net.dreditor.dialogues.implementation 0.0.0-stage → 0.1.6

package/DialogueAssetReader.cs

@@ -0,0 +1,378 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using DREditor.Dialogues.Ending;
+using DREditor.Dialogues.LineReading;
+using DREditor.Dialogues.Loading;
+using DREditor.EventObjects;
+using DREditor.Services;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
+
+namespace DREditor.Dialogues.Implementation
+{
+    /// <summary>
+    ///
+    /// </summary>
+    /// <remarks></remarks>
+    public class DialogueAssetReader : DialogueReader, IToTitleScreen
+    {
+        #region Fields
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Header("")]
+        [Divider]
+        [Tooltip("")]
+        [SerializeField] DialogueCore currentlyPlayingDialogue;
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Header("")]
+        [Divider]
+        [Tooltip("")]
+        [SerializeField] protected DialogueEndEventHandler DialogueEndEventHandler = null;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected DialogueEnder DialogueEnder = null;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected DialogueDataClearer DialogueClearer = null;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected DialogueLoader DialogueLoader = null;
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Header("")]
+        [Divider]
+        [Tooltip("")]
+        [SerializeField] protected IntWithEvent currentLineNum = null;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected SceneEvent updateDirectTo = null;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected BoolWithEvent isLeaving = null;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected BoolWithEvent isLoadingFile = null;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected StringWithEvent saveDialogueName = null;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected LineReader LineReader = null;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected List<DialogueComponent> DialogueReaderInitializeComponents = new();
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected List<DialogueComponent> DialogueReaderCleanUpComponents = new();
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected IEnumerable<IDialogueInteruptable> interuptables;
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected int lastLineNum = -1;
+
+        #endregion
+
+        #region Awake/Enable/Disable/Reset
+
+
+        protected virtual void Awake() => interuptables = transform.root.GetComponentsInChildren<IDialogueInteruptable>();
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void OnEnable() => SubscribeToEvents();
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void SubscribeToEvents()
+        {
+            foreach (var interuptable in interuptables)
+                interuptable.OnInteruptWithNewDialogue += PlayDialogues;
+
+            DialogueEndEventHandler.SubscribeToCleanUp(CleanUp);
+        }
+
+        
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void OnDisable() => UnsubscribeToEvents();
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void UnsubscribeToEvents()
+        {
+            foreach (var interuptable in interuptables)
+                interuptable.OnInteruptWithNewDialogue -= PlayDialogues;
+
+            DialogueEndEventHandler.UnsubscribeToCleanUp(CleanUp);
+        }
+
+        #endregion
+
+        #region Play Dialogues
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="dialogues"></param>
+        /// <remarks></remarks>
+        public virtual void PlayDialogues(DialogueCore[] dialogues)
+        {
+            List<Dialogue> dias = new();
+
+            foreach(DialogueCore dialogue in dialogues)
+                if (dialogue is Dialogue dia)
+                    dias.Add(dia);
+                else
+                    UnityEngine.Debug.LogWarning("ALERT: ISSUE PLAYING DIALOGUE WAS NOT OF DIALOGUE TYPE");
+
+            StartCoroutine(PlayDialoguesRoutine(dias.ToArray()));
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="dialogues"></param>
+        /// <param name="inLeave"></param>
+        public override void PlayDialogues<T>(DialogueBase<T>[] dialogues, bool inLeave = false) => 
+            StartCoroutine(PlayDialoguesRoutine<T>(dialogues, inLeave));
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="dialogues"></param>
+        /// <param name="intendingToLeave"></param>
+        /// <returns></returns>
+        protected virtual IEnumerator PlayDialoguesRoutine<T>(DialogueBase<T>[] dialogues, bool intendingToLeave = false) 
+            where T : Line
+        {
+            isLeaving.SetValue(intendingToLeave);
+
+            InitializeDialogueStarting();
+
+            for (int i = 0; i < dialogues.Length; i++)
+            {
+                DialogueBase<T> currentDialogue = dialogues[i];
+
+                if (i != 0)
+                    updateDirectTo.Raise();
+
+                bool stopParent = false;
+
+                yield return PlayDialogue(currentDialogue, () => stopParent = true);
+
+                LineReader.ClearSaveData();
+
+                if (stopParent)
+                    yield break;
+            }
+
+            CleanUp();
+
+            DialogueEnder.StopDialogue();
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void InitializeDialogueStarting()
+        {
+            if (!isLoadingFile.Value)
+                LineReader.ClearSaveDataOnDialogueStart();
+
+            foreach (IDialogueReaderInitialize initializer in DialogueReaderInitializeComponents.Cast<IDialogueReaderInitialize>())
+                initializer.OnDialogueReaderInitialize();
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        public override void CleanUp()
+        {
+            DialogueClearer.ClearSaveData();
+
+            foreach (IDialogueReaderCleanUp cleanUpComponent in DialogueReaderCleanUpComponents.Cast<IDialogueReaderCleanUp>())
+                cleanUpComponent?.OnDialogueReaderCleanUp();
+        }
+
+        #endregion
+
+        #region Play Dialogue
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="currentDialogue"></param>
+        /// <param name="exitParentRoutine"></param>
+        protected virtual IEnumerator PlayDialogue<T>(DialogueBase<T> currentDialogue, Action exitParentRoutine = null) 
+            where T : Line
+        {
+            currentlyPlayingDialogue = currentDialogue;
+
+            for (int i = 0; i < currentDialogue.Lines.Count; i++)
+            {
+                Line currentLine = currentDialogue.Lines[i];
+
+                if (isLoadingFile.Value)
+                    yield return DialogueLoader.LoadToDialogueLine<T>(currentDialogue,
+                        loadedIndex => { i = loadedIndex; currentLine = currentDialogue.Lines[i]; });
+
+                SetLineNumber(i);
+
+
+                bool exitEarly = false;
+
+                bool continueLine = false;
+
+                yield return LineReader.PlayDialogueLine(currentDialogue, currentLine, () => exitEarly = true, () => continueLine = true);
+
+                if (exitEarly)
+                {
+                    exitParentRoutine?.Invoke();
+
+                    yield break;
+                }
+
+                if (continueLine)
+                    continue;
+            }
+
+            // The dialogue reader has finished reading the dialogue lines.
+
+            SetLineOutOfBounds();
+
+
+            bool exitParent = false;
+
+            yield return DialogueEndEventHandler.EndDialogueEventOptions(currentDialogue, () => exitParent = true);
+
+            if (exitParent)
+                exitParentRoutine?.Invoke();
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="currentLineNum"></param>
+        protected virtual void SetLineNumber(int currentLineNum) => this.currentLineNum.SetValue(currentLineNum);
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void SetLineOutOfBounds()
+        {
+            lastLineNum = currentLineNum.Value;
+
+            SetLineNumber(-1); 
+        }
+
+        #endregion
+
+        #region Additional Public Functions
+
+        /// <inheritdoc/>
+        public override void MidDialogueEnterance<T>(DialogueBase<T>[] dialogues)
+        {
+            if (dialogues.Length == 0)
+            {
+                UnityEngine.Debug.LogWarning("ALERT: Tried to send MidDialogue without dialogues!");
+
+                return;
+            }
+
+            DialogueClearer.ClearSaveData();
+
+            saveDialogueName.SetValue(dialogues[0].name);
+
+            PlayDialogues<T>(dialogues);
+        }
+
+        /// <inheritdoc/>
+        public override bool IsOnLastLine() => 
+            GetCurrentDialogue() != null && GetCurrentLineNum() == GetCurrentDialogue().LineCount - 1;
+
+        /// <inheritdoc/>
+        public override DialogueCore GetCurrentDialogue() => currentlyPlayingDialogue;
+
+        /// <inheritdoc/>
+        public override int GetCurrentLineNum() => currentLineNum.Value;
+
+        /// <inheritdoc/>
+        public override Line GetCurrentLine()
+        {
+            int currentLineNumber = GetCurrentLineNum();
+
+            bool linesAreBeingRead = currentLineNumber != -1;
+
+            int lineNumber = linesAreBeingRead ? currentLineNumber : lastLineNum;
+
+            if (linesAreBeingRead)
+                lastLineNum = -1;
+
+            return GetCurrentDialogue().GetLine(lineNumber);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        public virtual void ToTitleScreen()
+        {
+            SetLineOutOfBounds();
+
+            StopAllCoroutines();
+        }
+
+        #endregion
+    }
+}

package/DialogueAssetReader.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5c3c35cde306d124eb430447d2f44553
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/DialogueAssetStarter.cs

@@ -0,0 +1,255 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using DREditor.Dialogues.Ending;
+using DREditor.Dialogues.Loading;
+using DREditor.Dialogues.Starting;
+using DREditor.EventObjects;
+using DREditor.Services;
+using System;
+using System.Collections;
+using UnityEngine;
+
+namespace DREditor.Dialogues.Implementation
+{
+    /// <summary>
+    ///
+    /// </summary>
+    [ClassHeader(nameof(PreparableDialogueStarter) + ", " + nameof(IDialogueStartEvent) + ", " +
+        nameof(PreparableDialogueStarter) + ", " + nameof(DialogueStarter) + ", " + nameof(IDialoguePrepareEvent) +
+        "\n\n")]
+    public class DialogueAssetStarter : PreparableDialogueStarter, IDialogueStartEvent
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        [Header("")]
+        [Divider]
+        [Tooltip("")]
+        [SerializeField] protected BoolWithEvent inDialogue = null;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected BoolWithEvent isLeaving = null;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected StringWithEvent currentControlsKey = null;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected BoolWithEvent hasMenuAccess = null;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected BoolWithEvent isLoadingFile = null;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected StringWithEvent saveDialogueName = null;
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Header("")]
+        [Divider]
+        [Tooltip("")]
+        [SerializeField] protected DialogueWaiter DialogueWaiter = null;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected DialogueStarter InstantDialogueStarter = null;
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Header("")]
+        [Divider]
+        [Tooltip("")]
+        [SerializeField] protected string setDialogueControlKey = "dialogue";
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        public event Action<DialogueCore> OnDialogueStarted;
+
+
+        #region Start Dialogue
+
+        /// <inheritdoc/>
+        public override void StartDialogue<T>(SelectableObject actor, DialogueBase<T>[] dialogues, bool inleaving = false)
+            => StartDialogueProcess(actor, dialogues, inleaving);
+
+        public override void StartDialogue<T>(SelectableObject actor, DialogueBase<T> dialogue, bool inleaving = false) 
+            => StartDialogue(actor, new DialogueBase<T>[1] { dialogue }, inleaving);
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="coreActor"></param>
+        /// <param name="coreDialogues"></param>
+        /// <param name="inleaving"></param>
+        protected virtual void StartDialogueProcess<T>(SelectableObject coreActor, DialogueBase<T>[] coreDialogues,
+            bool inleaving = false) 
+            where T : Line
+        {
+            if (SentDialoguesEmpty(coreDialogues))
+                return;
+
+            UnityEngine.Debug.Log($"{ToString()}: Starting Dialogue is named: " + coreDialogues[0].name);
+
+            saveDialogueName.SetValue(coreDialogues[0].name);
+
+            SetValueWithEvents(inleaving);
+
+            if (coreDialogues[0] is IInstantAbleDialogue instantable && instantable.GetInstant())
+                EvaluateInstantDialogue(coreActor, coreDialogues, inleaving);
+            else
+                StartCoroutine(BeginDialoguePreparations(coreActor, coreDialogues, inleaving));
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="intendingToLeave"></param>
+        protected virtual void SetValueWithEvents(bool intendingToLeave = false)
+        {
+            currentControlsKey.SetValue(setDialogueControlKey);
+
+            hasMenuAccess.SetValue(false);
+
+            isLeaving.SetValue(intendingToLeave);
+
+            // Added 4-30-2026 Moving to a place that starts dialogue on load showed the reticle when it shouldn't, this fixes that.
+            // The reason the other call in this script hasn't been removed is because it's unclear as to whether there would 
+            // be any adverse affects from doing so, I mean without the call here, the issue mentioned wouldn't be happening.
+            // If there are any adverse effects of inDialogue being active too early, then the issue mentioned must also be 
+            // fixed if this line is to be removed.
+            inDialogue.SetValue(true);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="dialogues"></param>
+        /// <returns></returns>
+        protected virtual bool SentDialoguesEmpty(DialogueCore[] dialogues)
+        {
+            bool dialoguesAreEmpty = dialogues == null || dialogues.Length == 0 || dialogues[0] == null;
+
+            if (dialoguesAreEmpty)
+            {
+                ServiceLocator.GetService<IDialogueManager>().GetEnder().StopDialogue();
+
+                UnityEngine.Debug.LogWarning($"{ToString()}:Sent dialogues were empty.");
+            }
+
+            return dialoguesAreEmpty;
+        }
+
+        #endregion
+
+        #region Dialogue Preparations
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="actor"></param>
+        /// <param name="dialogues"></param>
+        /// <param name="inleaving"></param>
+        protected virtual IEnumerator BeginDialoguePreparations<T>(SelectableObject actor, DialogueBase<T>[] dialogues,
+            bool inleaving = false)
+            where T : Line
+        {
+            InvokeDialoguePreparationEvent();
+
+            yield return DialogueWaiter.CheckIfInDialogueToPlay(dialogues[0]);
+
+            VerifyStartActor(actor);
+
+            inDialogue.SetValue(true);
+
+            OnDialogueStarted?.Invoke(dialogues[0]);
+
+            UnityEngine.Debug.Log($"REPORT: {nameof(DialogueAssetStarter)}: " +
+                $"Starting to Prepare Dialogue.");
+
+            yield return PrepareDialogueComponents();
+
+            UnityEngine.Debug.Log($"REPORT: {nameof(DialogueAssetStarter)}: " +
+                $"Prepared Dialogue while Loading File is: " + isLoadingFile.Value);
+
+            if (isLoadingFile.Value)
+                dialogues = ServiceLocator.GetService<IDialogueManager>()
+                .GetManagerComponent<DialogueLoader>()
+                .StartLoadThrough(dialogues);
+
+            ServiceLocator.GetService<IDialogueManager>()
+                .GetReader()
+                .PlayDialogues(dialogues, inleaving);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="actor"></param>
+        protected virtual void VerifyStartActor(SelectableObject actor)
+        {
+            if (ServiceLocator.HasService<DialogueObjectManager>())
+                ServiceLocator.GetService<DialogueObjectManager>().AttemptSetStartingDialogueObject(actor);
+            else
+                UnityEngine.Debug.LogWarning($"ALERT: There are no {nameof(DialogueObjectManager)}s in the scene," +
+                    $" the starting actor will skip validity checking.");
+        }
+
+        #endregion
+
+        #region Instant Dialogue
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="actor"></param>
+        /// <param name="dialogues"></param>
+        /// <param name="inleaving"></param>
+        protected virtual void EvaluateInstantDialogue<T>(SelectableObject actor, DialogueBase<T>[] dialogues,
+            bool inleaving = false) 
+            where T : Line
+        {
+            if (InstantDialogueStarter == this)
+            {
+                UnityEngine.Debug.LogError("ALERT: ERROR: YOU CANNOT USE THE SAME DIALOGUE STARTER FOR INSTANT DIALOGUE, " +
+                    "THIS WILL LOOP CODE. " +
+                    "USE INSTANTDIALOGUESTARTER SCRIPT INSTEAD. REMOVING REFERENCE.");
+
+                InstantDialogueStarter = null;
+            }
+
+            if (InstantDialogueStarter == null)
+            {
+                UnityEngine.Debug.LogWarning("REPORT: An Instant Dialogue Starter hasn't been assigned. Using Default Starter Instead.");
+
+                StartCoroutine(BeginDialoguePreparations(actor, dialogues, inleaving));
+
+                return;
+            }
+
+            InstantDialogueStarter.StartDialogue(actor, dialogues, inleaving);
+        }
+
+        #endregion
+    }
+}

package/DialogueAssetStarter.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: be8c7a41d1f924c4a9385074386de1d2
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/DialogueAssetStarterDebugger.cs

@@ -0,0 +1,41 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using DREditor.Dialogues.Starting;
+using DREditor.EventObjects;
+using UnityEngine;
+
+namespace DREditor.Dialogues.Implementation
+{
+    /// <summary>
+    ///
+    /// </summary>
+    [ClassHeader(nameof(DialogueStarterDebugger) + 
+        "\n\n")]
+    [RequireComponent(typeof(DialogueStarter))]
+    public class DialogueAssetStarterDebugger : DialogueStarterDebugger
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="actor"></param>
+        /// <param name="DebugNoDialogue"></param>
+        public override void DebugNoCharacterDialogueCall(SelectableObject actor, DialogueCore DebugNoDialogue = null)
+        {
+            Dialogue dialogueDebug = (Dialogue)DebugNoDialogue;
+
+            Dialogue[] Conversation = new Dialogue[1];
+
+            Dialogue dialogue = ScriptableObject.CreateInstance<Dialogue>();
+
+            dialogue.Lines.Add(new Line());
+
+            dialogue.Lines[0].SetText("THIS CHARACTER HAS NO DIALOGUE PLUGGED IN DO NOT SAVE ON THIS LINE!");
+
+            Conversation[0] = dialogue;
+
+            if (DebugNoDialogue != null)
+                Conversation[0] = dialogueDebug;
+
+            GetComponent<DialogueStarter>().StartDialogue(actor, Conversation);
+        }
+    }
+}