884 lines
38 KiB
C#
884 lines
38 KiB
C#
using UnityEngine;
|
|
using System;
|
|
using System.Collections;
|
|
using AppleHills.Core.Settings;
|
|
using Core;
|
|
using UnityEngine.Audio;
|
|
|
|
namespace Minigames.DivingForPictures.PictureCamera
|
|
{
|
|
/// <summary>
|
|
/// Manages the camera viewfinder visual representation and animation
|
|
/// Responsible only for visual aspects with no game logic
|
|
/// </summary>
|
|
public class CameraViewfinderManager : MonoBehaviour
|
|
{
|
|
// Singleton instance
|
|
private static CameraViewfinderManager _instance;
|
|
public static CameraViewfinderManager Instance
|
|
{
|
|
get
|
|
{
|
|
if (_instance == null && Application.isPlaying)
|
|
{
|
|
_instance = FindAnyObjectByType<CameraViewfinderManager>();
|
|
if (_instance == null)
|
|
{
|
|
var go = new GameObject("CameraViewfinderManager");
|
|
_instance = go.AddComponent<CameraViewfinderManager>();
|
|
}
|
|
}
|
|
|
|
return _instance;
|
|
}
|
|
}
|
|
|
|
[Header("References")] [Tooltip("The Canvas to spawn the viewfinder UI on")] [SerializeField]
|
|
private Canvas targetCanvas;
|
|
|
|
// References
|
|
private GameObject viewfinderInstance;
|
|
private RectTransform viewfinderRectTransform;
|
|
private Viewfinder viewfinderComponent;
|
|
private UnityEngine.Camera mainCamera;
|
|
private AudioSource _audioSource;
|
|
|
|
// Animation state
|
|
private float animationProgress = 0f;
|
|
private bool isAnimating = false;
|
|
private bool isReversePhase = false; // Whether we're in the zoom-out phase
|
|
private float currentProximity = 0f; // How close we are to the target (0=far, 1=directly over target)
|
|
private Transform targetTransform;
|
|
private Coroutine animationCoroutine;
|
|
|
|
// Target position and size (calculated once at start)
|
|
private Vector3 targetScreenPosition;
|
|
private float targetViewfinderSize;
|
|
private Vector2 targetAnchoredPosition; // target position in canvas units
|
|
|
|
// Store settings
|
|
private IDivingMinigameSettings settings;
|
|
|
|
// New field to store the current input mode
|
|
private PhotoInputModes currentInputMode;
|
|
|
|
public AudioResource flashSound;
|
|
public AudioResource focusSound;
|
|
|
|
// Events for progress milestones
|
|
public event Action<float> OnProgressUpdated; // Continuous progress updates (0-1)
|
|
public event Action OnAnimationStarted;
|
|
public event Action OnAnimationCompleted;
|
|
public event Action OnReverseAnimationStarted; // New event for when zoom-out phase starts
|
|
public event Action<float> OnProximityUpdated; // New event for proximity updates
|
|
public event Action<float> OnProgressThresholdReached; // Fires at configured thresholds (25%, 50%, etc.)
|
|
public event Action OnViewfinderTapped; // Event when viewfinder is tapped during normal display
|
|
public event Action<float> OnViewfinderTappedDuringAnimation; // Event when viewfinder is tapped during animation (with proximity)
|
|
|
|
private void Awake()
|
|
{
|
|
if (_instance == null)
|
|
{
|
|
_instance = this;
|
|
}
|
|
else if (_instance != this)
|
|
{
|
|
Destroy(gameObject);
|
|
}
|
|
}
|
|
|
|
private void Start()
|
|
{
|
|
settings = GameManager.GetSettingsObject<IDivingMinigameSettings>();
|
|
mainCamera = UnityEngine.Camera.main;
|
|
_audioSource = GetComponent<AudioSource>();
|
|
|
|
// Get the photo input mode from settings
|
|
currentInputMode = settings.PhotoInputMode;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Begin the viewfinder animation targeting a specific transform
|
|
/// </summary>
|
|
/// <param name="target">The transform to focus on (usually the monster)</param>
|
|
public void StartViewfinderAnimation(Transform target)
|
|
{
|
|
if (isAnimating)
|
|
{
|
|
StopViewfinderAnimation();
|
|
}
|
|
|
|
if (settings.ViewfinderPrefab == null)
|
|
{
|
|
Debug.LogError("[CameraViewfinderManager] No viewfinder prefab assigned!");
|
|
return;
|
|
}
|
|
|
|
if (targetCanvas == null)
|
|
{
|
|
Debug.LogError("[CameraViewfinderManager] No canvas assigned!");
|
|
return;
|
|
}
|
|
|
|
targetTransform = target;
|
|
|
|
// Calculate target screen position and size only once at the start
|
|
CalculateTargetScreenPositionAndSize();
|
|
|
|
// Create viewfinder as UI element
|
|
viewfinderInstance = Instantiate(settings.ViewfinderPrefab, targetCanvas.transform);
|
|
viewfinderRectTransform = viewfinderInstance.GetComponent<RectTransform>();
|
|
viewfinderComponent = viewfinderInstance.GetComponent<Viewfinder>();
|
|
if (viewfinderRectTransform == null)
|
|
{
|
|
Debug.LogError("[CameraViewfinderManager] Viewfinder prefab doesn't have a RectTransform component!");
|
|
Destroy(viewfinderInstance);
|
|
return;
|
|
}
|
|
|
|
// Initialize viewfinder with a reference to this manager
|
|
if (viewfinderComponent != null)
|
|
{
|
|
viewfinderComponent.Initialize(this);
|
|
viewfinderComponent.SetupInputOverride();
|
|
InitializeViewfinder(viewfinderComponent);
|
|
}
|
|
|
|
// Reset state
|
|
animationProgress = 0f;
|
|
isAnimating = true;
|
|
|
|
// Determine canvas width for CanvasScaler-consistent sizing
|
|
RectTransform canvasRect = targetCanvas.transform as RectTransform;
|
|
float canvasWidth = canvasRect != null ? canvasRect.rect.width : Screen.width;
|
|
|
|
// Initialize viewfinder size and position to full canvas width (square) at center
|
|
float startSize = canvasWidth;
|
|
viewfinderRectTransform.sizeDelta = new Vector2(startSize, startSize);
|
|
viewfinderRectTransform.anchorMin = new Vector2(0.5f, 0.5f);
|
|
viewfinderRectTransform.anchorMax = new Vector2(0.5f, 0.5f);
|
|
viewfinderRectTransform.pivot = new Vector2(0.5f, 0.5f);
|
|
viewfinderRectTransform.anchoredPosition = Vector2.zero;
|
|
|
|
// Compute target anchored position in canvas units from previously calculated screen position
|
|
targetAnchoredPosition = ScreenToAnchoredPosition(targetScreenPosition);
|
|
|
|
// Fire starting event
|
|
OnAnimationStarted?.Invoke();
|
|
|
|
// Start animation coroutine
|
|
animationCoroutine = StartCoroutine(AnimateViewfinder());
|
|
}
|
|
|
|
/// <summary>
|
|
/// Calculates the target screen position and size based on monster's sprite bounds
|
|
/// </summary>
|
|
private void CalculateTargetScreenPositionAndSize()
|
|
{
|
|
if (targetTransform == null || mainCamera == null) return;
|
|
|
|
RectTransform canvasRect = targetCanvas != null ? targetCanvas.transform as RectTransform : null;
|
|
if (canvasRect == null)
|
|
{
|
|
Debug.LogError("[CameraViewfinderManager] Target canvas RectTransform not found.");
|
|
return;
|
|
}
|
|
|
|
// Choose UI camera for coordinate conversion
|
|
Camera uiCamera = null;
|
|
if (targetCanvas.renderMode == RenderMode.ScreenSpaceCamera ||
|
|
targetCanvas.renderMode == RenderMode.WorldSpace)
|
|
{
|
|
uiCamera = targetCanvas.worldCamera;
|
|
}
|
|
|
|
// Get sprite renderer from the monster
|
|
SpriteRenderer spriteRenderer = targetTransform.GetComponent<SpriteRenderer>();
|
|
if (spriteRenderer == null || spriteRenderer.sprite == null)
|
|
{
|
|
// Fallback to transform position and default size if no sprite renderer
|
|
targetScreenPosition = mainCamera.WorldToScreenPoint(targetTransform.position);
|
|
// Convert to anchored UI position
|
|
RectTransformUtility.ScreenPointToLocalPointInRectangle(canvasRect, targetScreenPosition, uiCamera,
|
|
out targetAnchoredPosition);
|
|
|
|
// Default size: fraction of canvas width (canvas units)
|
|
float canvasWidth = canvasRect.rect.width;
|
|
targetViewfinderSize = canvasWidth * 0.25f;
|
|
|
|
Logging.Warning("[CameraViewfinderManager] No SpriteRenderer found on target, using default size");
|
|
return;
|
|
}
|
|
|
|
// Calculate world bounds of the sprite and apply padding
|
|
Bounds spriteBounds = spriteRenderer.bounds;
|
|
Vector3 paddedSize = spriteBounds.size * settings.PaddingFactor;
|
|
Bounds paddedBounds = new Bounds(spriteBounds.center, paddedSize);
|
|
|
|
// Convert bounds corners to screen space
|
|
Vector3[] worldCorners = new Vector3[4];
|
|
worldCorners[0] = new Vector3(paddedBounds.min.x, paddedBounds.min.y, paddedBounds.center.z); // BL
|
|
worldCorners[1] = new Vector3(paddedBounds.max.x, paddedBounds.min.y, paddedBounds.center.z); // BR
|
|
worldCorners[2] = new Vector3(paddedBounds.min.x, paddedBounds.max.y, paddedBounds.center.z); // TL
|
|
worldCorners[3] = new Vector3(paddedBounds.max.x, paddedBounds.max.y, paddedBounds.center.z); // TR
|
|
|
|
// Convert screen-space corners to canvas local points (canvas units)
|
|
bool anyFailed = false;
|
|
Vector2[] localCorners = new Vector2[4];
|
|
for (int i = 0; i < 4; i++)
|
|
{
|
|
Vector3 screenPos = mainCamera.WorldToScreenPoint(worldCorners[i]);
|
|
if (!RectTransformUtility.ScreenPointToLocalPointInRectangle(canvasRect, screenPos, uiCamera,
|
|
out localCorners[i]))
|
|
{
|
|
anyFailed = true;
|
|
}
|
|
}
|
|
|
|
// Fallback: if conversion failed for some reason, keep original behavior (pixels -> clamp -> convert later)
|
|
if (anyFailed)
|
|
{
|
|
Vector2 minScreen = new Vector2(float.MaxValue, float.MaxValue);
|
|
Vector2 maxScreen = new Vector2(float.MinValue, float.MinValue);
|
|
foreach (Vector3 corner in worldCorners)
|
|
{
|
|
Vector3 sp = mainCamera.WorldToScreenPoint(corner);
|
|
minScreen.x = Mathf.Min(minScreen.x, sp.x);
|
|
minScreen.y = Mathf.Min(minScreen.y, sp.y);
|
|
maxScreen.x = Mathf.Max(maxScreen.x, sp.x);
|
|
maxScreen.y = Mathf.Max(maxScreen.y, sp.y);
|
|
}
|
|
|
|
float widthPx = maxScreen.x - minScreen.x;
|
|
float heightPx = maxScreen.y - minScreen.y;
|
|
float canvasWidth = canvasRect.rect.width;
|
|
float scaleX = Screen.width > 0 ? canvasWidth / Screen.width : 1f;
|
|
targetViewfinderSize = Mathf.Max(widthPx, heightPx) * scaleX; // approximate conversion
|
|
float minCanvas = canvasWidth * settings.MinSizePercent;
|
|
float maxCanvas = canvasWidth * settings.MaxSizePercent;
|
|
targetViewfinderSize = Mathf.Clamp(targetViewfinderSize, minCanvas, maxCanvas);
|
|
|
|
// Target position
|
|
targetScreenPosition = mainCamera.WorldToScreenPoint(spriteBounds.center);
|
|
RectTransformUtility.ScreenPointToLocalPointInRectangle(canvasRect, targetScreenPosition, uiCamera,
|
|
out targetAnchoredPosition);
|
|
return;
|
|
}
|
|
|
|
// Compute width/height in canvas units from local corners
|
|
float minX = float.MaxValue, minY = float.MaxValue, maxX = float.MinValue, maxY = float.MinValue;
|
|
for (int i = 0; i < 4; i++)
|
|
{
|
|
minX = Mathf.Min(minX, localCorners[i].x);
|
|
minY = Mathf.Min(minY, localCorners[i].y);
|
|
maxX = Mathf.Max(maxX, localCorners[i].x);
|
|
maxY = Mathf.Max(maxY, localCorners[i].y);
|
|
}
|
|
|
|
float widthCanvas = Mathf.Max(0f, maxX - minX);
|
|
float heightCanvas = Mathf.Max(0f, maxY - minY);
|
|
float canvasSquare = Mathf.Max(widthCanvas, heightCanvas);
|
|
|
|
// Clamp using canvas width
|
|
float canvasW = canvasRect.rect.width;
|
|
float minSizeCanvas = canvasW * settings.MinSizePercent;
|
|
float maxSizeCanvas = canvasW * settings.MaxSizePercent;
|
|
targetViewfinderSize = Mathf.Clamp(canvasSquare, minSizeCanvas, maxSizeCanvas);
|
|
|
|
// Target position in both screen and canvas units
|
|
targetScreenPosition = mainCamera.WorldToScreenPoint(spriteBounds.center);
|
|
RectTransformUtility.ScreenPointToLocalPointInRectangle(canvasRect, targetScreenPosition, uiCamera,
|
|
out targetAnchoredPosition);
|
|
|
|
Logging.Debug(
|
|
$"[CameraViewfinderManager] Target size (canvas): {targetViewfinderSize}, target anchored: {targetAnchoredPosition}");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Stop the current viewfinder animation and clean up
|
|
/// </summary>
|
|
public void StopViewfinderAnimation()
|
|
{
|
|
if (animationCoroutine != null)
|
|
{
|
|
StopCoroutine(animationCoroutine);
|
|
animationCoroutine = null;
|
|
}
|
|
|
|
if (viewfinderInstance != null)
|
|
{
|
|
Destroy(viewfinderInstance);
|
|
viewfinderInstance = null;
|
|
}
|
|
|
|
isAnimating = false;
|
|
targetTransform = null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Coroutine that handles the viewfinder animation
|
|
/// </summary>
|
|
private IEnumerator AnimateViewfinder()
|
|
{
|
|
RectTransform canvasRect = targetCanvas.transform as RectTransform;
|
|
float canvasWidth = canvasRect != null ? canvasRect.rect.width : Screen.width;
|
|
|
|
// IMPORTANT: We're animating from full canvas width DOWN to the target size
|
|
float startSize = canvasWidth; // Always start with full canvas width
|
|
float endSize = targetViewfinderSize; // End at the calculated target size
|
|
|
|
float elapsedTime = 0f;
|
|
bool[] thresholdTriggered = new bool[settings.ViewfinderProgressThresholds.Length];
|
|
|
|
// Debug the actual values
|
|
Logging.Debug($"[CameraViewfinderManager] Animation starting: startSize={startSize}, endSize={endSize}, " +
|
|
$"current sizeDelta={viewfinderRectTransform.sizeDelta}");
|
|
|
|
// Verify the initial size is set correctly
|
|
viewfinderRectTransform.sizeDelta = new Vector2(startSize, startSize);
|
|
|
|
while (elapsedTime < settings.ViewfinderShrinkDuration)
|
|
{
|
|
if (targetTransform == null)
|
|
{
|
|
StopViewfinderAnimation();
|
|
yield break;
|
|
}
|
|
|
|
elapsedTime += Time.unscaledDeltaTime;
|
|
animationProgress = Mathf.Clamp01(elapsedTime / settings.ViewfinderShrinkDuration);
|
|
|
|
// The curve value might be inverted - ensure we're shrinking not growing
|
|
float curveValue = settings.ViewfinderShrinkCurve.Evaluate(animationProgress);
|
|
|
|
// FIX: Ensure we're interpolating from large (start) to small (end)
|
|
// This is critical - we must ensure the start and end are in the right order
|
|
float currentSize = Mathf.Lerp(startSize, endSize, curveValue);
|
|
|
|
// Additional check to ensure size is actually shrinking
|
|
if (startSize > endSize && currentSize > startSize)
|
|
{
|
|
Logging.Warning($"[CameraViewfinderManager] Animation curve producing wrong direction! " +
|
|
$"progress={animationProgress:F2}, curveValue={curveValue:F2}");
|
|
// Force correct behavior
|
|
curveValue = animationProgress; // Override with linear interpolation
|
|
currentSize = Mathf.Lerp(startSize, endSize, curveValue);
|
|
}
|
|
|
|
viewfinderRectTransform.sizeDelta = new Vector2(currentSize, currentSize);
|
|
|
|
// Move in UI space towards the anchored target position
|
|
Vector2 currentPos = viewfinderRectTransform.anchoredPosition;
|
|
Vector2 newPos = Vector2.Lerp(currentPos, targetAnchoredPosition,
|
|
settings.ViewfinderMoveSpeed * Time.unscaledDeltaTime);
|
|
viewfinderRectTransform.anchoredPosition = newPos;
|
|
|
|
// Log the animation state occasionally for debugging
|
|
if (animationProgress % 0.25f <= 0.01f || animationProgress >= 0.99f)
|
|
{
|
|
Logging.Debug($"[CameraViewfinderManager] Animation progress: {animationProgress:F2}, " +
|
|
$"curveValue={curveValue:F2}, currentSize={currentSize:F2}, currentPos={newPos}");
|
|
}
|
|
|
|
for (int i = 0; i < settings.ViewfinderProgressThresholds.Length; i++)
|
|
{
|
|
if (!thresholdTriggered[i] && animationProgress >= settings.ViewfinderProgressThresholds[i])
|
|
{
|
|
thresholdTriggered[i] = true;
|
|
OnProgressThresholdReached?.Invoke(settings.ViewfinderProgressThresholds[i]);
|
|
}
|
|
}
|
|
|
|
OnProgressUpdated?.Invoke(animationProgress);
|
|
yield return null;
|
|
}
|
|
|
|
// Ensure we reach the exact end size
|
|
viewfinderRectTransform.sizeDelta = new Vector2(endSize, endSize);
|
|
|
|
animationProgress = 1f;
|
|
OnProgressUpdated?.Invoke(animationProgress);
|
|
OnAnimationCompleted?.Invoke();
|
|
|
|
// Log final state to confirm we reached the target size
|
|
Logging.Debug(
|
|
$"[CameraViewfinderManager] Animation completed: final size={viewfinderRectTransform.sizeDelta}");
|
|
|
|
yield return new WaitForSecondsRealtime(0.5f);
|
|
StopViewfinderAnimation();
|
|
}
|
|
|
|
// Converts a screen-space point to a RectTransform anchoredPosition for the target canvas
|
|
private Vector2 ScreenToAnchoredPosition(Vector3 screenPosition)
|
|
{
|
|
if (targetCanvas == null)
|
|
{
|
|
return new Vector2(screenPosition.x, screenPosition.y);
|
|
}
|
|
|
|
RectTransform canvasRect = targetCanvas.transform as RectTransform;
|
|
Camera uiCamera = null;
|
|
if (targetCanvas.renderMode == RenderMode.ScreenSpaceCamera ||
|
|
targetCanvas.renderMode == RenderMode.WorldSpace)
|
|
{
|
|
uiCamera = targetCanvas.worldCamera;
|
|
}
|
|
|
|
Vector2 localPoint;
|
|
RectTransformUtility.ScreenPointToLocalPointInRectangle(canvasRect, screenPosition, uiCamera,
|
|
out localPoint);
|
|
return localPoint;
|
|
}
|
|
|
|
private void OnDestroy()
|
|
{
|
|
StopViewfinderAnimation();
|
|
|
|
if (_instance == this)
|
|
{
|
|
_instance = null;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Handles tap event from the viewfinder and forwards it
|
|
/// </summary>
|
|
private void HandleViewfinderTapped()
|
|
{
|
|
// Forward the tap event to any listeners
|
|
OnViewfinderTapped?.Invoke();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Hides the currently displayed viewfinder
|
|
/// </summary>
|
|
public void HideViewfinder()
|
|
{
|
|
if (viewfinderInstance != null)
|
|
{
|
|
viewfinderComponent.RemoveInputOverride();
|
|
|
|
// Unsubscribe from all viewfinder events
|
|
if (viewfinderComponent != null)
|
|
{
|
|
viewfinderComponent.OnViewfinderTapped -= HandleViewfinderTapped;
|
|
viewfinderComponent.OnViewfinderTapped -= HandleViewfinderTappedDuringAnimation;
|
|
viewfinderComponent.OnViewfinderHoldStarted -= HandleViewfinderHoldStarted;
|
|
viewfinderComponent.OnViewfinderHoldEnded -= HandleViewfinderHoldEnded;
|
|
}
|
|
|
|
Destroy(viewfinderInstance);
|
|
viewfinderInstance = null;
|
|
viewfinderComponent = null;
|
|
viewfinderRectTransform = null;
|
|
Logging.Debug("[CameraViewfinderManager] Hid viewfinder");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Shows the viewfinder in the middle of the screen at full size without animation
|
|
/// This is the first step in the two-step process, showing the UI without targeting a monster yet
|
|
/// </summary>
|
|
public void ShowFullScreenViewfinder()
|
|
{
|
|
if (viewfinderInstance != null)
|
|
{
|
|
// Already showing a viewfinder, destroy it first
|
|
Destroy(viewfinderInstance);
|
|
}
|
|
|
|
if (settings.ViewfinderPrefab == null)
|
|
{
|
|
Debug.LogError("[CameraViewfinderManager] No viewfinder prefab assigned!");
|
|
return;
|
|
}
|
|
|
|
if (targetCanvas == null)
|
|
{
|
|
Debug.LogError("[CameraViewfinderManager] No canvas assigned!");
|
|
return;
|
|
}
|
|
|
|
isAnimating = false;
|
|
|
|
// Create viewfinder as UI element
|
|
viewfinderInstance = Instantiate(settings.ViewfinderPrefab, targetCanvas.transform);
|
|
viewfinderRectTransform = viewfinderInstance.GetComponent<RectTransform>();
|
|
viewfinderComponent = viewfinderInstance.GetComponent<Viewfinder>();
|
|
|
|
if (viewfinderRectTransform == null)
|
|
{
|
|
Debug.LogError("[CameraViewfinderManager] Viewfinder prefab doesn't have a RectTransform component!");
|
|
Destroy(viewfinderInstance);
|
|
return;
|
|
}
|
|
|
|
// Initialize viewfinder with a reference to this manager
|
|
if (viewfinderComponent != null)
|
|
{
|
|
viewfinderComponent.Initialize(this);
|
|
viewfinderComponent.SetupInputOverride();
|
|
InitializeViewfinder(viewfinderComponent);
|
|
}
|
|
|
|
// Determine canvas width for full-screen sizing
|
|
RectTransform canvasRect = targetCanvas.transform as RectTransform;
|
|
float canvasWidth = canvasRect != null ? canvasRect.rect.width : Screen.width;
|
|
|
|
// Set up the viewfinder in the center of the screen at full canvas width
|
|
viewfinderRectTransform.anchorMin = new Vector2(0.5f, 0.5f);
|
|
viewfinderRectTransform.anchorMax = new Vector2(0.5f, 0.5f);
|
|
viewfinderRectTransform.pivot = new Vector2(0.5f, 0.5f);
|
|
viewfinderRectTransform.sizeDelta = new Vector2(canvasWidth, canvasWidth);
|
|
viewfinderRectTransform.anchoredPosition = Vector2.zero;
|
|
|
|
Logging.Debug($"[CameraViewfinderManager] Showed full-screen viewfinder with size {canvasWidth}");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Starts the complete viewfinder animation sequence (zoom in, then zoom out)
|
|
/// </summary>
|
|
/// <param name="target">The transform to focus on (usually the monster)</param>
|
|
public void StartViewfinderSequence(Transform target)
|
|
{
|
|
if (isAnimating)
|
|
{
|
|
StopViewfinderAnimation();
|
|
}
|
|
|
|
if (settings.ViewfinderPrefab == null)
|
|
{
|
|
Debug.LogError("[CameraViewfinderManager] No viewfinder prefab assigned!");
|
|
return;
|
|
}
|
|
|
|
if (targetCanvas == null)
|
|
{
|
|
Debug.LogError("[CameraViewfinderManager] No canvas assigned!");
|
|
return;
|
|
}
|
|
|
|
targetTransform = target;
|
|
isReversePhase = false;
|
|
currentProximity = 0f;
|
|
PlayFocusSound();
|
|
|
|
// Calculate target screen position and size based on monster's sprite bounds
|
|
CalculateTargetScreenPositionAndSize();
|
|
|
|
// Reuse existing viewfinder instance if it exists
|
|
if (viewfinderInstance == null)
|
|
{
|
|
// Create viewfinder as UI element if it doesn't exist yet
|
|
viewfinderInstance = Instantiate(settings.ViewfinderPrefab, targetCanvas.transform);
|
|
viewfinderRectTransform = viewfinderInstance.GetComponent<RectTransform>();
|
|
viewfinderComponent = viewfinderInstance.GetComponent<Viewfinder>();
|
|
|
|
if (viewfinderRectTransform == null)
|
|
{
|
|
Debug.LogError("[CameraViewfinderManager] Viewfinder prefab doesn't have a RectTransform component!");
|
|
Destroy(viewfinderInstance);
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Unsubscribe from any existing event to prevent multiple subscriptions
|
|
if (viewfinderComponent != null)
|
|
{
|
|
viewfinderComponent.OnViewfinderTapped -= HandleViewfinderTapped;
|
|
viewfinderComponent.OnViewfinderTapped -= HandleViewfinderTappedDuringAnimation;
|
|
}
|
|
|
|
// Subscribe to the viewfinder's tap event for interrupting the animation
|
|
viewfinderComponent.OnViewfinderTapped += HandleViewfinderTappedDuringAnimation;
|
|
}
|
|
|
|
// Initialize viewfinder with appropriate event handlers based on input mode
|
|
if (viewfinderComponent != null)
|
|
{
|
|
viewfinderComponent.Initialize(this);
|
|
viewfinderComponent.SetupInputOverride();
|
|
InitializeViewfinder(viewfinderComponent);
|
|
|
|
// For animation sequence, we need additional handling for tapping during animation
|
|
if (currentInputMode == PhotoInputModes.Tap)
|
|
{
|
|
viewfinderComponent.OnViewfinderTapped += HandleViewfinderTappedDuringAnimation;
|
|
}
|
|
}
|
|
|
|
// Reset state
|
|
animationProgress = 0f;
|
|
isAnimating = true;
|
|
|
|
// Determine canvas width for CanvasScaler-consistent sizing
|
|
RectTransform canvasRect = targetCanvas.transform as RectTransform;
|
|
float canvasWidth = canvasRect != null ? canvasRect.rect.width : Screen.width;
|
|
|
|
// Initialize viewfinder size and position to full canvas width (square) at center
|
|
float startSize = canvasWidth;
|
|
viewfinderRectTransform.sizeDelta = new Vector2(startSize, startSize);
|
|
viewfinderRectTransform.anchorMin = new Vector2(0.5f, 0.5f);
|
|
viewfinderRectTransform.anchorMax = new Vector2(0.5f, 0.5f);
|
|
viewfinderRectTransform.pivot = new Vector2(0.5f, 0.5f);
|
|
viewfinderRectTransform.anchoredPosition = Vector2.zero;
|
|
|
|
// Compute target anchored position in canvas units from previously calculated screen position
|
|
targetAnchoredPosition = ScreenToAnchoredPosition(targetScreenPosition);
|
|
|
|
// Fire starting event
|
|
OnAnimationStarted?.Invoke();
|
|
|
|
// Start sequence coroutine
|
|
animationCoroutine = StartCoroutine(AnimateViewfinderSequence());
|
|
}
|
|
|
|
/// <summary>
|
|
/// Coroutine that handles the complete viewfinder animation sequence (zoom in, then zoom out)
|
|
/// </summary>
|
|
private IEnumerator AnimateViewfinderSequence()
|
|
{
|
|
RectTransform canvasRect = targetCanvas.transform as RectTransform;
|
|
float canvasWidth = canvasRect != null ? canvasRect.rect.width : Screen.width;
|
|
|
|
// Phase 1: Zoom in (from full screen to monster)
|
|
float startSize = canvasWidth; // Always start with full canvas width
|
|
float endSize = targetViewfinderSize; // End at the calculated target size
|
|
Vector2 startPos = Vector2.zero; // Center of screen
|
|
Vector2 endPos = targetAnchoredPosition; // Target position
|
|
|
|
float elapsedTime = 0f;
|
|
bool[] thresholdTriggered = new bool[settings.ViewfinderProgressThresholds.Length];
|
|
|
|
// Debug the actual values
|
|
Logging.Debug($"[CameraViewfinderManager] Animation sequence starting: startSize={startSize}, endSize={endSize}");
|
|
|
|
// Verify the initial size is set correctly
|
|
viewfinderRectTransform.sizeDelta = new Vector2(startSize, startSize);
|
|
|
|
// Phase 1: Zoom In
|
|
while (elapsedTime < settings.ViewfinderShrinkDuration && !isReversePhase)
|
|
{
|
|
if (targetTransform == null)
|
|
{
|
|
StopViewfinderAnimation();
|
|
yield break;
|
|
}
|
|
|
|
elapsedTime += Time.unscaledDeltaTime;
|
|
animationProgress = Mathf.Clamp01(elapsedTime / settings.ViewfinderShrinkDuration);
|
|
|
|
// Calculate proximity - it increases as we get closer to the target
|
|
currentProximity = animationProgress;
|
|
OnProximityUpdated?.Invoke(currentProximity);
|
|
|
|
// The curve value might be inverted - ensure we're shrinking not growing
|
|
float curveValue = settings.ViewfinderShrinkCurve.Evaluate(animationProgress);
|
|
|
|
// Interpolate size
|
|
float currentSize = Mathf.Lerp(startSize, endSize, curveValue);
|
|
viewfinderRectTransform.sizeDelta = new Vector2(currentSize, currentSize);
|
|
|
|
// Interpolate position
|
|
Vector2 currentPos = viewfinderRectTransform.anchoredPosition;
|
|
Vector2 newPos = Vector2.Lerp(startPos, endPos, curveValue);
|
|
viewfinderRectTransform.anchoredPosition = newPos;
|
|
|
|
// Log the animation state occasionally for debugging
|
|
if (animationProgress % 0.25f <= 0.01f || animationProgress >= 0.99f)
|
|
{
|
|
Logging.Debug($"[CameraViewfinderManager] Animation progress: {animationProgress:F2}, " +
|
|
$"curveValue={curveValue:F2}, currentSize={currentSize:F2}, currentPos={newPos}, proximity={currentProximity:F2}");
|
|
}
|
|
|
|
for (int i = 0; i < settings.ViewfinderProgressThresholds.Length; i++)
|
|
{
|
|
if (!thresholdTriggered[i] && animationProgress >= settings.ViewfinderProgressThresholds[i])
|
|
{
|
|
thresholdTriggered[i] = true;
|
|
OnProgressThresholdReached?.Invoke(settings.ViewfinderProgressThresholds[i]);
|
|
}
|
|
}
|
|
|
|
OnProgressUpdated?.Invoke(animationProgress);
|
|
yield return null;
|
|
}
|
|
|
|
// Ensure we reach the exact end size and position for phase 1
|
|
viewfinderRectTransform.sizeDelta = new Vector2(endSize, endSize);
|
|
viewfinderRectTransform.anchoredPosition = endPos;
|
|
currentProximity = 1.0f; // At target
|
|
OnProximityUpdated?.Invoke(currentProximity);
|
|
|
|
// Brief pause at target
|
|
yield return new WaitForSecondsRealtime(0.2f);
|
|
|
|
// Start phase 2 - reverse animation
|
|
isReversePhase = true;
|
|
OnReverseAnimationStarted?.Invoke();
|
|
|
|
// Reset for reverse phase
|
|
elapsedTime = 0f;
|
|
animationProgress = 0f;
|
|
|
|
// Phase 2: Zoom Out (from monster back to full screen)
|
|
while (elapsedTime < settings.ViewfinderShrinkDuration && isReversePhase)
|
|
{
|
|
if (targetTransform == null)
|
|
{
|
|
StopViewfinderAnimation();
|
|
yield break;
|
|
}
|
|
|
|
elapsedTime += Time.unscaledDeltaTime;
|
|
animationProgress = Mathf.Clamp01(elapsedTime / settings.ViewfinderShrinkDuration);
|
|
|
|
// Calculate proximity - it decreases as we move away from target
|
|
currentProximity = 1.0f - animationProgress;
|
|
OnProximityUpdated?.Invoke(currentProximity);
|
|
|
|
// The curve value for zooming out
|
|
float curveValue = settings.ViewfinderShrinkCurve.Evaluate(animationProgress);
|
|
|
|
// Interpolate size (now growing)
|
|
float currentSize = Mathf.Lerp(endSize, startSize, curveValue);
|
|
viewfinderRectTransform.sizeDelta = new Vector2(currentSize, currentSize);
|
|
|
|
// Interpolate position (now returning to center)
|
|
Vector2 currentPos = viewfinderRectTransform.anchoredPosition;
|
|
Vector2 newPos = Vector2.Lerp(endPos, startPos, curveValue);
|
|
viewfinderRectTransform.anchoredPosition = newPos;
|
|
|
|
// Log the animation state occasionally for debugging
|
|
if (animationProgress % 0.25f <= 0.01f || animationProgress >= 0.99f)
|
|
{
|
|
Logging.Debug($"[CameraViewfinderManager] Reverse animation progress: {animationProgress:F2}, " +
|
|
$"curveValue={curveValue:F2}, currentSize={currentSize:F2}, currentPos={newPos}, proximity={currentProximity:F2}");
|
|
}
|
|
|
|
OnProgressUpdated?.Invoke(animationProgress);
|
|
yield return null;
|
|
}
|
|
|
|
// Animation completed (both phases)
|
|
HandleViewfinderTappedDuringAnimation();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Handle tap events during animation (for capturing at current proximity)
|
|
/// </summary>
|
|
private void HandleViewfinderTappedDuringAnimation()
|
|
{
|
|
if (isAnimating)
|
|
{
|
|
// Fire event with current proximity value for scoring
|
|
OnViewfinderTappedDuringAnimation?.Invoke(currentProximity);
|
|
|
|
// Complete the animation immediately
|
|
if (animationCoroutine != null)
|
|
{
|
|
StopCoroutine(animationCoroutine);
|
|
animationCoroutine = null;
|
|
}
|
|
|
|
// Fire completed event
|
|
OnAnimationCompleted?.Invoke();
|
|
isAnimating = false;
|
|
isReversePhase = false;
|
|
|
|
// Hide the viewfinder on the second tap
|
|
HideViewfinder();
|
|
}
|
|
else
|
|
{
|
|
// Regular tap handling when not animating
|
|
HandleViewfinderTapped();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Initialize the viewfinder with appropriate event handlers based on input mode
|
|
/// </summary>
|
|
/// <param name="viewfinder">The viewfinder component to initialize</param>
|
|
public void InitializeViewfinder(Viewfinder viewfinder)
|
|
{
|
|
if (viewfinder != null)
|
|
{
|
|
// Clean up any existing event subscriptions
|
|
viewfinder.OnViewfinderTapped -= HandleViewfinderTapped;
|
|
viewfinder.OnViewfinderHoldStarted -= HandleViewfinderHoldStarted;
|
|
viewfinder.OnViewfinderHoldEnded -= HandleViewfinderHoldEnded;
|
|
|
|
// Set up handlers based on the current input mode
|
|
switch (currentInputMode)
|
|
{
|
|
case PhotoInputModes.Tap:
|
|
// For tap mode, only subscribe to tap events
|
|
viewfinder.OnViewfinderTapped += HandleViewfinderTapped;
|
|
break;
|
|
|
|
case PhotoInputModes.Hold:
|
|
// For hold mode, subscribe to hold start/end events
|
|
viewfinder.OnViewfinderHoldStarted += HandleViewfinderHoldStarted;
|
|
viewfinder.OnViewfinderHoldEnded += HandleViewfinderHoldEnded;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Handles hold start event from the viewfinder
|
|
/// </summary>
|
|
private void HandleViewfinderHoldStarted()
|
|
{
|
|
if (currentInputMode == PhotoInputModes.Hold)
|
|
{
|
|
// Start the photo sequence when hold begins (same behavior as first tap in tap mode)
|
|
OnViewfinderTapped?.Invoke();
|
|
Logging.Debug("[CameraViewfinderManager] Hold started - initiating photo sequence");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Handles hold end event from the viewfinder
|
|
/// </summary>
|
|
private void HandleViewfinderHoldEnded()
|
|
{
|
|
if (currentInputMode == PhotoInputModes.Hold && isAnimating)
|
|
{
|
|
// Complete the sequence when hold ends (same behavior as second tap in tap mode)
|
|
OnViewfinderTappedDuringAnimation?.Invoke(currentProximity);
|
|
Logging.Debug("[CameraViewfinderManager] Hold ended - completing photo sequence with proximity: " + currentProximity);
|
|
|
|
// Complete the animation immediately
|
|
if (animationCoroutine != null)
|
|
{
|
|
StopCoroutine(animationCoroutine);
|
|
animationCoroutine = null;
|
|
}
|
|
|
|
// Fire completed event
|
|
OnAnimationCompleted?.Invoke();
|
|
isAnimating = false;
|
|
isReversePhase = false;
|
|
HideViewfinder();
|
|
}
|
|
}
|
|
|
|
public void PlayShutterSound()
|
|
{
|
|
_audioSource.Stop();
|
|
_audioSource.resource = flashSound;
|
|
_audioSource.Play();
|
|
}
|
|
|
|
private void PlayFocusSound()
|
|
{
|
|
_audioSource.Stop();
|
|
_audioSource.resource = focusSound;
|
|
_audioSource.Play();
|
|
}
|
|
}
|
|
}
|