tschesky/AppleHillsProduction
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Revamp the prompt system, the bootstrapper system, the starting cinematic

Browse Source
This commit is contained in:
Michal Pikulski
2025-10-16 19:43:19 +02:00
parent df604fbc03
commit 50448c5bd3
89 changed files with 3964 additions and 677 deletions
Download Patch File Download Diff File Expand all files Collapse all files

360
Assets/Scripts/PuzzleS/PuzzleManager.cs
View File

@@ -5,7 +5,11 @@ using System.Linq;
using UnityEngine;
using UnityEngine.SceneManagement;
using AppleHills.Core.Settings;
using Core; // Added for IInteractionSettings
using Bootstrap;
using Core;
using UnityEngine.AddressableAssets;
using UnityEngine.ResourceManagement.AsyncOperations;
using Utils;
namespace PuzzleS
{
@@ -26,71 +30,103 @@ namespace PuzzleS
// Settings reference
private IInteractionSettings _interactionSettings;
// Current level puzzle data
private PuzzleLevelDataSO _currentLevelData;
private AsyncOperationHandle<PuzzleLevelDataSO> _levelDataLoadOperation;
private bool _isDataLoaded = false;
// Store registered behaviors that are waiting for data to be loaded
private List<ObjectiveStepBehaviour> _registeredBehaviours = new List<ObjectiveStepBehaviour>();
/// <summary>
/// Singleton instance of the PuzzleManager.
/// </summary>
public static PuzzleManager Instance
{
get
{
if (_instance == null && Application.isPlaying && !_isQuitting)
{
_instance = FindAnyObjectByType<PuzzleManager>();
if (_instance == null)
{
var go = new GameObject("PuzzleManager");
_instance = go.AddComponent<PuzzleManager>();
// DontDestroyOnLoad(go);
}
}
return _instance;
}
}
public static PuzzleManager Instance => _instance;
// Events to notify about step lifecycle
public event Action<PuzzleStepSO> OnStepCompleted;
public event Action<PuzzleStepSO> OnStepUnlocked;
public event Action<PuzzleLevelDataSO> OnLevelDataLoaded;
public event Action<PuzzleLevelDataSO> OnAllPuzzlesComplete;
private HashSet<PuzzleStepSO> _completedSteps = new HashSet<PuzzleStepSO>();
private HashSet<PuzzleStepSO> _unlockedSteps = new HashSet<PuzzleStepSO>();
// Registration for ObjectiveStepBehaviour
private Dictionary<PuzzleStepSO, ObjectiveStepBehaviour> _stepBehaviours = new Dictionary<PuzzleStepSO, ObjectiveStepBehaviour>();
// Runtime dependency graph
private Dictionary<PuzzleStepSO, List<PuzzleStepSO>> _runtimeDependencies = new Dictionary<PuzzleStepSO, List<PuzzleStepSO>>();
void Awake()
{
_instance = this;
// DontDestroyOnLoad(gameObject);
SceneManager.sceneLoaded += OnSceneLoaded;
// Initialize settings reference
_interactionSettings = GameManager.GetSettingsObject<IInteractionSettings>();
// Register for post-boot initialization
BootCompletionService.RegisterInitAction(InitializePostBoot);
}
void Start()
private void InitializePostBoot()
{
// Subscribe to SceneManagerService events after boot is complete
SceneManagerService.Instance.SceneLoadCompleted += OnSceneLoadCompleted;
SceneManagerService.Instance.SceneLoadStarted += OnSceneLoadStarted;
// Find player transform
_playerTransform = GameObject.FindGameObjectWithTag("Player")?.transform;
// Start proximity check coroutine
StartProximityChecks();
// Load puzzle data for the current scene if not already loading
if (_currentLevelData == null && !_isDataLoaded)
{
LoadPuzzleDataForCurrentScene();
}
Logging.Debug("[PuzzleManager] Subscribed to SceneManagerService events");
}
void OnDestroy()
{
SceneManager.sceneLoaded -= OnSceneLoaded;
StopProximityChecks();
// Unsubscribe from scene manager events
if (SceneManagerService.Instance != null)
{
SceneManagerService.Instance.SceneLoadCompleted -= OnSceneLoadCompleted;
SceneManagerService.Instance.SceneLoadStarted -= OnSceneLoadStarted;
}
// Release addressable handle if needed
if (_levelDataLoadOperation.IsValid())
{
Addressables.Release(_levelDataLoadOperation);
}
}
private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
/// <summary>
/// Called when a scene is starting to load
/// </summary>
public void OnSceneLoadStarted(string sceneName)
{
SceneManager.sceneLoaded -= OnSceneLoaded;
// Reset data loaded state when changing scenes to avoid using stale data
_isDataLoaded = false;
Logging.Debug($"[Puzzles] Scene load started: {sceneName}, marked puzzle data as not loaded");
}
/// <summary>
/// Called when a scene is loaded
/// </summary>
public void OnSceneLoadCompleted(string sceneName)
{
// Skip for non-gameplay scenes
if (sceneName == "BootstrapScene" || string.IsNullOrEmpty(sceneName))
{
return;
}
Logging.Debug("[MDPI] OnSceneLoaded");
_runtimeDependencies.Clear();
BuildRuntimeDependencies();
UnlockInitialSteps();
Logging.Debug($"[Puzzles] Scene loaded: {sceneName}, loading puzzle data");
LoadPuzzleDataForCurrentScene(sceneName);
// Find player transform again in case it changed with scene load
_playerTransform = GameObject.FindGameObjectWithTag("Player")?.transform;
@@ -99,6 +135,72 @@ namespace PuzzleS
StartProximityChecks();
}
/// <summary>
/// Load puzzle data for the current scene
/// </summary>
private void LoadPuzzleDataForCurrentScene(string sceneName = null)
{
string currentScene = sceneName ?? SceneManagerService.Instance.CurrentGameplayScene;
if (string.IsNullOrEmpty(currentScene))
{
Logging.Warning("[Puzzles] Cannot load puzzle data: Current scene name is empty");
return;
}
_isDataLoaded = false;
string addressablePath = $"Puzzles/{currentScene}";
Logging.Debug($"[Puzzles] Loading puzzle data from addressable: {addressablePath}");
// Release previous handle if needed
if (_levelDataLoadOperation.IsValid())
{
Addressables.Release(_levelDataLoadOperation);
}
// Check if the addressable exists before trying to load it
if (!AppleHillsUtils.AddressableKeyExists(addressablePath))
{
Logging.Warning($"[Puzzles] Puzzle data does not exist for scene: {currentScene}");
_isDataLoaded = true; // Mark as loaded but with no data
_currentLevelData = null;
return;
}
// Load the level data asset
_levelDataLoadOperation = Addressables.LoadAssetAsync<PuzzleLevelDataSO>(addressablePath);
_levelDataLoadOperation.Completed += handle =>
{
if (handle.Status == AsyncOperationStatus.Succeeded)
{
_currentLevelData = handle.Result;
Logging.Debug($"[Puzzles] Loaded level data: {_currentLevelData.levelId} with {_currentLevelData.allSteps.Count} steps");
// Reset state
_completedSteps.Clear();
_unlockedSteps.Clear();
// Unlock initial steps
UnlockInitialSteps();
// Update all registered behaviors now that data is loaded
UpdateAllRegisteredBehaviors();
// Mark data as loaded
_isDataLoaded = true;
// Notify listeners
OnLevelDataLoaded?.Invoke(_currentLevelData);
}
else
{
Logging.Warning($"[Puzzles] Failed to load puzzle data for {currentScene}: {handle.OperationException?.Message}");
_isDataLoaded = true; // Mark as loaded but with error
_currentLevelData = null;
}
};
}
/// <summary>
/// Start the proximity check coroutine.
/// </summary>
@@ -138,7 +240,7 @@ namespace PuzzleS
foreach (var kvp in _stepBehaviours)
{
if (kvp.Value == null) continue;
if (IsPuzzleStepCompleted(kvp.Value.stepData.stepId)) continue;
if (IsPuzzleStepCompleted(kvp.Key.stepId)) continue;
float distance = Vector3.Distance(_playerTransform.position, kvp.Value.transform.position);
@@ -157,6 +259,24 @@ namespace PuzzleS
}
}
/// <summary>
/// Update all registered behaviors with their current state
/// </summary>
private void UpdateAllRegisteredBehaviors()
{
foreach (var behaviour in _registeredBehaviours)
{
if (behaviour == null) continue;
// Only update if the step is in our dictionary
bool stepUnlocked = IsStepUnlocked(behaviour.stepData);
if (stepUnlocked)
{
UpdateStepState(behaviour);
}
}
}
/// <summary>
/// Registers a step behaviour with the manager.
/// </summary>
@@ -164,21 +284,51 @@ namespace PuzzleS
public void RegisterStepBehaviour(ObjectiveStepBehaviour behaviour)
{
if (behaviour?.stepData == null) return;
// Always add to our registered behaviors list
if (!_registeredBehaviours.Contains(behaviour))
{
_registeredBehaviours.Add(behaviour);
}
// Add to the step behaviours dictionary if not already there
if (!_stepBehaviours.ContainsKey(behaviour.stepData))
{
_stepBehaviours.Add(behaviour.stepData, behaviour);
_runtimeDependencies.Clear();
foreach (var step in _stepBehaviours.Values)
{
step.LockStep();
}
_unlockedSteps.Clear();
BuildRuntimeDependencies();
UnlockInitialSteps();
Logging.Debug($"[Puzzles] Registered step: {behaviour.stepData.stepId} on {behaviour.gameObject.name}");
// Only update state if data is already loaded
if (_isDataLoaded && _currentLevelData != null)
{
UpdateStepState(behaviour);
}
// Otherwise, the state will be updated when data loads in UpdateAllRegisteredBehaviors
}
}
/// <summary>
/// Updates a step's state based on the current puzzle state.
/// </summary>
private void UpdateStepState(ObjectiveStepBehaviour behaviour)
{
if (behaviour?.stepData == null) return;
// If step is already completed, ignore
if (_completedSteps.Contains(behaviour.stepData))
return;
// If step is already unlocked, update the behaviour
if (_unlockedSteps.Contains(behaviour.stepData))
{
behaviour.UnlockStep();
}
else
{
// Make sure it's locked
behaviour.LockStep();
}
}
/// <summary>
/// Unregisters a step behaviour from the manager.
/// </summary>
@@ -186,57 +336,27 @@ namespace PuzzleS
public void UnregisterStepBehaviour(ObjectiveStepBehaviour behaviour)
{
if (behaviour?.stepData == null) return;
_stepBehaviours.Remove(behaviour.stepData);
_registeredBehaviours.Remove(behaviour);
Logging.Debug($"[Puzzles] Unregistered step: {behaviour.stepData.stepId} on {behaviour.gameObject.name}");
}
/// <summary>
/// Builds the runtime dependency graph for all registered steps.
/// </summary>
private void BuildRuntimeDependencies()
{
_runtimeDependencies = PuzzleGraphUtility.BuildDependencyGraph(_stepBehaviours.Keys);
foreach (var step in _runtimeDependencies.Keys)
{
foreach (var dep in _runtimeDependencies[step])
{
Logging.Debug($"[Puzzles] Step {step.stepId} depends on {dep.stepId}");
}
}
Logging.Debug($"[Puzzles] Runtime dependencies built. Total steps: {_stepBehaviours.Count}");
}
/// <summary>
/// Unlocks all initial steps (those with no dependencies) and any steps whose dependencies are already met.
/// Unlocks all initial steps (those with no dependencies)
/// </summary>
private void UnlockInitialSteps()
{
// First, unlock all steps with no dependencies (initial steps)
var initialSteps = PuzzleGraphUtility.FindInitialSteps(_runtimeDependencies);
foreach (var step in initialSteps)
if (_currentLevelData == null) return;
// Unlock initial steps
foreach (var step in _currentLevelData.initialSteps)
{
Logging.Debug($"[Puzzles] Initial step unlocked: {step.stepId}");
UnlockStep(step);
}
// Keep trying to unlock steps as long as we're making progress
bool madeProgress;
do
{
madeProgress = false;
// Check all steps that haven't been unlocked yet
foreach (var step in _runtimeDependencies.Keys.Where(s => !_unlockedSteps.Contains(s)))
{
// Check if all dependencies have been completed
if (AreRuntimeDependenciesMet(step))
{
Logging.Debug($"[Puzzles] Chain step unlocked: {step.stepId}");
UnlockStep(step);
madeProgress = true;
}
}
} while (madeProgress);
Logging.Debug($"[Puzzles] Unlocked {_unlockedSteps.Count} initial steps");
}
/// <summary>
@@ -246,24 +366,29 @@ namespace PuzzleS
public void MarkPuzzleStepCompleted(PuzzleStepSO step)
{
if (_completedSteps.Contains(step)) return;
if (_currentLevelData == null) return;
_completedSteps.Add(step);
Logging.Debug($"[Puzzles] Step completed: {step.stepId}");
// Broadcast completion
OnStepCompleted?.Invoke(step);
foreach (var unlock in step.unlocks)
// Unlock steps that are unlocked by this step
foreach (var unlockStep in _currentLevelData.GetUnlockedSteps(step))
{
if (AreRuntimeDependenciesMet(unlock))
if (AreStepDependenciesMet(unlockStep))
{
Logging.Debug($"[Puzzles] Unlocking step {unlock.stepId} after completing {step.stepId}");
UnlockStep(unlock);
Logging.Debug($"[Puzzles] Unlocking step {unlockStep.stepId} after completing {step.stepId}");
UnlockStep(unlockStep);
}
else
{
Logging.Debug($"[Puzzles] Step {unlock.stepId} not unlocked yet, waiting for other dependencies");
Logging.Debug($"[Puzzles] Step {unlockStep.stepId} not unlocked yet, waiting for other dependencies");
}
}
// Check if all puzzle steps are now complete
CheckPuzzleCompletion();
}
@@ -272,13 +397,33 @@ namespace PuzzleS
/// </summary>
/// <param name="step">The step to check.</param>
/// <returns>True if all dependencies are met, false otherwise.</returns>
private bool AreRuntimeDependenciesMet(PuzzleStepSO step)
private bool AreStepDependenciesMet(PuzzleStepSO step)
{
if (!_runtimeDependencies.ContainsKey(step) || _runtimeDependencies[step].Count == 0) return true;
foreach (var dep in _runtimeDependencies[step])
if (_currentLevelData == null || step == null) return false;
// If it's an initial step, it has no dependencies
if (_currentLevelData.IsInitialStep(step)) return true;
// Check if dependencies are met using pre-processed data
if (_currentLevelData.stepDependencies.TryGetValue(step.stepId, out string[] dependencies))
{
if (!_completedSteps.Contains(dep)) return false;
foreach (var depId in dependencies)
{
// Find the dependency step
bool dependencyMet = false;
foreach (var completedStep in _completedSteps)
{
if (completedStep.stepId == depId)
{
dependencyMet = true;
break;
}
}
if (!dependencyMet) return false;
}
}
return true;
}
@@ -290,6 +435,7 @@ namespace PuzzleS
{
if (_unlockedSteps.Contains(step)) return;
_unlockedSteps.Add(step);
if (_stepBehaviours.TryGetValue(step, out var behaviour))
{
behaviour.UnlockStep();
@@ -301,14 +447,18 @@ namespace PuzzleS
}
/// <summary>
/// Checks if the puzzle is complete (all steps finished).
/// Checks if the puzzle is complete (all steps in level finished).
/// </summary>
private void CheckPuzzleCompletion()
{
if (_completedSteps.Count == _stepBehaviours.Count)
if (_currentLevelData == null) return;
if (_currentLevelData.IsLevelComplete(_completedSteps))
{
Logging.Debug("[Puzzles] Puzzle complete! All steps finished.");
// TODO: Fire puzzle complete event or trigger outcome logic
Logging.Debug("[Puzzles] All puzzles complete! Level finished.");
// Fire level complete event
OnAllPuzzlesComplete?.Invoke(_currentLevelData);
}
}
@@ -317,9 +467,6 @@ namespace PuzzleS
/// </summary>
public bool IsStepUnlocked(PuzzleStepSO step)
{
// _runtimeDependencies.Clear();
// BuildRuntimeDependencies();
// UnlockInitialSteps();
return _unlockedSteps.Contains(step);
}
@@ -332,6 +479,23 @@ namespace PuzzleS
{
return _completedSteps.Any(step => step.stepId == stepId);
}
/// <summary>
/// Get the current level puzzle data
/// </summary>
public PuzzleLevelDataSO GetCurrentLevelData()
{
return _currentLevelData;
}
/// <summary>
/// Checks if puzzle data is loaded
/// </summary>
/// <returns>True if data loading has completed (whether successful or not)</returns>
public bool IsDataLoaded()
{
return _isDataLoaded;
}
void OnApplicationQuit()
{