using UnityEngine; using System.Collections.Generic; // Required for lists if adding choices later /// <summary> /// Represents a single node (line) in a dialogue sequence. /// Uses ScriptableObject so dialogue lines can be created and managed as assets. /// </summary> [CreateAssetMenu(fileName = "New Dialogue Node", menuName = "Dialogue System/Dialogue Node")] public class DialogueNode : ScriptableObject { [Tooltip("Optional: Name of the speaker for this line. If empty, uses NPC's default name.")] public string speakerName; // Can be overridden per node [Tooltip("Optional: Portrait of the speaker for this line.")] public Sprite speakerPortrait; // Can be overridden per node [TextArea(3, 10)] [Tooltip("The text content of this dialogue line.")] public string dialogueText; [Tooltip("The next node in the sequence. If null, this is the end of the dialogue branch.")] public DialogueNode nextNode; // --- Potential Future Extensions --- // public List<DialogueChoice> choices; // For branching dialogue // public UnityEvent onNodeStart; // Event triggered when this node starts // public UnityEvent onNodeEnd; // Event triggered when this node ends } // --- Example of a Choice structure (for future extension) --- // [System.Serializable] // public class DialogueChoice // { // public string choiceText; // public DialogueNode nextNode; // Node to jump to if this choice is selected // } using UnityEngine; /// <summary> /// Represents a complete dialogue conversation, starting with an initial node. /// Uses ScriptableObject so dialogues can be created and managed as assets. /// </summary> [CreateAssetMenu(fileName = "New Dialogue", menuName = "Dialogue System/Dialogue")] public class Dialogue : ScriptableObject { [Tooltip("The very first node to display when this dialogue starts.")] public DialogueNode startingNode; [Tooltip("Default speaker name if not overridden in a DialogueNode.")] public string defaultSpeakerName = "NPC"; [Tooltip("Default speaker portrait if not overridden in a DialogueNode.")] public Sprite defaultSpeakerPortrait; // --- Potential Future Extensions --- // public bool isRepeatable = true; // public Quest prerequisiteQuest; // Only allow dialogue if a certain quest is active/complete // public UnityEvent onDialogueStart; // public UnityEvent onDialogueEnd; } using UnityEngine; using UnityEngine.Events; // Required for UnityEvent /// <summary> /// Component to attach to NPCs or interactable objects to initiate a dialogue. /// </summary> public class DialogueTrigger : MonoBehaviour { [Tooltip("The Dialogue asset containing the conversation to start.")] [SerializeField] private Dialogue dialogue; [Tooltip("Should the dialogue trigger automatically on proximity (using Collider2D)?")] [SerializeField] private bool triggerOnProximity = true; [Tooltip("Key to press to manually trigger dialogue when in proximity (if not automatic).")] [SerializeField] private KeyCode interactionKey = KeyCode.E; [Tooltip("Optional: Event triggered when the player enters the trigger zone.")] public UnityEvent onPlayerEnter; [Tooltip("Optional: Event triggered when the player exits the trigger zone.")] public UnityEvent onPlayerExit; private bool playerInRange = false; private void Update() { // Manual trigger check if player is in range and proximity trigger is off OR requires key if (playerInRange && !triggerOnProximity) { if (Input.GetKeyDown(interactionKey)) { StartDialogue(); } } } private void OnTriggerEnter2D(Collider2D other) { // Basic check - refine this tag check for your specific player setup if (other.CompareTag("Player")) { playerInRange = true; onPlayerEnter?.Invoke(); // Invoke enter event if (triggerOnProximity) { StartDialogue(); } else { // Optionally show an interaction prompt UI here Debug.Log($"Press {interactionKey} to talk to {gameObject.name}"); } } } private void OnTriggerExit2D(Collider2D other) { if (other.CompareTag("Player")) { playerInRange = false; onPlayerExit?.Invoke(); // Invoke exit event // Optionally hide interaction prompt UI here } } /// <summary> /// Starts the dialogue using the DialogueManager. /// </summary> public void StartDialogue() { if (dialogue != null) { DialogueManager.Instance?.StartDialogue(dialogue); } else { Debug.LogWarning($"No Dialogue asset assigned to {gameObject.name}", this); } } } using UnityEngine; using System.Collections; // Required for Coroutines /// <summary> /// Manages the flow of dialogue conversations and interacts with the DialogueUI. /// Implements the Singleton pattern. /// </summary> public class DialogueManager : MonoBehaviour { #region Singleton private static DialogueManager _instance; public static DialogueManager Instance { get { if (_instance == null) { // Try to find an existing instance in the scene _instance = FindObjectOfType<DialogueManager>(); // If not found, create a new GameObject and add the component if (_instance == null) { GameObject singletonObject = new GameObject("DialogueManager"); _instance = singletonObject.AddComponent<DialogueManager>(); Debug.Log("DialogueManager instance created."); } } return _instance; } } private void Awake() { // Ensure only one instance exists if (_instance != null && _instance != this) { Debug.LogWarning("Duplicate DialogueManager found. Destroying the new one."); Destroy(gameObject); } else { _instance = this; // Optional: Keep the manager across scene loads // DontDestroyOnLoad(gameObject); } } #endregion [Tooltip("Reference to the DialogueUI component in the scene.")] [SerializeField] private DialogueUI dialogueUI; [Tooltip("Key to press to advance the dialogue.")] [SerializeField] private KeyCode advanceKey = KeyCode.Space; // Or KeyCode.E, Mouse0 etc. private Dialogue currentDialogue; private DialogueNode currentNode; private bool isDialogueActive = false; private Coroutine typingCoroutine; // To handle text reveal effect private void Start() { // Ensure DialogueUI is assigned if (dialogueUI == null) { dialogueUI = FindObjectOfType<DialogueUI>(); if (dialogueUI == null) { Debug.LogError("DialogueManager could not find a DialogueUI component in the scene!", this); this.enabled = false; // Disable manager if UI is missing return; } Debug.Log("DialogueManager automatically found DialogueUI."); } dialogueUI.HideUI(); // Start with UI hidden } private void Update() { // Handle advancing dialogue if (isDialogueActive && Input.GetKeyDown(advanceKey)) { // If text is still typing, skip to the end if (typingCoroutine != null) { StopCoroutine(typingCoroutine); typingCoroutine = null; dialogueUI.SetDialogueText(currentNode.dialogueText); // Show full text immediately } // Otherwise, advance to the next node else { AdvanceDialogue(); } } } /// <summary> /// Starts a new dialogue conversation. /// </summary> /// <param name="dialogueToStart">The Dialogue asset to begin.</param> public void StartDialogue(Dialogue dialogueToStart) { if (isDialogueActive) { Debug.LogWarning("Tried to start a new dialogue while one is already active."); return; // Don't start if already in dialogue } if (dialogueToStart == null || dialogueToStart.startingNode == null) { Debug.LogError("Cannot start dialogue: Dialogue asset or starting node is null.", dialogueToStart); return; } currentDialogue = dialogueToStart; currentNode = currentDialogue.startingNode; isDialogueActive = true; // Optional: Pause game, disable player movement etc. // Time.timeScale = 0f; dialogueUI.ShowUI(); DisplayNode(currentNode); Debug.Log($"Dialogue Started: {currentDialogue.name}"); } /// <summary> /// Displays the content of the current dialogue node in the UI. /// </summary> /// <param name="node">The node to display.</param> private void DisplayNode(DialogueNode node) { if (node == null) { EndDialogue(); return; } currentNode = node; // Update current node reference // Determine speaker name and portrait (use node override or dialogue default) string speakerName = string.IsNullOrEmpty(node.speakerName) ? currentDialogue.defaultSpeakerName : node.speakerName; Sprite speakerPortrait = node.speakerPortrait != null ? node.speakerPortrait : currentDialogue.defaultSpeakerPortrait; dialogueUI.SetSpeaker(speakerName, speakerPortrait); // Start typing effect if enabled in UI, otherwise set text directly if (dialogueUI.useTypingEffect) { if (typingCoroutine != null) StopCoroutine(typingCoroutine); typingCoroutine = StartCoroutine(dialogueUI.TypeSentence(node.dialogueText)); } else { dialogueUI.SetDialogueText(node.dialogueText); } } /// <summary> /// Advances the dialogue to the next node. /// </summary> private void AdvanceDialogue() { if (!isDialogueActive || currentNode == null) return; if (currentNode.nextNode != null) { DisplayNode(currentNode.nextNode); } else { // Reached the end of this branch/dialogue EndDialogue(); } } /// <summary> /// Ends the current dialogue conversation. /// </summary> public void EndDialogue() { if (!isDialogueActive) return; // Avoid ending if not active if (typingCoroutine != null) { StopCoroutine(typingCoroutine); typingCoroutine = null; } isDialogueActive = false; dialogueUI.HideUI(); currentNode = null; // Optional: Resume game, enable player movement etc. // Time.timeScale = 1f; Debug.Log($"Dialogue Ended: {currentDialogue?.name}"); currentDialogue = null; } /// <summary> /// Checks if a dialogue is currently active. /// </summary> public bool IsDialogueActive() { return isDialogueActive; } } using UnityEngine; using UnityEngine.UI; // Required for Image, Button using TMPro; // Required for TextMeshProUGUI using System.Collections; // Required for Coroutines /// <summary> /// Handles displaying dialogue content in the UI. /// Assumes a specific UI structure (Panel, TextMeshProUGUI, Image). /// </summary> public class DialogueUI : MonoBehaviour { [Header("UI Elements")] [Tooltip("The main panel containing all dialogue UI elements.")] [SerializeField] private GameObject dialoguePanel; [Tooltip("TextMeshProUGUI component for displaying the speaker's name.")] [SerializeField] private TextMeshProUGUI speakerNameText; [Tooltip("TextMeshProUGUI component for displaying the dialogue text.")] [SerializeField] private TextMeshProUGUI dialogueText; [Tooltip("Image component for displaying the speaker's portrait.")] [SerializeField] private Image speakerPortraitImage; // Optional: Add reference for a "Continue" prompt/button indicator [Header("Typing Effect (Optional)")] [Tooltip("Enable the character-by-character typing effect.")] public bool useTypingEffect = true; [Tooltip("Delay between characters appearing (in seconds).")] [SerializeField] private float typingSpeed = 0.03f; private void Awake() { // Basic validation if (dialoguePanel == null || speakerNameText == null || dialogueText == null || speakerPortraitImage == null) { Debug.LogError("DialogueUI is missing references to one or more UI elements!", this); } // Ensure portrait image component exists if a reference is assigned if (speakerPortraitImage != null && speakerPortraitImage.GetComponent<Image>() == null) { Debug.LogError("Speaker Portrait object does not have an Image component!", speakerPortraitImage); } } /// <summary> /// Shows the dialogue UI panel. /// </summary> public void ShowUI() { if (dialoguePanel != null) { dialoguePanel.SetActive(true); } } /// <summary> /// Hides the dialogue UI panel. /// </summary> public void HideUI() { if (dialoguePanel != null) { dialoguePanel.SetActive(false); } } /// <summary> /// Sets the speaker's name and portrait in the UI. /// </summary> /// <param name="name">Speaker's name.</param> /// <param name="portrait">Speaker's portrait sprite.</param> public void SetSpeaker(string name, Sprite portrait) { if (speakerNameText != null) { speakerNameText.text = name ?? ""; // Use empty string if name is null speakerNameText.gameObject.SetActive(!string.IsNullOrEmpty(name)); // Hide if name is empty } if (speakerPortraitImage != null) { if (portrait != null) { speakerPortraitImage.sprite = portrait; speakerPortraitImage.enabled = true; // Show image } else { speakerPortraitImage.enabled = false; // Hide image if no portrait } } } /// <summary> /// Sets the main dialogue text directly (no typing effect). /// </summary> /// <param name="text">The dialogue text to display.</param> public void SetDialogueText(string text) { if (dialogueText != null) { dialogueText.text = text ?? ""; // Use empty string if text is null } } /// <summary> /// Coroutine for the typing effect. Clears existing text first. /// </summary> /// <param name="sentence">The sentence to type out.</param> public IEnumerator TypeSentence(string sentence) { if (dialogueText == null) yield break; // Exit if no text component dialogueText.text = ""; // Clear previous text if (string.IsNullOrEmpty(sentence)) yield break; // Exit if sentence is empty foreach (char letter in sentence.ToCharArray()) { dialogueText.text += letter; if (typingSpeed > 0) { yield return new WaitForSeconds(typingSpeed); } else { yield return null; // Yield for one frame if speed is zero or less } } } } using UnityEngine; using UnityEditor; /// <summary> /// Custom editor for DialogueNode to provide a slightly better inspector experience. /// (Optional, but helpful) /// </summary> [CustomEditor(typeof(DialogueNode))] public class DialogueNodeEditor : Editor { public override void OnInspectorGUI() { serializedObject.Update(); // Always start with this DialogueNode node = (DialogueNode)target; EditorGUILayout.LabelField("Dialogue Content", EditorStyles.boldLabel); EditorGUILayout.PropertyField(serializedObject.FindProperty("speakerName")); EditorGUILayout.PropertyField(serializedObject.FindProperty("speakerPortrait")); EditorGUILayout.PropertyField(serializedObject.FindProperty("dialogueText"), GUILayout.Height(80)); // Make text area taller EditorGUILayout.Space(10); EditorGUILayout.LabelField("Flow Control", EditorStyles.boldLabel); EditorGUILayout.PropertyField(serializedObject.FindProperty("nextNode")); // You could add buttons here later for creating/linking nodes automatically serializedObject.ApplyModifiedProperties(); // Always end with this } }