285 lines
11 KiB
C#
285 lines
11 KiB
C#
using System;
|
|
using AppleHills.Core.Settings;
|
|
using UnityEngine;
|
|
using UI;
|
|
using Core;
|
|
using UnityEngine.SceneManagement;
|
|
using Cinematics;
|
|
using UnityEngine.Serialization;
|
|
|
|
namespace Bootstrap
|
|
{
|
|
/// <summary>
|
|
/// Controller for the boot scene that coordinates bootstrap initialization with loading screen
|
|
/// </summary>
|
|
public class BootSceneController : MonoBehaviour
|
|
{
|
|
[SerializeField] private string mainSceneName = "AppleHillsOverworld";
|
|
[SerializeField] private float minDelayAfterBoot = 0.5f; // Small delay after boot to ensure smooth transition
|
|
[SerializeField] private bool debugMode = false;
|
|
[SerializeField] private InitialLoadingScreen initialLoadingScreen; // Reference to our specialized loading screen
|
|
|
|
// Progress distribution between bootstrap and scene loading
|
|
[SerializeField, Range(0.1f, 0.9f)] private float bootProgressWeight = 0.5f; // Default 50/50 split
|
|
|
|
private enum LoadingPhase { Bootstrap, SceneLoading }
|
|
private LoadingPhase _currentPhase = LoadingPhase.Bootstrap;
|
|
|
|
private bool _bootComplete = false;
|
|
private bool _hasStartedLoading = false;
|
|
private float _sceneLoadingProgress = 0f;
|
|
private LogVerbosity _logVerbosity = LogVerbosity.Warning;
|
|
|
|
private void Start()
|
|
{
|
|
LogDebugMessage("Boot scene started");
|
|
|
|
// Ensure the initial loading screen exists
|
|
if (initialLoadingScreen == null)
|
|
{
|
|
Debug.LogError("[BootSceneController] No InitialLoadingScreen assigned! Please assign it in the inspector.");
|
|
return;
|
|
}
|
|
|
|
// Subscribe to the loading screen completion event
|
|
initialLoadingScreen.OnLoadingScreenFullyHidden += OnInitialLoadingComplete;
|
|
|
|
// Show the loading screen immediately with our combined progress provider
|
|
initialLoadingScreen.ShowLoadingScreen(GetCombinedProgress);
|
|
|
|
// Subscribe to boot progress events
|
|
CustomBoot.OnBootProgressChanged += OnBootProgressChanged;
|
|
|
|
// Register our boot completion handler with the BootCompletionService
|
|
// This will execute either immediately if boot is already complete,
|
|
// or when the boot process completes
|
|
BootCompletionService.RegisterInitAction(
|
|
OnBootCompleted,
|
|
50, // Higher priority (lower number)
|
|
"BootSceneController.OnBootCompleted"
|
|
);
|
|
|
|
_logVerbosity = DeveloperSettingsProvider.Instance.GetSettings<DebugSettings>().bootstrapLogVerbosity;
|
|
|
|
// In debug mode, log additional information
|
|
if (debugMode)
|
|
{
|
|
InvokeRepeating(nameof(LogDebugInfo), 0.1f, 0.5f);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Called when the initial loading screen is fully hidden
|
|
/// </summary>
|
|
private void OnInitialLoadingComplete()
|
|
{
|
|
LogDebugMessage("Initial loading screen fully hidden, boot sequence completed");
|
|
|
|
// Play the intro cinematic if available
|
|
if (CinematicsManager.Instance != null)
|
|
{
|
|
LogDebugMessage("Attempting to play intro cinematic");
|
|
|
|
// Use LoadAndPlayCinematic to play the intro sequence
|
|
CinematicsManager.Instance.LoadAndPlayCinematic("IntroSequence", false);
|
|
CinematicsManager.Instance.ChangeCinematicBackgroundColour(new Color(0f, 0f, 0f, 1f));
|
|
//PlayerHudManager.Instance.ResizeCinematicPlayer();
|
|
|
|
// Immediately unload the StartingScene - no need to wait for cinematic to finish
|
|
// since CinematicsManager is bootstrapped and won't be unloaded
|
|
UnloadStartingScene();
|
|
}
|
|
else
|
|
{
|
|
// If no cinematics manager, unload the StartingScene directly
|
|
UnloadStartingScene();
|
|
}
|
|
}
|
|
|
|
private void OnDestroy()
|
|
{
|
|
// Clean up event subscriptions
|
|
CustomBoot.OnBootCompleted -= OnBootCompleted;
|
|
CustomBoot.OnBootProgressChanged -= OnBootProgressChanged;
|
|
|
|
if (initialLoadingScreen != null)
|
|
{
|
|
initialLoadingScreen.OnLoadingScreenFullyHidden -= OnInitialLoadingComplete;
|
|
}
|
|
|
|
if (debugMode)
|
|
{
|
|
CancelInvoke(nameof(LogDebugInfo));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Progress provider that combines bootstrap and scene loading progress
|
|
/// </summary>
|
|
private float GetCombinedProgress()
|
|
{
|
|
switch (_currentPhase)
|
|
{
|
|
case LoadingPhase.Bootstrap:
|
|
// Scale bootstrap progress from 0 to bootProgressWeight
|
|
return CustomBoot.CurrentProgress * bootProgressWeight;
|
|
|
|
case LoadingPhase.SceneLoading:
|
|
// Scale scene loading progress from bootProgressWeight to 1.0
|
|
return bootProgressWeight + (_sceneLoadingProgress * (1f - bootProgressWeight));
|
|
|
|
default:
|
|
return 0f;
|
|
}
|
|
}
|
|
|
|
private void OnBootProgressChanged(float progress)
|
|
{
|
|
if (debugMode)
|
|
{
|
|
LogDebugMessage($"Bootstrap progress: {progress:P0}, Combined: {GetCombinedProgress():P0}");
|
|
}
|
|
}
|
|
|
|
private void LogDebugInfo()
|
|
{
|
|
LogDebugMessage($"Debug - Phase: {_currentPhase}, Bootstrap: {CustomBoot.CurrentProgress:P0}, " +
|
|
$"Scene: {_sceneLoadingProgress:P0}, Combined: {GetCombinedProgress():P0}, Boot Complete: {_bootComplete}");
|
|
}
|
|
|
|
private void OnBootCompleted()
|
|
{
|
|
// Unsubscribe to prevent duplicate calls
|
|
CustomBoot.OnBootCompleted -= OnBootCompleted;
|
|
|
|
LogDebugMessage("Boot process completed");
|
|
_bootComplete = true;
|
|
|
|
// After a small delay, start loading the main menu
|
|
// This prevents jerky transitions if boot happens very quickly
|
|
Invoke(nameof(StartLoadingMainMenu), minDelayAfterBoot);
|
|
}
|
|
|
|
private void StartLoadingMainMenu()
|
|
{
|
|
if (_hasStartedLoading)
|
|
return;
|
|
|
|
_hasStartedLoading = true;
|
|
_currentPhase = LoadingPhase.SceneLoading;
|
|
LoadMainScene();
|
|
}
|
|
|
|
private async void LoadMainScene()
|
|
{
|
|
LogDebugMessage($"Loading main menu scene: {mainSceneName}");
|
|
|
|
try
|
|
{
|
|
// Initialize scene loading progress to 0 to ensure proper remapping
|
|
_sceneLoadingProgress = 0f;
|
|
|
|
// Create a custom progress reporter using a custom class
|
|
var progressHandler = new ProgressHandler(value => {
|
|
// Store the raw scene loading progress (0-1)
|
|
_sceneLoadingProgress = value;
|
|
|
|
if (debugMode)
|
|
{
|
|
LogDebugMessage($"Scene loading raw: {value:P0}, Combined: {GetCombinedProgress():P0}");
|
|
}
|
|
});
|
|
|
|
// Step 1: Additively load the main menu scene - don't unload StartingScene yet
|
|
var op = SceneManager.LoadSceneAsync(mainSceneName, LoadSceneMode.Additive);
|
|
|
|
// Disable scene activation until we're ready to show it
|
|
op.allowSceneActivation = true;
|
|
|
|
// Track progress while loading
|
|
while (!op.isDone)
|
|
{
|
|
progressHandler.ReportProgress(op.progress);
|
|
await System.Threading.Tasks.Task.Yield();
|
|
}
|
|
|
|
// Update the current gameplay scene in SceneManagerService
|
|
SceneManagerService.Instance.CurrentGameplayScene = mainSceneName;
|
|
|
|
// Ensure progress is complete
|
|
_sceneLoadingProgress = 1f;
|
|
|
|
// Step 2: Scene is fully loaded, now hide the loading screen
|
|
// This will trigger OnInitialLoadingComplete via the event when animation completes
|
|
initialLoadingScreen.HideLoadingScreen();
|
|
|
|
// Step 3: The OnInitialLoadingComplete method will handle playing the intro cinematic
|
|
// Step 4: StartingScene will be unloaded after the cinematic completes in OnIntroCinematicFinished
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Debug.LogError($"[BootSceneController] Error loading main menu: {e.Message}");
|
|
// Still try to hide the loading screen even if there was an error
|
|
initialLoadingScreen.HideLoadingScreen();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Unloads the StartingScene, completing the transition to the main menu
|
|
/// </summary>
|
|
private async void UnloadStartingScene()
|
|
{
|
|
try
|
|
{
|
|
// Get the current scene (StartingScene)
|
|
Scene currentScene = SceneManager.GetActiveScene();
|
|
string startingSceneName = currentScene.name;
|
|
|
|
LogDebugMessage($"Unloading StartingScene: {startingSceneName}");
|
|
|
|
// Unload the StartingScene
|
|
await SceneManager.UnloadSceneAsync(startingSceneName);
|
|
|
|
// Set the main menu scene as the active scene
|
|
Scene mainMenuScene = SceneManager.GetSceneByName(mainSceneName);
|
|
SceneManager.SetActiveScene(mainMenuScene);
|
|
|
|
LogDebugMessage($"Transition complete: {startingSceneName} unloaded, {mainSceneName} is now active");
|
|
|
|
// Destroy the boot scene controller since its job is done
|
|
Destroy(gameObject);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Logging.Warning($"[BootSceneController] Error unloading StartingScene: {e.Message}");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Helper class to handle progress reporting without running into explicit interface implementation issues
|
|
/// </summary>
|
|
private class ProgressHandler
|
|
{
|
|
private Action<float> _progressAction;
|
|
|
|
public ProgressHandler(Action<float> progressAction)
|
|
{
|
|
_progressAction = progressAction;
|
|
}
|
|
|
|
public void ReportProgress(float value)
|
|
{
|
|
_progressAction?.Invoke(value);
|
|
}
|
|
}
|
|
|
|
private void LogDebugMessage(string message)
|
|
{
|
|
if ( _logVerbosity <= LogVerbosity.Debug)
|
|
{
|
|
Logging.Debug($"[BootSceneController] {message}");
|
|
}
|
|
}
|
|
}
|
|
}
|