net.dreditor.dialogueeventmanaging 0.0.0-stage → 0.1.7

package/CharacterLeaveDialogueEvent.cs

@@ -0,0 +1,14 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using DREditor.Dialogues;
+using DREditor.Dialogues.Events;
+using DREditor.Dialogues.LineReading;
+
+namespace DREditor.DialogueEventManaging
+{
+    /// <summary>
+    ///
+    /// </summary>
+    [ClassHeader(nameof(LineProcessDialogueEvent<CharacterLeave>) + " for the Dialogue Event: " + nameof(CharacterLeave) +
+        "\n\n")]
+    public class CharacterLeaveDialogueEvent : LineProcessDialogueEvent<CharacterLeave> { }
+}

package/CharacterLeaveDialogueEvent.cs.meta

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

package/DREditor.DialogueEventManaging.asmdef

@@ -0,0 +1,17 @@
+{
+    "name": "DREditor.DialogueEventManaging",
+    "rootNamespace": "",
+    "references": [
+        "DREditor",
+        "DREditor.Investigations"
+    ],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}

package/DREditor.DialogueEventManaging.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 2d78ccb046d3233479c6c3d835f1326d
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/DialogueEventExcluder.cs

@@ -0,0 +1,40 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using DREditor.Dialogues.Events;
+using System;
+using UnityEngine;
+
+namespace DREditor.DialogueEventManaging
+{
+    /// <summary>
+    ///
+    /// </summary>
+    public class DialogueEventExcluder : DialogueEventTypeExcluder
+    {
+        /// <inheritdoc/>
+        public override bool IsExcludedEvent(IDialogueEvent dialogueEvent)
+        {
+            foreach (IDialogueEvent type in exclusionTypes)
+                if (dialogueEvent.GetType() == type.GetType())
+                    return true;
+
+            return false;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        [ContextMenu("Set Default Exclusion Types")]
+        public virtual void SetDefaultExclusionTypes() => exclusionTypes = new()
+        {
+            Create<ShakeObject>(), Create<CGDisplay>(), Create<VideoDisplay>(), Create<FaintAnim>(), Create<CharacterLeave>(),
+            Create<Flashback>()
+        };
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <returns></returns>
+        protected IDialogueEvent Create<T>() where T : IDialogueEvent => (IDialogueEvent)Activator.CreateInstance(typeof(T));
+    }
+}

package/DialogueEventExcluder.cs.meta

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

package/DialogueEventIgnorer.cs

@@ -0,0 +1,45 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using DREditor.Dialogues;
+using DREditor.Dialogues.Events;
+using System.Collections.Generic;
+
+namespace DREditor.DialogueEventManaging
+{
+    /// <summary>
+    ///
+    /// </summary>
+    public abstract class DialogueEventIgnorer : DialogueComponent
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        protected readonly List<IDialogueEvent> ignoredEvents = new();
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="ignoredEvent"></param>
+        protected virtual void AddIgnoredEvent(IDialogueEvent ignoredEvent) => ignoredEvents.Add(ignoredEvent);
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        public virtual void ClearIgnoredEvents() => ignoredEvents.Clear();
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="dialogueEvent"></param>
+        /// <returns></returns>
+        public virtual bool IsIgnoredEvent(IDialogueEvent dialogueEvent)
+        {
+            foreach (IDialogueEvent i in ignoredEvents)
+                if (dialogueEvent == i)
+                    return true;
+
+            return false;
+        }
+    }
+}

package/DialogueEventIgnorer.cs.meta

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

package/DialogueEventManager.cs

