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

Small updates to dispatchers in items and puzzles

Browse Source
This commit is contained in:
AlexanderT
2025-09-26 14:06:03 +02:00
parent b781a1656d
commit f380b6fa54
10 changed files with 531 additions and 182 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
Assets/Scripts/Interactions/Interactable.cs
View File

@@ -25,7 +25,7 @@ namespace Interactions
public UnityEvent interactionInterrupted;
public UnityEvent characterArrived;
public UnityEvent<bool> interactionComplete;
// Helpers for managing interaction state
private bool _interactionInProgress;
private PlayerTouchController _playerRef;

27
Assets/Scripts/Interactions/ItemSlot.cs
View File

@@ -1,18 +1,38 @@
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Events;
using System; // for Action<T>
namespace Interactions
{
// New enum describing possible states for the slotted item
public enum ItemSlotState
{
None,
Correct,
Incorrect,
Forbidden
}
/// <summary>
/// Interaction requirement that allows slotting, swapping, or picking up items in a slot.
/// </summary>
[RequireComponent(typeof(Interactable))]
public class ItemSlot : Pickup
{
// Tracks the current state of the slotted item
private ItemSlotState _currentState = ItemSlotState.None;
/// <summary>
/// Read-only access to the current slotted item state.
/// </summary>
public ItemSlotState CurrentSlottedState => _currentState;
public UnityEvent onItemSlotted;
public UnityEvent onItemSlotRemoved;
public UnityEvent onCorrectItemSlotted;
// Native C# event alternative to the UnityEvent for code-only subscribers
public event Action<PickupItemData, PickupItemData> OnCorrectItemSlotted;
public UnityEvent onIncorrectItemSlotted;
public UnityEvent onForbiddenItemSlotted;
private PickupItemData _currentlySlottedItemData;
@@ -48,6 +68,7 @@ namespace Interactions
{
DebugUIMessage.Show("Can't place that here.", Color.red);
onForbiddenItemSlotted?.Invoke();
_currentState = ItemSlotState.Forbidden;
Interactable.BroadcastInteractionComplete(false);
return;
}
@@ -62,6 +83,7 @@ namespace Interactions
{
FollowerController.TryPickupItem(_currentlySlottedItemObject, _currentlySlottedItemData, false);
onItemSlotRemoved?.Invoke();
_currentState = ItemSlotState.None;
SlotItem(heldItemObj, heldItemData, _currentlySlottedItemObject == null);
return;
}
@@ -109,6 +131,8 @@ namespace Interactions
{
_currentlySlottedItemObject = null;
_currentlySlottedItemData = null;
// Clear state when no item is slotted
_currentState = ItemSlotState.None;
}
else
{
@@ -133,6 +157,8 @@ namespace Interactions
{
DebugUIMessage.Show("You correctly slotted " + itemToSlotData.itemName + " into: " + itemData.itemName, Color.green);
onCorrectItemSlotted?.Invoke();
OnCorrectItemSlotted?.Invoke(itemData, _currentlySlottedItemData);
_currentState = ItemSlotState.Correct;
}
Interactable.BroadcastInteractionComplete(true);
@@ -143,6 +169,7 @@ namespace Interactions
{
DebugUIMessage.Show("I'm not sure this works.", Color.yellow);
onIncorrectItemSlotted?.Invoke();
_currentState = ItemSlotState.Incorrect;
}
Interactable.BroadcastInteractionComplete(false);
}

13
Assets/Scripts/Interactions/Pickup.cs
View File

@@ -1,5 +1,6 @@
using Input;
using UnityEngine;
using System; // added for Action<T>
namespace Interactions
{
@@ -11,6 +12,9 @@ namespace Interactions
protected Interactable Interactable;
private PlayerTouchController _playerRef;
protected FollowerController FollowerController;
// Event: invoked when the item was picked up successfully
public event Action<PickupItemData> OnItemPickedUp;
/// <summary>
/// Unity Awake callback. Sets up icon, interactable, and event handlers.
@@ -89,7 +93,14 @@ namespace Interactions
}
FollowerController?.TryPickupItem(gameObject, itemData);
Interactable.BroadcastInteractionComplete(combinationResult == FollowerController.CombinationResult.NotApplicable);
bool wasPickedUp = (combinationResult == FollowerController.CombinationResult.NotApplicable);
Interactable.BroadcastInteractionComplete(wasPickedUp);
// Invoke native C# event when the item was picked up successfully
if (wasPickedUp)
{
OnItemPickedUp?.Invoke(itemData);
}
}
}
}

2
Assets/Scripts/PuzzleS/ObjectiveStepBehaviour.cs
View File

@@ -95,7 +95,7 @@ namespace PuzzleS
if (success)
{
Debug.Log($"[Puzzles] Step interacted: {stepData?.stepId} on {gameObject.name}");
PuzzleManager.Instance?.OnStepCompleted(stepData);
PuzzleManager.Instance?.MarkPuzzleStepCompleted(stepData);
}
}
}

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

@@ -1,208 +1,208 @@
using UnityEngine;
using System;
using System.Collections.Generic;
using PuzzleS;
using UnityEngine;
using UnityEngine.SceneManagement;
using System; // added for Action<T>
/// <summary>
/// Manages puzzle step registration, dependency management, and step completion for the puzzle system.
/// </summary>
public class PuzzleManager : MonoBehaviour
namespace PuzzleS
{
private static PuzzleManager _instance;
private static bool _isQuitting = false;
/// <summary>
/// Singleton instance of the PuzzleManager.
/// Manages puzzle step registration, dependency management, and step completion for the puzzle system.
/// </summary>
public static PuzzleManager Instance
public class PuzzleManager : MonoBehaviour
{
get
private static PuzzleManager _instance;
private static bool _isQuitting;
/// <summary>
/// Singleton instance of the PuzzleManager.
/// </summary>
public static PuzzleManager Instance
{
if (_instance == null && Application.isPlaying && !_isQuitting)
get
{
_instance = FindAnyObjectByType<PuzzleManager>();
if (_instance == null)
if (_instance == null && Application.isPlaying && !_isQuitting)
{
var go = new GameObject("PuzzleManager");
_instance = go.AddComponent<PuzzleManager>();
// DontDestroyOnLoad(go);
_instance = FindAnyObjectByType<PuzzleManager>();
if (_instance == null)
{
var go = new GameObject("PuzzleManager");
_instance = go.AddComponent<PuzzleManager>();
// DontDestroyOnLoad(go);
}
}
return _instance;
}
}
// Events to notify about step lifecycle
public event Action<PuzzleStepSO> OnStepCompleted;
public event Action<PuzzleStepSO> OnStepUnlocked;
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;
}
void OnDestroy()
{
SceneManager.sceneLoaded -= OnSceneLoaded;
}
private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
{
BuildRuntimeDependencies();
UnlockInitialSteps();
}
/// <summary>
/// Registers a step behaviour with the manager.
/// </summary>
/// <param name="behaviour">The step behaviour to register.</param>
public void RegisterStepBehaviour(ObjectiveStepBehaviour behaviour)
{
if (behaviour?.stepData == null) return;
if (!_stepBehaviours.ContainsKey(behaviour.stepData))
{
_stepBehaviours.Add(behaviour.stepData, behaviour);
Debug.Log($"[Puzzles] Registered step: {behaviour.stepData.stepId} on {behaviour.gameObject.name}");
}
}
/// <summary>
/// Unregisters a step behaviour from the manager.
/// </summary>
/// <param name="behaviour">The step behaviour to unregister.</param>
public void UnregisterStepBehaviour(ObjectiveStepBehaviour behaviour)
{
if (behaviour?.stepData == null) return;
_stepBehaviours.Remove(behaviour.stepData);
Debug.Log($"[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])
{
Debug.Log($"[Puzzles] Step {step.stepId} depends on {dep.stepId}");
}
}
return _instance;
Debug.Log($"[Puzzles] Runtime dependencies built. Total steps: {_stepBehaviours.Count}");
}
}
// Events to notify about step lifecycle
public event Action<PuzzleStepSO> StepCompleted;
public event Action<PuzzleStepSO> StepUnlocked;
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;
}
void OnDestroy()
{
SceneManager.sceneLoaded -= OnSceneLoaded;
}
private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
{
BuildRuntimeDependencies();
UnlockInitialSteps();
}
/// <summary>
/// Registers a step behaviour with the manager.
/// </summary>
/// <param name="behaviour">The step behaviour to register.</param>
public void RegisterStepBehaviour(ObjectiveStepBehaviour behaviour)
{
if (behaviour?.stepData == null) return;
if (!stepBehaviours.ContainsKey(behaviour.stepData))
/// <summary>
/// Unlocks all initial steps (those with no dependencies).
/// </summary>
private void UnlockInitialSteps()
{
stepBehaviours.Add(behaviour.stepData, behaviour);
Debug.Log($"[Puzzles] Registered step: {behaviour.stepData.stepId} on {behaviour.gameObject.name}");
}
}
/// <summary>
/// Unregisters a step behaviour from the manager.
/// </summary>
/// <param name="behaviour">The step behaviour to unregister.</param>
public void UnregisterStepBehaviour(ObjectiveStepBehaviour behaviour)
{
if (behaviour?.stepData == null) return;
stepBehaviours.Remove(behaviour.stepData);
Debug.Log($"[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])
var initialSteps = PuzzleGraphUtility.FindInitialSteps(_runtimeDependencies);
foreach (var step in initialSteps)
{
Debug.Log($"[Puzzles] Step {step.stepId} depends on {dep.stepId}");
Debug.Log($"[Puzzles] Initial step unlocked: {step.stepId}");
UnlockStep(step);
}
}
Debug.Log($"[Puzzles] Runtime dependencies built. Total steps: {stepBehaviours.Count}");
}
/// <summary>
/// Unlocks all initial steps (those with no dependencies).
/// </summary>
private void UnlockInitialSteps()
{
var initialSteps = PuzzleGraphUtility.FindInitialSteps(runtimeDependencies);
foreach (var step in initialSteps)
/// <summary>
/// Called when a step is completed. Unlocks dependent steps if their dependencies are met.
/// </summary>
/// <param name="step">The completed step.</param>
public void MarkPuzzleStepCompleted(PuzzleStepSO step)
{
Debug.Log($"[Puzzles] Initial step unlocked: {step.stepId}");
UnlockStep(step);
}
}
if (_completedSteps.Contains(step)) return;
_completedSteps.Add(step);
Debug.Log($"[Puzzles] Step completed: {step.stepId}");
/// <summary>
/// Called when a step is completed. Unlocks dependent steps if their dependencies are met.
/// </summary>
/// <param name="step">The completed step.</param>
public void OnStepCompleted(PuzzleStepSO step)
{
if (completedSteps.Contains(step)) return;
completedSteps.Add(step);
Debug.Log($"[Puzzles] Step completed: {step.stepId}");
// Broadcast completion
OnStepCompleted?.Invoke(step);
// Broadcast completion
StepCompleted?.Invoke(step);
foreach (var unlock in step.unlocks)
{
if (AreRuntimeDependenciesMet(unlock))
foreach (var unlock in step.unlocks)
{
Debug.Log($"[Puzzles] Unlocking step {unlock.stepId} after completing {step.stepId}");
UnlockStep(unlock);
if (AreRuntimeDependenciesMet(unlock))
{
Debug.Log($"[Puzzles] Unlocking step {unlock.stepId} after completing {step.stepId}");
UnlockStep(unlock);
}
else
{
Debug.Log($"[Puzzles] Step {unlock.stepId} not unlocked yet, waiting for other dependencies");
}
}
else
CheckPuzzleCompletion();
}
/// <summary>
/// Checks if all dependencies for a step are met.
/// </summary>
/// <param name="step">The step to check.</param>
/// <returns>True if all dependencies are met, false otherwise.</returns>
private bool AreRuntimeDependenciesMet(PuzzleStepSO step)
{
if (!_runtimeDependencies.ContainsKey(step) || _runtimeDependencies[step].Count == 0) return true;
foreach (var dep in _runtimeDependencies[step])
{
Debug.Log($"[Puzzles] Step {unlock.stepId} not unlocked yet, waiting for other dependencies");
if (!_completedSteps.Contains(dep)) return false;
}
return true;
}
/// <summary>
/// Unlocks a specific step and notifies its behaviour.
/// </summary>
/// <param name="step">The step to unlock.</param>
private void UnlockStep(PuzzleStepSO step)
{
if (_unlockedSteps.Contains(step)) return;
_unlockedSteps.Add(step);
if (_stepBehaviours.TryGetValue(step, out var behaviour))
{
behaviour.UnlockStep();
}
Debug.Log($"[Puzzles] Step unlocked: {step.stepId}");
// Broadcast unlock
OnStepUnlocked?.Invoke(step);
}
/// <summary>
/// Checks if the puzzle is complete (all steps finished).
/// </summary>
private void CheckPuzzleCompletion()
{
if (_completedSteps.Count == _stepBehaviours.Count)
{
Debug.Log("[Puzzles] Puzzle complete! All steps finished.");
// TODO: Fire puzzle complete event or trigger outcome logic
}
}
CheckPuzzleCompletion();
}
/// <summary>
/// Checks if all dependencies for a step are met.
/// </summary>
/// <param name="step">The step to check.</param>
/// <returns>True if all dependencies are met, false otherwise.</returns>
private bool AreRuntimeDependenciesMet(PuzzleStepSO step)
{
if (!runtimeDependencies.ContainsKey(step) || runtimeDependencies[step].Count == 0) return true;
foreach (var dep in runtimeDependencies[step])
/// <summary>
/// Returns whether a step is already unlocked.
/// </summary>
public bool IsStepUnlocked(PuzzleStepSO step)
{
if (!completedSteps.Contains(dep)) return false;
BuildRuntimeDependencies();
UnlockInitialSteps();
return _unlockedSteps.Contains(step);
}
return true;
}
/// <summary>
/// Unlocks a specific step and notifies its behaviour.
/// </summary>
/// <param name="step">The step to unlock.</param>
private void UnlockStep(PuzzleStepSO step)
{
if (unlockedSteps.Contains(step)) return;
unlockedSteps.Add(step);
if (stepBehaviours.TryGetValue(step, out var behaviour))
void OnApplicationQuit()
{
behaviour.UnlockStep();
_isQuitting = true;
}
Debug.Log($"[Puzzles] Step unlocked: {step.stepId}");
// Broadcast unlock
StepUnlocked?.Invoke(step);
}
/// <summary>
/// Checks if the puzzle is complete (all steps finished).
/// </summary>
private void CheckPuzzleCompletion()
{
if (completedSteps.Count == stepBehaviours.Count)
{
Debug.Log("[Puzzles] Puzzle complete! All steps finished.");
// TODO: Fire puzzle complete event or trigger outcome logic
}
}
/// <summary>
/// Returns whether a step is already unlocked.
/// </summary>
public bool IsStepUnlocked(PuzzleStepSO step)
{
BuildRuntimeDependencies();
UnlockInitialSteps();
return unlockedSteps.Contains(step);
}
void OnApplicationQuit()
{
_isQuitting = true;
}
}