773 lines
29 KiB
C#
773 lines
29 KiB
C#
using UnityEngine;
|
|
using System.Collections.Generic;
|
|
using System;
|
|
using System.Collections;
|
|
using UnityEngine.Events;
|
|
using UnityEngine.Playables;
|
|
using AppleHills.Core.Settings;
|
|
using Utility;
|
|
using AppleHills.Core.Interfaces;
|
|
using UI;
|
|
|
|
namespace Minigames.DivingForPictures
|
|
{
|
|
public class DivingGameManager : MonoBehaviour, IPausable
|
|
{
|
|
[Header("Monster Prefabs")]
|
|
[Tooltip("Array of monster prefabs to spawn randomly")]
|
|
[SerializeField] private GameObject[] monsterPrefabs;
|
|
|
|
[Header("Rope Damage System")]
|
|
[Tooltip("Ropes that will break one by one as player takes damage")]
|
|
[SerializeField] private RopeBreaker[] playerRopes;
|
|
|
|
[Header("Surfacing Settings")]
|
|
[Tooltip("Reference to the PlayableDirector that will play the surfacing timeline")]
|
|
[SerializeField] private PlayableDirector surfacingTimeline;
|
|
|
|
// Settings reference
|
|
private IDivingMinigameSettings _settings;
|
|
|
|
// Private state variables
|
|
private int playerScore = 0;
|
|
private float currentSpawnProbability;
|
|
private float lastSpawnTime = -100f;
|
|
private float timeSinceLastSpawn = 0f;
|
|
private List<Monster> activeMonsters = new List<Monster>();
|
|
|
|
// Velocity management
|
|
// Velocity state tracking
|
|
private float _currentVelocityFactor = 1.0f; // 1.0 = normal descent speed, -1.0 * surfacingSpeedFactor = full surfacing speed
|
|
private Coroutine _velocityTransitionCoroutine;
|
|
private Coroutine _surfacingSequenceCoroutine;
|
|
|
|
// Public properties
|
|
public int PlayerScore => playerScore;
|
|
public float CurrentVelocityFactor => _currentVelocityFactor;
|
|
|
|
// Events
|
|
public event Action<int> OnScoreChanged;
|
|
public event Action<Monster> OnMonsterSpawned;
|
|
public event Action<Monster, int> OnPictureTaken;
|
|
public event Action<float> OnSpawnProbabilityChanged;
|
|
public event Action OnGameOver;
|
|
public event Action<int> OnRopeBroken; // Passes remaining ropes count
|
|
public event Action<float> OnVelocityFactorChanged;
|
|
|
|
// Private state variables for rope system
|
|
private int currentRopeIndex = 0;
|
|
private bool isGameOver = false;
|
|
private bool _isSurfacing = false;
|
|
|
|
// Initialization state
|
|
private bool _isGameInitialized = false;
|
|
|
|
// Used to track if we're currently surfacing
|
|
public bool IsSurfacing => _isSurfacing;
|
|
|
|
// Event for game components to subscribe to
|
|
public event Action OnGameInitialized;
|
|
|
|
// Pause state
|
|
private bool _isPaused = false;
|
|
|
|
// List of pausable components controlled by this manager
|
|
private List<IPausable> _pausableComponents = new List<IPausable>();
|
|
|
|
// IPausable implementation
|
|
public bool IsPaused => _isPaused;
|
|
|
|
private void Awake()
|
|
{
|
|
// Get settings from GameManager
|
|
_settings = GameManager.GetSettingsObject<IDivingMinigameSettings>();
|
|
if (_settings == null)
|
|
{
|
|
Debug.LogError("[DivingGameManager] Failed to load diving minigame settings!");
|
|
}
|
|
|
|
// Initialize with base probability from settings
|
|
currentSpawnProbability = _settings?.BaseSpawnProbability ?? 0.2f;
|
|
}
|
|
|
|
private void Start()
|
|
{
|
|
// Find PauseMenu and subscribe to its events
|
|
PauseMenu pauseMenu = PauseMenu.Instance;
|
|
if (pauseMenu != null)
|
|
{
|
|
pauseMenu.OnGamePaused += Pause;
|
|
pauseMenu.OnGameResumed += Resume;
|
|
|
|
Debug.Log("[DivingGameManager] Subscribed to PauseMenu events");
|
|
}
|
|
else
|
|
{
|
|
Debug.LogWarning("[DivingGameManager] PauseMenu not found. Pause functionality won't work properly.");
|
|
}
|
|
|
|
// Register this manager with the global GameManager
|
|
if (GameManager.Instance != null)
|
|
{
|
|
GameManager.Instance.RegisterPausableComponent(this);
|
|
}
|
|
|
|
// Subscribe to SceneOrientationEnforcer's event
|
|
if (SceneOrientationEnforcer.Instance != null)
|
|
{
|
|
SceneOrientationEnforcer.Instance.OnOrientationCorrect += InitializeGame;
|
|
|
|
// If orientation is already correct, initialize right away
|
|
// This prevents issues if the orientation was already correct before subscription
|
|
if (SceneOrientationEnforcer.Instance.IsOrientationCorrect())
|
|
{
|
|
InitializeGame();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Debug.LogWarning("[DivingGameManager] SceneOrientationEnforcer not found. Initializing game immediately.");
|
|
InitializeGame();
|
|
}
|
|
|
|
// Subscribe to player damage events (this doesn't depend on initialization)
|
|
PlayerCollisionBehavior.OnDamageTaken += OnPlayerDamageTaken;
|
|
|
|
// Validate rope references (this doesn't depend on initialization)
|
|
ValidateRopeReferences();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Initializes the game components once the orientation is correct.
|
|
/// This is called by SceneOrientationEnforcer when the device is properly oriented.
|
|
/// </summary>
|
|
public void InitializeGame()
|
|
{
|
|
// Prevent double initialization
|
|
if (_isGameInitialized) return;
|
|
|
|
Debug.Log("[DivingGameManager] Initializing game");
|
|
|
|
// Subscribe to tile spawned event
|
|
TrenchTileSpawner tileSpawner = FindFirstObjectByType<TrenchTileSpawner>();
|
|
if (tileSpawner != null)
|
|
{
|
|
tileSpawner.onTileSpawned.AddListener(OnTileSpawned);
|
|
}
|
|
else
|
|
{
|
|
Debug.LogWarning("No TrenchTileSpawner found in scene. Monster spawning won't work.");
|
|
}
|
|
|
|
// Mark as initialized
|
|
_isGameInitialized = true;
|
|
|
|
// Notify all listeners that the game is initialized
|
|
OnGameInitialized?.Invoke();
|
|
}
|
|
|
|
private void OnDestroy()
|
|
{
|
|
// Unsubscribe from events when the manager is destroyed
|
|
PlayerCollisionBehavior.OnDamageTaken -= OnPlayerDamageTaken;
|
|
|
|
if (SceneOrientationEnforcer.Instance != null)
|
|
{
|
|
SceneOrientationEnforcer.Instance.OnOrientationCorrect -= InitializeGame;
|
|
}
|
|
|
|
// Unsubscribe from PauseMenu events
|
|
PauseMenu pauseMenu = PauseMenu.Instance;
|
|
if (pauseMenu != null)
|
|
{
|
|
pauseMenu.OnGamePaused -= Pause;
|
|
pauseMenu.OnGameResumed -= Resume;
|
|
}
|
|
|
|
// Unregister from GameManager
|
|
if (GameManager.Instance != null)
|
|
{
|
|
GameManager.Instance.UnregisterPausableComponent(this);
|
|
}
|
|
|
|
// Unregister all pausable components
|
|
_pausableComponents.Clear();
|
|
}
|
|
|
|
private void Update()
|
|
{
|
|
timeSinceLastSpawn += Time.deltaTime;
|
|
|
|
// Gradually increase spawn probability over time
|
|
float previousProbability = currentSpawnProbability;
|
|
if (currentSpawnProbability < _settings.MaxSpawnProbability)
|
|
{
|
|
currentSpawnProbability += _settings.ProbabilityIncreaseRate * Time.deltaTime;
|
|
currentSpawnProbability = Mathf.Min(currentSpawnProbability, _settings.MaxSpawnProbability);
|
|
|
|
// Only fire event if probability changed significantly
|
|
if (Mathf.Abs(currentSpawnProbability - previousProbability) > 0.01f)
|
|
{
|
|
OnSpawnProbabilityChanged?.Invoke(currentSpawnProbability);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void OnTileSpawned(GameObject tile)
|
|
{
|
|
// Check for spawn points in the new tile
|
|
MonsterSpawnPoint[] spawnPoints = tile.GetComponentsInChildren<MonsterSpawnPoint>();
|
|
|
|
if (spawnPoints.Length == 0) return;
|
|
|
|
// If we're surfacing, don't spawn new monsters
|
|
if (_isSurfacing) return;
|
|
|
|
bool forceSpawn = timeSinceLastSpawn >= _settings.GuaranteedSpawnTime;
|
|
bool onCooldown = timeSinceLastSpawn < _settings.SpawnCooldown;
|
|
|
|
// Don't spawn if on cooldown, unless forced
|
|
if (onCooldown && !forceSpawn) return;
|
|
|
|
// Check probability or forced spawn
|
|
if (forceSpawn || UnityEngine.Random.value <= currentSpawnProbability)
|
|
{
|
|
// Pick a random spawn point from this tile
|
|
MonsterSpawnPoint spawnPoint = spawnPoints[UnityEngine.Random.Range(0, spawnPoints.Length)];
|
|
|
|
// Spawn the monster at the spawn point and parent it
|
|
SpawnMonster(spawnPoint.transform);
|
|
|
|
// Reset timer and adjust probability
|
|
lastSpawnTime = Time.time;
|
|
timeSinceLastSpawn = 0f;
|
|
currentSpawnProbability = _settings.BaseSpawnProbability;
|
|
OnSpawnProbabilityChanged?.Invoke(currentSpawnProbability);
|
|
}
|
|
}
|
|
|
|
private void SpawnMonster(Transform spawnPoint)
|
|
{
|
|
if (monsterPrefabs.Length == 0)
|
|
{
|
|
Debug.LogWarning("No monster prefabs assigned to DivingGameManager.");
|
|
return;
|
|
}
|
|
|
|
// Select random monster prefab
|
|
GameObject prefab = monsterPrefabs[UnityEngine.Random.Range(0, monsterPrefabs.Length)];
|
|
|
|
// Instantiate monster at spawn point position
|
|
GameObject monsterObj = Instantiate(prefab, spawnPoint.position, Quaternion.identity);
|
|
Monster monster = monsterObj.GetComponent<Monster>();
|
|
|
|
if (monster != null)
|
|
{
|
|
// Parent the monster to the spawn point so it moves with the tile
|
|
monsterObj.transform.SetParent(spawnPoint);
|
|
|
|
// Subscribe to monster events
|
|
monster.OnPictureTaken += OnMonsterPictureTaken;
|
|
monster.OnMonsterDespawned += OnMonsterDespawned;
|
|
|
|
// Add to active monsters list
|
|
activeMonsters.Add(monster);
|
|
|
|
// Fire event
|
|
OnMonsterSpawned?.Invoke(monster);
|
|
}
|
|
else
|
|
{
|
|
Debug.LogError($"Monster prefab {prefab.name} does not have a Monster component!");
|
|
Destroy(monsterObj);
|
|
}
|
|
}
|
|
|
|
private void OnMonsterPictureTaken(Monster monster)
|
|
{
|
|
// Calculate points based on depth
|
|
int depthBonus = Mathf.FloorToInt(Mathf.Abs(monster.transform.position.y) * _settings.DepthMultiplier);
|
|
int pointsAwarded = _settings.BasePoints + depthBonus;
|
|
|
|
// Add score
|
|
playerScore += pointsAwarded;
|
|
|
|
// Fire events
|
|
OnScoreChanged?.Invoke(playerScore);
|
|
OnPictureTaken?.Invoke(monster, pointsAwarded);
|
|
}
|
|
|
|
private void OnMonsterDespawned(Monster monster)
|
|
{
|
|
// Remove from active list
|
|
activeMonsters.Remove(monster);
|
|
|
|
// Unsubscribe from events
|
|
monster.OnPictureTaken -= OnMonsterPictureTaken;
|
|
monster.OnMonsterDespawned -= OnMonsterDespawned;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Called when the player takes damage from any collision
|
|
/// </summary>
|
|
private void OnPlayerDamageTaken()
|
|
{
|
|
if (isGameOver) return;
|
|
|
|
// Break the next rope in sequence
|
|
BreakNextRope();
|
|
|
|
// Check if all ropes are broken
|
|
if (currentRopeIndex >= playerRopes.Length)
|
|
{
|
|
TriggerGameOver();
|
|
}
|
|
else
|
|
{
|
|
// Notify listeners about rope break and remaining ropes
|
|
int remainingRopes = playerRopes.Length - currentRopeIndex;
|
|
OnRopeBroken?.Invoke(remainingRopes);
|
|
|
|
Debug.Log($"[DivingGameManager] Rope broken! {remainingRopes} ropes remaining.");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Breaks the next available rope in the sequence
|
|
/// </summary>
|
|
private void BreakNextRope()
|
|
{
|
|
if (currentRopeIndex < playerRopes.Length)
|
|
{
|
|
RopeBreaker ropeToBreak = playerRopes[currentRopeIndex];
|
|
|
|
if (ropeToBreak != null)
|
|
{
|
|
// Let the RopeBreaker component handle the breaking, effects, and sounds
|
|
ropeToBreak.BreakRope();
|
|
}
|
|
else
|
|
{
|
|
Debug.LogWarning($"[DivingGameManager] Rope at index {currentRopeIndex} is null!");
|
|
}
|
|
|
|
// Move to the next rope regardless if current was null
|
|
currentRopeIndex++;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Manually break a rope (for testing or external events)
|
|
/// </summary>
|
|
public void ForceBreakRope()
|
|
{
|
|
if (!isGameOver)
|
|
{
|
|
OnPlayerDamageTaken();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Triggers game over state when all ropes are broken
|
|
/// </summary>
|
|
private void TriggerGameOver()
|
|
{
|
|
if (isGameOver) return;
|
|
|
|
isGameOver = true;
|
|
Debug.Log("[DivingGameManager] Game Over! All ropes broken. Starting surfacing sequence...");
|
|
|
|
// Fire game over event
|
|
OnGameOver?.Invoke();
|
|
|
|
// Start surfacing instead of directly ending the game
|
|
StartSurfacing();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Validates rope references and logs warnings if any are missing
|
|
/// </summary>
|
|
private void ValidateRopeReferences()
|
|
{
|
|
if (playerRopes == null || playerRopes.Length == 0)
|
|
{
|
|
Debug.LogWarning("[DivingGameManager] No ropes assigned to break! Damage system won't work properly.");
|
|
return;
|
|
}
|
|
|
|
for (int i = 0; i < playerRopes.Length; i++)
|
|
{
|
|
if (playerRopes[i] == null)
|
|
{
|
|
Debug.LogWarning($"[DivingGameManager] Rope at index {i} is null!");
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Resets the rope system for a new game
|
|
/// </summary>
|
|
public void ResetRopeSystem()
|
|
{
|
|
// Reset rope state
|
|
currentRopeIndex = 0;
|
|
isGameOver = false;
|
|
|
|
// Restore all broken ropes
|
|
if (playerRopes != null)
|
|
{
|
|
foreach (var rope in playerRopes)
|
|
{
|
|
if (rope != null)
|
|
{
|
|
rope.RestoreRope();
|
|
}
|
|
}
|
|
}
|
|
|
|
Debug.Log("[DivingGameManager] Rope system reset.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Starts the surfacing mode - reverses trench direction and adjusts all spawned entities
|
|
/// </summary>
|
|
public void StartSurfacing()
|
|
{
|
|
if (_isSurfacing) return; // Already surfacing
|
|
|
|
_isSurfacing = true;
|
|
|
|
// 1. Initiate smooth velocity transition to surfacing speed
|
|
float targetVelocityFactor = -1.0f * _settings.SurfacingSpeedFactor;
|
|
SetVelocityFactor(targetVelocityFactor);
|
|
|
|
// 2. Find and notify trench tile spawner about direction change (for spawning/despawning logic)
|
|
TrenchTileSpawner tileSpawner = FindFirstObjectByType<TrenchTileSpawner>();
|
|
if (tileSpawner != null)
|
|
{
|
|
// Subscribe to velocity changes if not already subscribed
|
|
OnVelocityFactorChanged -= tileSpawner.OnVelocityFactorChanged;
|
|
OnVelocityFactorChanged += tileSpawner.OnVelocityFactorChanged;
|
|
|
|
// Subscribe to the last tile event
|
|
tileSpawner.onLastTileLeft.RemoveListener(OnLastTileLeft);
|
|
tileSpawner.onLastTileLeft.AddListener(OnLastTileLeft);
|
|
|
|
// Tell spawner to reverse spawn/despawn logic
|
|
tileSpawner.StartSurfacing();
|
|
|
|
// Immediately send current velocity factor
|
|
tileSpawner.OnVelocityFactorChanged(_currentVelocityFactor);
|
|
}
|
|
|
|
// Handle the Rock object - disable components and animate it falling offscreen
|
|
GameObject rockObject = GameObject.FindGameObjectWithTag("Rock");
|
|
if (rockObject != null)
|
|
{
|
|
// Disable all components except Transform on the rock object (not its children)
|
|
foreach (Component component in rockObject.GetComponents<Component>())
|
|
{
|
|
if (!(component is Transform))
|
|
{
|
|
if (component is Behaviour behaviour)
|
|
{
|
|
behaviour.enabled = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Start coroutine to animate the rock falling offscreen
|
|
StartCoroutine(MoveRockOffscreen(rockObject.transform));
|
|
|
|
Debug.Log("[DivingGameManager] Disabled rock components and animating it offscreen");
|
|
}
|
|
|
|
// Handle the Player object - disable components and reset X position
|
|
GameObject playerObject = GameObject.FindGameObjectWithTag("Player");
|
|
if (playerObject != null)
|
|
{
|
|
// Disable all components except Transform, Animator, and PlayerBlinkBehavior on the player object
|
|
foreach (Component component in playerObject.GetComponents<Component>())
|
|
{
|
|
if (!(component is Transform) &&
|
|
!(component is Animator) &&
|
|
!(component is PlayerBlinkBehavior))
|
|
{
|
|
if (component is Behaviour behaviour)
|
|
{
|
|
behaviour.enabled = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Start coroutine to reset X position to 0 over 1 second
|
|
StartCoroutine(ResetPlayerPosition(playerObject.transform));
|
|
|
|
Debug.Log("[DivingGameManager] Disabled player components (keeping Animator and PlayerBlinkBehavior) and resetting position");
|
|
}
|
|
|
|
// 3. Find bubble spawner and slow down existing bubbles (no velocity management needed)
|
|
BubbleSpawner bubbleSpawner = FindFirstObjectByType<BubbleSpawner>();
|
|
if (bubbleSpawner != null)
|
|
{
|
|
bubbleSpawner.StartSurfacing();
|
|
}
|
|
|
|
// 4. Find obstacle spawner and set up for velocity changes
|
|
ObstacleSpawner obstacleSpawner = FindFirstObjectByType<ObstacleSpawner>();
|
|
if (obstacleSpawner != null)
|
|
{
|
|
// Subscribe to velocity changes
|
|
OnVelocityFactorChanged -= obstacleSpawner.OnVelocityFactorChanged;
|
|
OnVelocityFactorChanged += obstacleSpawner.OnVelocityFactorChanged;
|
|
|
|
// Tell spawner to reverse spawn/despawn logic
|
|
obstacleSpawner.StartSurfacing();
|
|
|
|
// Immediately send current velocity factor
|
|
obstacleSpawner.OnVelocityFactorChanged(_currentVelocityFactor);
|
|
}
|
|
|
|
// Start the surfacing sequence coroutine
|
|
if (_surfacingSequenceCoroutine != null)
|
|
{
|
|
StopCoroutine(_surfacingSequenceCoroutine);
|
|
}
|
|
_surfacingSequenceCoroutine = StartCoroutine(SurfacingSequence());
|
|
|
|
Debug.Log($"[DivingGameManager] Started surfacing with target velocity factor: {targetVelocityFactor}");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Coroutine to animate the rock falling below the screen
|
|
/// </summary>
|
|
private IEnumerator MoveRockOffscreen(Transform rockTransform)
|
|
{
|
|
Vector3 startPosition = rockTransform.position;
|
|
|
|
// Calculate position below the screen
|
|
Camera mainCamera = Camera.main;
|
|
if (mainCamera == null)
|
|
{
|
|
Debug.LogWarning("[DivingGameManager] Cannot find main camera to calculate offscreen position");
|
|
yield break;
|
|
}
|
|
|
|
// Get a position below the bottom of the screen
|
|
Vector3 offscreenPosition = mainCamera.ViewportToWorldPoint(new Vector3(0.5f, -0.2f, mainCamera.nearClipPlane));
|
|
Vector3 targetPosition = new Vector3(startPosition.x, offscreenPosition.y, startPosition.z);
|
|
|
|
float duration = 2.0f; // Animation duration in seconds
|
|
float elapsed = 0f;
|
|
|
|
while (elapsed < duration)
|
|
{
|
|
elapsed += Time.deltaTime;
|
|
float t = Mathf.Clamp01(elapsed / duration);
|
|
|
|
// Use an easing function that accelerates to simulate falling
|
|
float easedT = t * t; // Quadratic easing
|
|
|
|
rockTransform.position = Vector3.Lerp(startPosition, targetPosition, easedT);
|
|
yield return null;
|
|
}
|
|
|
|
// Ensure final position is exactly at target
|
|
rockTransform.position = targetPosition;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Coroutine to reset the player's X position to 0 over time
|
|
/// </summary>
|
|
private IEnumerator ResetPlayerPosition(Transform playerTransform)
|
|
{
|
|
Vector3 startPosition = playerTransform.position;
|
|
Vector3 targetPosition = new Vector3(0f, startPosition.y, startPosition.z);
|
|
|
|
float duration = 1.0f; // Reset duration in seconds (as requested)
|
|
float elapsed = 0f;
|
|
|
|
while (elapsed < duration)
|
|
{
|
|
elapsed += Time.deltaTime;
|
|
float t = Mathf.Clamp01(elapsed / duration);
|
|
|
|
// Use smooth step for more natural movement
|
|
float smoothT = Mathf.SmoothStep(0f, 1f, t);
|
|
|
|
playerTransform.position = Vector3.Lerp(startPosition, targetPosition, smoothT);
|
|
yield return null;
|
|
}
|
|
|
|
// Ensure final position is exactly at target
|
|
playerTransform.position = targetPosition;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Coroutine to handle the surfacing sequence timing
|
|
/// </summary>
|
|
private IEnumerator SurfacingSequence()
|
|
{
|
|
// Wait for the configured delay
|
|
yield return new WaitForSeconds(_settings.SurfacingSpawnDelay);
|
|
|
|
// Find tile spawner and tell it to stop spawning
|
|
TrenchTileSpawner tileSpawner = FindFirstObjectByType<TrenchTileSpawner>();
|
|
if (tileSpawner != null)
|
|
{
|
|
// Tell it to stop spawning new tiles
|
|
tileSpawner.StopSpawning();
|
|
Debug.Log("[DivingGameManager] Stopped spawning new tiles after delay");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Called when the last tile leaves the screen
|
|
/// </summary>
|
|
private void OnLastTileLeft()
|
|
{
|
|
// Play the timeline
|
|
if (surfacingTimeline != null)
|
|
{
|
|
surfacingTimeline.Play();
|
|
Debug.Log("[DivingGameManager] Last tile left the screen, playing timeline");
|
|
}
|
|
else
|
|
{
|
|
Debug.LogWarning("[DivingGameManager] No surfacing timeline assigned!");
|
|
}
|
|
}
|
|
|
|
// Call this when the game ends
|
|
public void EndGame()
|
|
{
|
|
// Clean up active monsters
|
|
foreach (var monster in activeMonsters.ToArray())
|
|
{
|
|
if (monster != null)
|
|
{
|
|
monster.DespawnMonster();
|
|
}
|
|
}
|
|
|
|
activeMonsters.Clear();
|
|
|
|
// Final score could be saved to player prefs or other persistence
|
|
Debug.Log($"Final Score: {playerScore}");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Starts a smooth transition to the new velocity factor
|
|
/// </summary>
|
|
/// <param name="targetFactor">Target velocity factor (e.g., -1.0 for surfacing speed)</param>
|
|
public void SetVelocityFactor(float targetFactor)
|
|
{
|
|
if (_velocityTransitionCoroutine != null)
|
|
{
|
|
StopCoroutine(_velocityTransitionCoroutine);
|
|
}
|
|
|
|
_velocityTransitionCoroutine = StartCoroutine(TransitionVelocityFactor(targetFactor));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Coroutine to smoothly transition the velocity factor over time
|
|
/// </summary>
|
|
private IEnumerator<WaitForEndOfFrame> TransitionVelocityFactor(float targetFactor)
|
|
{
|
|
float startFactor = _currentVelocityFactor;
|
|
float elapsed = 0f;
|
|
|
|
while (elapsed < _settings.SpeedTransitionDuration)
|
|
{
|
|
elapsed += Time.deltaTime;
|
|
float t = Mathf.Clamp01(elapsed / _settings.SpeedTransitionDuration);
|
|
|
|
// Smooth step interpolation
|
|
float smoothStep = t * t * (3f - 2f * t);
|
|
|
|
_currentVelocityFactor = Mathf.Lerp(startFactor, targetFactor, smoothStep);
|
|
|
|
// Notify listeners about the velocity factor change
|
|
OnVelocityFactorChanged?.Invoke(_currentVelocityFactor);
|
|
|
|
yield return null;
|
|
}
|
|
|
|
_currentVelocityFactor = targetFactor;
|
|
|
|
// Final assignment to ensure exact target value
|
|
OnVelocityFactorChanged?.Invoke(_currentVelocityFactor);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Register a component as pausable with this manager
|
|
/// </summary>
|
|
/// <param name="component">The pausable component to register</param>
|
|
public void RegisterPausableComponent(IPausable component)
|
|
{
|
|
if (component != null && !_pausableComponents.Contains(component))
|
|
{
|
|
_pausableComponents.Add(component);
|
|
|
|
// If the game is already paused, pause the component immediately
|
|
if (_isPaused)
|
|
{
|
|
component.Pause();
|
|
}
|
|
|
|
Debug.Log($"[DivingGameManager] Registered pausable component: {(component as MonoBehaviour)?.name ?? "Unknown"}");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Unregister a pausable component
|
|
/// </summary>
|
|
/// <param name="component">The pausable component to unregister</param>
|
|
public void UnregisterPausableComponent(IPausable component)
|
|
{
|
|
if (component != null && _pausableComponents.Contains(component))
|
|
{
|
|
_pausableComponents.Remove(component);
|
|
Debug.Log($"[DivingGameManager] Unregistered pausable component: {(component as MonoBehaviour)?.name ?? "Unknown"}");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Pause the game and all registered components
|
|
/// </summary>
|
|
public void Pause()
|
|
{
|
|
if (_isPaused) return; // Already paused
|
|
|
|
_isPaused = true;
|
|
|
|
// Pause all registered components
|
|
foreach (var component in _pausableComponents)
|
|
{
|
|
component.Pause();
|
|
}
|
|
|
|
Debug.Log($"[DivingGameManager] Game paused. Paused {_pausableComponents.Count} components.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Resume the game and all registered components
|
|
/// </summary>
|
|
public void Resume()
|
|
{
|
|
if (!_isPaused) return; // Already running
|
|
|
|
_isPaused = false;
|
|
|
|
// Resume all registered components
|
|
foreach (var component in _pausableComponents)
|
|
{
|
|
component.Resume();
|
|
}
|
|
|
|
Debug.Log($"[DivingGameManager] Game resumed. Resumed {_pausableComponents.Count} components.");
|
|
}
|
|
}
|
|
}
|