@@ -0,0 +1,38 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using DREditor.Dialogues;
+using DREditor.Dialogues.Events;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace DREditor.DialogueEventManaging
+{
+    /// <summary>
+    ///
+    /// </summary>
+    public abstract class DialogueEventManager : DialogueComponent
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="events"></param>
+        protected virtual void TriggerDialogueEvents(IEnumerable<IDialogueEvent> events)
+        {
+            foreach (IDialogueEvent dialogueEvent in events)
+                dialogueEvent.TriggerDialogueEvent();
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="currentLine"></param>
+        protected virtual void TriggerAllDialogueEventsOfType<T>(Line currentLine) where T : IDialogueEvent
+        {
+            var events = currentLine.DiaEvents.Where(dialogueEvent => dialogueEvent.GetType() == typeof(T));
+
+            if (events.Count() > 0)
+                foreach (IDialogueEvent dialogueEvent in events)
+                    dialogueEvent.TriggerDialogueEvent();
+        }
+    }
+}

package/DialogueEventManager.cs.meta

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

package/DialogueEventTypeExcluder.cs

@@ -0,0 +1,27 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using DREditor.Dialogues.Events;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace DREditor.DialogueEventManaging
+{
+    /// <summary>
+    ///
+    /// </summary>
+    public abstract class DialogueEventTypeExcluder : MonoBehaviour
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        [SerializeReference]
+        public List<IDialogueEvent> exclusionTypes = new();
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="dialogueEvent"></param>
+        /// <returns></returns>
+        public abstract bool IsExcludedEvent(IDialogueEvent dialogueEvent);
+    }
+}

package/DialogueEventTypeExcluder.cs.meta

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

package/DialogueLineEventManager.cs

