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

Create a simple dialogue authoring system, tied into our items (#10)

Browse Source 
- Editor dialogue graph
- Asset importer for processing the graph into runtime data
- DialogueComponent that steers the dialogue interactions
- DialogueCanbas with a scalable speech bubble to display everything
- Brief README overview of the system

Co-authored-by: AlexanderT <alexander@foolhardyhorizons.com>
Co-authored-by: Michal Pikulski <michal.a.pikulski@gmail.com>
Reviewed-on: #10
This commit is contained in:
tschesky
2025-09-29 09:34:15 +00:00
parent 2cd791f69d
commit f686f28cb8
73 changed files with 6530 additions and 173 deletions
Download Patch File Download Diff File Expand all files Collapse all files

263
Assets/Scripts/Core/ItemManager.cs Normal file
View File

@@ -0,0 +1,263 @@
using System;
using System.Collections.Generic;
using UnityEngine;
using Interactions;
namespace Core
{
/// <summary>
/// Central registry for pickups and item slots.
/// Mirrors the singleton pattern used by PuzzleManager.
/// </summary>
public class ItemManager : MonoBehaviour
{
private static ItemManager _instance;
private static bool _isQuitting;
public static ItemManager Instance
{
get
{
if (_instance == null && Application.isPlaying && !_isQuitting)
{
_instance = FindAnyObjectByType<ItemManager>();
if (_instance == null)
{
var go = new GameObject("ItemManager");
_instance = go.AddComponent<ItemManager>();
// DontDestroyOnLoad(go);
}
}
return _instance;
}
}
private readonly HashSet<Pickup> _pickups = new HashSet<Pickup>();
private readonly HashSet<ItemSlot> _itemSlots = new HashSet<ItemSlot>();
private readonly HashSet<string> _itemsCreatedThroughCombination = new HashSet<string>();
// Central events forwarded from registered pickups/slots
// Broadcasts when any registered pickup was picked up (passes the picked item data)
public event Action<PickupItemData> OnItemPickedUp;
// Broadcasts when any registered ItemSlot reports a correct item slotted
// Args: slot's itemData (the slot definition), then the slotted item data
public event Action<PickupItemData, PickupItemData> OnCorrectItemSlotted;
// Broadcasts when any registered ItemSlot reports an incorrect item slotted
// Args: slot's itemData (the slot definition), then the slotted item data
public event Action<PickupItemData, PickupItemData> OnIncorrectItemSlotted;
// Broadcasts when any registered ItemSlot reports a forbidden item slotted
// Args: slot's itemData (the slot definition), then the slotted item data
public event Action<PickupItemData, PickupItemData> OnForbiddenItemSlotted;
// Broadcasts when any registered ItemSlot is cleared (item removed)
// Args: the item data that was removed
public event Action<PickupItemData> OnItemSlotCleared;
// Broadcasts when any two items are successfully combined
// Args: first item data, second item data, result item data
public event Action<PickupItemData, PickupItemData, PickupItemData> OnItemsCombined;
void Awake()
{
_instance = this;
}
void Start()
{
// Subscribe to scene load completed so we can clear registrations when scenes change
// Access Instance directly to ensure the service is initialized and we get the event hookup.
SceneManagerService.Instance.SceneLoadCompleted += OnSceneLoadCompleted;
}
void OnDestroy()
{
// Unsubscribe from SceneManagerService
if (SceneManagerService.Instance != null)
SceneManagerService.Instance.SceneLoadCompleted -= OnSceneLoadCompleted;
// Ensure we clean up any subscriptions from registered items when the manager is destroyed
ClearAllRegistrations();
}
void OnApplicationQuit()
{
_isQuitting = true;
}
private void OnSceneLoadCompleted(string sceneName)
{
// Clear all registrations when a new scene is loaded, so no stale references persist
ClearAllRegistrations();
}
// Handler that forwards pickup events
private void Pickup_OnItemPickedUp(PickupItemData data)
{
OnItemPickedUp?.Invoke(data);
}
// Handler that forwards correct-slot events
private void ItemSlot_OnCorrectItemSlotted(PickupItemData slotData, PickupItemData slottedItem)
{
OnCorrectItemSlotted?.Invoke(slotData, slottedItem);
}
// Handler that forwards incorrect-slot events
private void ItemSlot_OnIncorrectItemSlotted(PickupItemData slotData, PickupItemData slottedItem)
{
OnIncorrectItemSlotted?.Invoke(slotData, slottedItem);
}
// Handler that forwards forbidden-slot events
private void ItemSlot_OnForbiddenItemSlotted(PickupItemData slotData, PickupItemData slottedItem)
{
OnForbiddenItemSlotted?.Invoke(slotData, slottedItem);
}
// Handler that forwards item combination events
private void Pickup_OnItemsCombined(PickupItemData itemA, PickupItemData itemB, PickupItemData resultItem)
{
// Track the created item
if (resultItem != null)
{
_itemsCreatedThroughCombination.Add(resultItem.itemId);
}
OnItemsCombined?.Invoke(itemA, itemB, resultItem);
}
// Handler that forwards slot-removed events
private void ItemSlot_OnItemSlotRemoved(PickupItemData removedItem)
{
OnItemSlotCleared?.Invoke(removedItem);
}
/// <summary>
/// Unsubscribe all pickup/slot event handlers and clear registries and manager events.
/// </summary>
private void ClearAllRegistrations()
{
// Unsubscribe pickup handlers
var pickupsCopy = new List<Pickup>(_pickups);
foreach (var p in pickupsCopy)
{
if (p != null)
{
p.OnItemPickedUp -= Pickup_OnItemPickedUp;
p.OnItemsCombined -= Pickup_OnItemsCombined;
}
}
_pickups.Clear();
// Unsubscribe slot handlers
var slotsCopy = new List<ItemSlot>(_itemSlots);
foreach (var s in slotsCopy)
{
if (s != null)
{
s.OnCorrectItemSlotted -= ItemSlot_OnCorrectItemSlotted;
s.OnIncorrectItemSlotted -= ItemSlot_OnIncorrectItemSlotted;
s.OnForbiddenItemSlotted -= ItemSlot_OnForbiddenItemSlotted;
s.OnItemSlotRemoved -= ItemSlot_OnItemSlotRemoved;
}
}
_itemSlots.Clear();
// Clear item tracking
_itemsCreatedThroughCombination.Clear();
// Clear manager-level event subscribers
OnItemPickedUp = null;
OnCorrectItemSlotted = null;
OnIncorrectItemSlotted = null;
OnForbiddenItemSlotted = null;
OnItemSlotCleared = null;
OnItemsCombined = null;
}
public void RegisterPickup(Pickup pickup)
{
if (pickup == null) return;
// only subscribe if newly added to avoid duplicate subscriptions
if (_pickups.Add(pickup))
{
pickup.OnItemPickedUp += Pickup_OnItemPickedUp;
pickup.OnItemsCombined += Pickup_OnItemsCombined;
}
}
public void UnregisterPickup(Pickup pickup)
{
if (pickup == null) return;
if (_pickups.Remove(pickup))
{
pickup.OnItemPickedUp -= Pickup_OnItemPickedUp;
pickup.OnItemsCombined -= Pickup_OnItemsCombined;
}
}
public void RegisterItemSlot(ItemSlot slot)
{
if (slot == null) return;
if (_itemSlots.Add(slot))
{
// Subscribe to all slot events
slot.OnCorrectItemSlotted += ItemSlot_OnCorrectItemSlotted;
slot.OnIncorrectItemSlotted += ItemSlot_OnIncorrectItemSlotted;
slot.OnForbiddenItemSlotted += ItemSlot_OnForbiddenItemSlotted;
slot.OnItemSlotRemoved += ItemSlot_OnItemSlotRemoved;
}
}
public void UnregisterItemSlot(ItemSlot slot)
{
if (slot == null) return;
if (_itemSlots.Remove(slot))
{
// Unsubscribe from all slot events
slot.OnCorrectItemSlotted -= ItemSlot_OnCorrectItemSlotted;
slot.OnIncorrectItemSlotted -= ItemSlot_OnIncorrectItemSlotted;
slot.OnForbiddenItemSlotted -= ItemSlot_OnForbiddenItemSlotted;
slot.OnItemSlotRemoved -= ItemSlot_OnItemSlotRemoved;
}
}
/// <summary>
/// Checks if a specific item has been created through item combination.
/// </summary>
/// <param name="itemId">The ID of the item to check.</param>
/// <returns>True if the item has been created through combination, false otherwise.</returns>
public bool WasItemCreatedThroughCombination(string itemId)
{
return !string.IsNullOrEmpty(itemId) && _itemsCreatedThroughCombination.Contains(itemId);
}
/// <summary>
/// Returns the current slot state for the given item data by searching registered slots.
/// If the item is currently slotted in a slot, returns that slot's state; otherwise returns ItemSlotState.None.
/// </summary>
public ItemSlotState GetSlotStatusForItem(PickupItemData itemData)
{
if (itemData == null) return ItemSlotState.None;
foreach (var slot in _itemSlots)
{
var slottedObj = slot.GetSlottedObject();
if (slottedObj == null) continue;
var pickup = slottedObj.GetComponent<Pickup>();
if (pickup == null) continue;
if (pickup.itemData == itemData)
{
return slot.CurrentSlottedState;
}
}
return ItemSlotState.None;
}
public IEnumerable<Pickup> Pickups => _pickups;
public IEnumerable<ItemSlot> ItemSlots => _itemSlots;
}
}

3
Assets/Scripts/Core/ItemManager.cs.meta Normal file
View File

@@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: a78fe78378e6426da43710f6d0ae84ba
timeCreated: 1758888493