@@ -0,0 +1,120 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using DREditor.Dialogues;
+using DREditor.Dialogues.Events;
+using DREditor.Dialogues.LineReading;
+using DREditor.Dialogues.Loading;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
+
+namespace DREditor.DialogueEventManaging
+{
+    /// <summary>
+    ///
+    /// </summary>
+    [ClassHeader(nameof(FilteredDialogueEventManager) + ", " + nameof(ILineProcessorRoutine) + ", " + nameof(ILoadToLineEvents) +
+        "\n\n")]
+    public class DialogueLineEventManager : FilteredDialogueEventManager, ILineProcessorRoutine, ILoadToLineEvents
+    {
+        /// <inheritdoc/>
+        public virtual bool ShouldProcess(Line currentLine)
+        {
+            bool hasEvents = currentLine.DiaEvents.Count != 0;
+
+            bool hasEventWaiters = LineContainsEventWaiters(currentLine, out _);
+
+            if (hasEvents && !hasEventWaiters)
+                TriggerDialogueLineEvents(currentLine);
+
+            return hasEvents && hasEventWaiters;
+        }
+
+        /// <inheritdoc/>
+        public IEnumerator LineProcessRoutine(Line currentLine) => EvaluateDialogueEvents(currentLine);
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="currentLine"></param>
+        /// <returns></returns>
+        protected virtual IEnumerator EvaluateDialogueEvents(Line currentLine)
+        {
+            if (currentLine.DiaEvents.Count != 0)
+                if (LineContainsEventWaiters(currentLine, out List<IDialogueEvent> list))
+                    yield return SplitTriggeringWaiterEvents(currentLine, list);
+                else
+                    TriggerDialogueLineEvents(currentLine);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="currentLine"></param>
+        /// <param name="dialogueEvents"></param>
+        /// <returns></returns>
+        protected virtual bool LineContainsEventWaiters(Line currentLine, out List<IDialogueEvent> dialogueEvents)
+        {
+            dialogueEvents = currentLine.DiaEvents.Where(dialogueEvent => dialogueEvent is EventWaiter).ToList();
+
+            return dialogueEvents.Count > 0;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="currentLine"></param>
+        /// <param name="dialogueEvents"></param>
+        /// <returns></returns>
+        protected virtual IEnumerator SplitTriggeringWaiterEvents(Line currentLine, List<IDialogueEvent> dialogueEvents)
+        {
+            yield return TriggerEventWaiters(dialogueEvents);
+
+            TriggerNonEventWaiters(currentLine);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="dialogueEvents"></param>
+        /// <returns></returns>
+        protected virtual IEnumerator TriggerEventWaiters(List<IDialogueEvent> dialogueEvents)
+        {
+            foreach (IDialogueEvent dialogueEvent in dialogueEvents)
+            {
+                EventWaiter dialogueEventWaiter = dialogueEvent as EventWaiter;
+
+                dialogueEventWaiter.SetUnfinished();
+
+                dialogueEvent.TriggerDialogueEvent();
+
+                UnityEngine.Debug.Log($"REPORT: {ToString()}: Started waiting for event.");
+
+                yield return new WaitUntil(() => dialogueEventWaiter.done);
+
+                dialogueEventWaiter.SetUnfinished();
+
+                UnityEngine.Debug.Log($"REPORT: {ToString()}: Finished waiting for event.");
+            }
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="currentLine"></param>
+        protected virtual void TriggerNonEventWaiters(Line currentLine)
+        {
+            List<IDialogueEvent> nonEventWaiterDialogueEvents = currentLine.DiaEvents
+                .Where(dialogueEvent => dialogueEvent is not EventWaiter).ToList();
+
+            if (nonEventWaiterDialogueEvents.Count > 0)
+                foreach (IDialogueEvent dialogueEvent in nonEventWaiterDialogueEvents)
+                    dialogueEvent.TriggerDialogueEvent();
+        }
+
+
+        /// <inheritdoc/>
+        public virtual void OnLoadToLineEvents(Line currentLine) => TriggerDialogueLineEvents(currentLine);
+    }
+}

package/DialogueLineEventManager.cs.meta

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

package/DialogueLineSceneEventManager.cs

@@ -0,0 +1,68 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using DREditor.Dialogues;
+using DREditor.Dialogues.LineReading;
+using DREditor.EventObjects;
+using System.Collections;
+using UnityEngine;
+
+namespace DREditor.DialogueEventManaging
+{
+    /// <summary>
+    ///
+    /// </summary>
+    [ClassHeader(nameof(DialogueComponent) + ", " + nameof(ILineProcessorRoutine) +
+        "\n\n")]
+    public class DialogueLineSceneEventManager : DialogueComponent, ILineProcessorRoutine
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected BoolWithEvent eventTrigger = null;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected BoolWithEvent isLoadingFile = null;
+
+
+        /// <inheritdoc/>
+        public virtual bool ShouldProcess(Line currentLine) => currentLine.Events.Count != 0 && !isLoadingFile.Value;
+
+        /// <inheritdoc/>
+        public virtual IEnumerator LineProcessRoutine(Line currentLine) => EvaluateSceneEvents(currentLine);
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="currentLine"></param>
+        /// <returns></returns>
+        protected virtual IEnumerator EvaluateSceneEvents(Line currentLine)
+        {
+            if (currentLine.Events.Count != 0 && !isLoadingFile.Value)
+                foreach (SceneEvent sceneEvent in currentLine.Events.ToArray())
+                    yield return TriggerSceneEvent(sceneEvent);
+
+            yield break;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="sceneEvent"></param>
+        /// <returns></returns>
+        protected virtual IEnumerator TriggerSceneEvent(SceneEvent sceneEvent)
+        {
+            sceneEvent.Raise();
+
+            // Will wait until trigger is true from Event Ending
+            while (!eventTrigger.Value)
+                yield return null;
+
+            eventTrigger.SetValue(false);
+
+            yield break;
+        }
+    }
+}

package/DialogueLineSceneEventManager.cs.meta

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

package/Editor/DREditor.DialogueEventManaging.Editor.asmdef

@@ -0,0 +1,18 @@
+{
+    "name": "DREditor.DialogueEventManaging.Editor",
+    "rootNamespace": "",
+    "references": [
+        "DREditor",
+        "DREditor.Editor",
+        "DREditor.DialogueEventManaging"
+    ],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}

package/Editor/DREditor.DialogueEventManaging.Editor.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 4185b5b1f51ddee4b8936589e292b793
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: