net.dreditor.core 0.1.5 → 0.1.6

package/Scripts/Editor/Dialogues/DialogueEditor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 50612143988784b4d8e22fb72b7764cb
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences:
+  - BaseExpression: {fileID: 2800000, guid: c413052461bb89947b0d8d9d138d03e0, type: 3}
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Scripts/Editor/Dialogues/DialogueEditorBase.cs

@@ -0,0 +1,183 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+#if UNITY_EDITOR
+using DREditor.Characters;
+using DREditor.Dialogues;
+using DREditor.Editor.Utility;
+using UnityEditor;
+using UnityEngine;
+
+namespace DREditor.Editor.Dialogues
+{
+    public abstract class DialogueEditorBase<T> : UnityEditor.Editor where T : new()//where T : Line, new()
+    {
+        protected bool editNameFoldout = false;
+
+        protected bool debugMode;
+
+        protected DialogueBase<T> dia;
+
+        protected abstract LineEditorBase LineEditor { get; }
+
+        protected abstract DialogueDebugToolEditorBase DebugTool { get; }
+
+        protected virtual void SetDialogue(DialogueBase<T> dia) => this.dia = dia;
+
+        public override void OnInspectorGUI()
+        {
+            serializedObject.Update();
+
+            CreateForm();
+
+            EditorUtility.SetDirty(dia);
+
+            serializedObject.ApplyModifiedProperties();
+        }
+
+        protected virtual void CreateForm()
+        {
+            if (!DatabasesAreValid() || DisplayDebugTool())
+                return;
+
+            DisplayDialogueOptions();
+
+            SetWordWrappingColor();
+
+            EditPanels();
+
+            EditFooter();
+        }
+
+        protected virtual bool DatabasesAreValid()
+        {
+            if (DatabaseUtility.InitializeDatabase(dia.Speakers, out CharacterDatabase speakers) && speakers.IsValid())
+                dia.SetSpeakers(speakers);
+            else
+                return false;
+
+            return true;
+        }
+
+        protected virtual bool DisplayDebugTool()
+        {
+            using (new EditorGUILayout.HorizontalScope())
+            {
+                debugMode = HandyFields.Option(debugMode, "Debug Mode: ", 80);
+
+                EditorGUILayout.LabelField(dia.DialogueName, EditorStyles.boldLabel);
+
+                dia.SetColor(EditorGUILayout.ColorField(dia.Color, GUILayout.Width(50)));
+            }
+
+            if (debugMode)
+            {
+                GUI.enabled = false;
+
+                EditDialogueNameFoldout();
+
+                GUI.enabled = true;
+            }
+
+            if (debugMode && DebugTool.DebugMode(dia))
+                debugMode = false;
+
+            return debugMode;
+        }
+
+        protected virtual void SetWordWrappingColor()
+        {
+            EditorStyles.textArea.wordWrap = true;
+
+            EditorStyles.textField.wordWrap = true;
+
+            GUI.backgroundColor = dia.Color;
+        }
+
+
+        protected virtual void EditDialogueNameFoldout()
+        {
+            editNameFoldout = EditorGUILayout.BeginFoldoutHeaderGroup(editNameFoldout, "Edit DialogueName");
+
+            if (editNameFoldout)
+                EditDialogueName();
+
+            EditorGUILayout.EndFoldoutHeaderGroup();
+        }
+        protected virtual void EditDialogueName()
+        {
+
+            using (new EditorGUILayout.VerticalScope("Box"))
+            {
+                using (new EditorGUILayout.HorizontalScope())
+                {
+                    if (dia.DialogueName == "")
+                        dia.SetName(target.name);
+
+                    dia.SetName(EditorGUILayout.DelayedTextField("Dialogue Code: ", dia.DialogueName));
+
+                    if (GUILayout.Button("Update", GUILayout.Width(80)))
+                    {
+                        var path = AssetDatabase.GetAssetPath(dia);
+                        var flds = path.Split('/');
+                        var nm = flds[^2];
+
+                        string tx = "";
+                        if (dia.Lines.Count > 0)
+                        {
+                            tx = dia.GetLine(0).Text[..(dia.GetLine(0).Text.Length > 29 ? 30 : dia.GetLine(0).Text.Length)];
+                            tx = tx.Replace('?', ' ');
+                        }
+
+                        string fileName = nm + "_" + dia.DialogueName + "_" + tx;
+
+                        AssetDatabase.RenameAsset(AssetDatabase.GetAssetPath(dia), fileName);
+                        UnityEngine.Debug.Log(fileName);
+                        UnityEngine.Debug.Log(AssetDatabase.GetAssetPath(dia));
+                    }
+                }
+
+                GUI.backgroundColor = Color.white;
+            }
+        }
+
+        protected virtual void DisplayDialogueOptions()
+        {
+            if (dia is IInstantAbleDialogue instantableDialogue)
+                using (new EditorGUILayout.HorizontalScope())
+                    instantableDialogue.SetInstant(HandyFields.Option(instantableDialogue.GetInstant(), "Is Instant: ", 60));
+        }
+
+        protected virtual void EditPanels()
+        {
+            LineEditor.EditTestLine(dia.LineCount);
+
+            if (dia.Lines == null)
+                return;
+
+            if (LineEditor.TestLine != -1)
+                EditLine(LineEditor.TestLine);
+            else
+                for (int i = 0; i < dia.LineCount; i++)
+                    EditLine(i);
+        }
+
+        protected virtual void EditLine(int i) => LineEditor.EditLine(i);
+
+        protected virtual void EditFooter()
+        {
+            if (LineEditor.TestLine == -1)
+                DisplayFooter();
+
+            LineEditor.DrawHoverSprite();
+        }
+
+        protected virtual void DisplayFooter() => NewLineButton();
+
+        protected virtual void NewLineButton()
+        {
+            using (new EditorGUILayout.HorizontalScope())
+                if (GUILayout.Button("New " + ObjectNames.NicifyVariableName(typeof(T).Name), GUILayout.Width(100)))
+                    dia.Lines.Add(new T());
+        }
+    }
+}
+#endif

package/Scripts/Editor/Dialogues/DialogueEditorBase.cs.meta

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

package/Scripts/Editor/Dialogues/DialogueEditorTextPreviewer.cs

@@ -0,0 +1,49 @@
+//Author: Happy30
+#if UNITY_EDITOR
+using System.Linq;
+using System.Text.RegularExpressions;
+using UnityEditor;
+using UnityEngine;
+
+namespace DREditor.Editor.Dialogues
+{
+    /// <summary>
+    ///
+    /// </summary>
+    public static class DialogueEditorTextPreviewer
+	{
+        public static void TextPreview(string text, float width = 100, float height = 100)
+        {
+            GUIStyle style = new(GUI.skin.label)
+            {
+                richText = true,
+                wordWrap = true
+            };
+
+            if (text.Contains("$"))
+                text = $"{text}</color>";
+
+            int c = text.Count(x => x == '@');
+
+            var regex = new Regex(Regex.Escape("@"));
+
+            for (int i = 0; i < c; i++)
+            {
+                if (i % 2 == 0)
+                    text = regex.Replace(text, "<color=yellow>", 1);
+                else
+                    text = regex.Replace(text, "</color>", 1);
+            }
+
+            text = Regex.Replace(text, "\\$", "<color=cyan>");
+
+            if (text == "")
+                text = "<size=\"10\"><color=magenta>ANALYSIS: This line has no text. " +
+                    "This will be skipped, and only the Dialogue Events in this line will be invoked." +
+                    "You can ignore this if this is intended.</color></size>";
+
+            EditorGUILayout.LabelField(new GUIContent(text, "Text Preview with formatting"), style, GUILayout.Height(height));
+        }
+    }
+}
+#endif

package/Scripts/Editor/Dialogues/DialogueEditorTextPreviewer.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 19b5f92335a0cfe47842e0cb78f667b2

package/Scripts/Editor/Dialogues/DialogueEndEventEditor.cs

@@ -0,0 +1,171 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For DREditor
+#if UNITY_EDITOR
+using DREditor.Dialogues;
+using DREditor.Editor.Utility;
+using System;
+using UnityEditor;
+using UnityEngine;
+
+namespace DREditor.Editor.Dialogues
+{
+    [Serializable]
+    public class DialogueEndEventEditor : EndEventEditor<Line>
+    {
+        protected Dialogue dialogue;
+
+        protected readonly CustomCallEndEventEditor CustomCallEditor = new();
+
+        public DialogueEndEventEditor() : base() { }
+
+        public override void DisplayEndEvents(DialogueBase<Line> dia)
+        {
+            if (dia is Dialogue dialogueType)
+                dialogue = dialogueType;
+
+            base.DisplayEndEvents(dia);
+        }
+
+        protected override void DisplayEvents()
+        {
+            DisplayChoices();
+
+            dialogue.SetEndEvent(CustomCallEditor.Display(dialogue.EndEvent));
+
+            DisplayInvestigation();
+
+            base.DisplayEvents();
+        }
+
+        protected virtual void DisplayChoices()
+        {
+            if (dialogue.Choices == null)
+                return;
+
+            for (int i = 0; i < dialogue.Choices.Count; i++)
+            {
+                GUILayout.Label("Choice " + (i + 1).ToString(), GUILayout.Width(80));
+
+                using (new EditorGUILayout.HorizontalScope("Box"))
+                    DisplayMainChoice(dialogue.Choices[i]);
+
+                DisplayLowerChoice(dialogue.Choices[i]);
+            }
+
+            GUI.backgroundColor = dialogue.Color;
+
+            if (dialogue.Choices.Count > 0 && GUILayout.Button("Remove Choices", GUILayout.Width(130)))
+                dialogue.Choices.Clear();
+        }
+
+        protected virtual void DisplayMainChoice(Choice choice)
+        {
+            choice.ChoiceText = EditorGUILayout.TextField(
+                choice.ChoiceText, GUILayout.Width(Screen.width - 343));
+
+            if (choice.NextDialogue == null)
+                GUI.backgroundColor = Color.cyan;
+
+            choice.NextDialogue =
+                (Dialogue)EditorGUILayout.ObjectField(choice.NextDialogue, typeof(Dialogue), true,
+                    GUILayout.Width(100));
+
+            GUI.backgroundColor = dialogue.Color;
+
+            if (choice.NextDialogue != null)
+            {
+                string[] nextDialogueTexts = new string[choice.NextDialogue.Lines.Count];
+
+                int[] optValues = new int[choice.NextDialogue.Lines.Count];
+
+                for (int j = 0; j < choice.NextDialogue.Lines.Count; j++)
+                {
+                    nextDialogueTexts[j] = choice.NextDialogue.Lines[j].Text;
+
+                    optValues[j] = value;
+
+                    value++;
+                }
+
+                value = 0;
+
+                GUI.backgroundColor = Color.white;
+
+                GUI.backgroundColor = choice.NextDialogue.Color;
+
+                choice.NextIndexInDialogue = EditorGUILayout.IntPopup(
+                    choice.NextIndexInDialogue, nextDialogueTexts, optValues, GUILayout.Width(100));
+            }
+        }
+
+        protected virtual void DisplayLowerChoice(Choice choice)
+        {
+            choice.CustomCall = HandyFields.StringField("Custom Call: ", choice.CustomCall);
+
+            using (new EditorGUILayout.HorizontalScope("Box"))
+                choice.CallBreak = HandyFields.Option(choice.CallBreak, "Call Break: ", 70);
+
+            GUILayout.Space(5);
+
+            EditorGUILayout.LabelField("===========================");
+
+            GUILayout.Space(5);
+        }
+
+        protected virtual void DisplayInvestigation()
+        {
+            if (dialogue.StartInvestigation.Enabled)
+            {
+                using (new EditorGUILayout.VerticalScope("Box", GUILayout.Width(400)))
+                {
+                    using (new EditorGUILayout.HorizontalScope())
+                    {
+                        dialogue.StartInvestigation.NextObjective =
+                            HandyFields.Option(dialogue.StartInvestigation.NextObjective, "Next Objective: ", 100);
+
+                        dialogue.StartInvestigation.NewDialogue =
+                            HandyFields.UnityField(dialogue.StartInvestigation.NewDialogue, 120, 30);
+
+                        dialogue.StartInvestigation.ID =
+                            HandyFields.IntField("ID: ", dialogue.StartInvestigation.ID, 100);
+                    }
+
+                    if (GUILayout.Button("Remove", GUILayout.Width(80)))
+                    {
+                        dialogue.StartInvestigation.NextObjective = false;
+                        dialogue.StartInvestigation.SetEnabled(false);
+                        dialogue.StartInvestigation.NewDialogue = null;
+                    }
+                }
+            }
+        }
+
+        protected override void DisplayButtons()
+        {
+            if (dialogue.Choices.Count != 0)
+                return;
+
+            base.DisplayButtons();
+
+            if (!dialogue.StartInvestigation.Enabled && GUILayout.Button("End Event", GUILayout.Width(100)))
+                dialogue.StartInvestigation.SetEnabled(true);
+        }
+
+        protected override void DisplayVariableButtons()
+        {
+            if (dialogue.Choices.Count == 0)
+            {
+                base.DisplayVariableButtons();
+
+                CustomCallEditor.DisplayAddButton();
+
+                if (GUILayout.Button("Add Choice", GUILayout.Width(100)))
+                {
+                    dialogue.Choices.Add(new Choice());
+                    dialogue.Choices.Add(new Choice());
+                    dialogue.Choices.Add(new Choice());
+                }
+            }
+        }
+    }
+}
+#endif

package/Scripts/Editor/Dialogues/DialogueEndEventEditor.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 5c157469e8c1d244d9633b7e80b2bbaf

package/Scripts/Editor/Dialogues/DialogueEventEditor.cs

@@ -0,0 +1,54 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For DREditor
+using DREditor.Dialogues.Events;
+using DREditor.Editor.Utility;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace DREditor.Editor.Dialogues
+{
+    /// <summary>
+    ///
+    /// </summary>
+    public class DialogueEventEditor : InterfaceEditor<IDialogueEvent>
+    {
+        public DialogueEventEditor() : base() { }
+
+        public DialogueEventEditor(UnityEditor.Editor parentEditor, List<IDialogueEvent> diaEvents,
+            bool showDiaEvents, int currentlyPickedIndex = -1) : 
+            base(parentEditor, diaEvents, showDiaEvents, currentlyPickedIndex) { }
+
+        protected override void DisplayValidInterfaceInstance()
+        {
+            base.DisplayValidInterfaceInstance();
+
+            if (instances[currentlyDisplayedEventIndex] is IDisplayableDialogueEvent dialogueEvent)
+            {
+                dialogueEvent?.EditorUI(GetPastProperty());
+
+                GUILayout.Space(5);
+
+                dialogueEvent?.ShowHelpBox();
+            }
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <returns></returns>
+        protected virtual object GetPastProperty() => eventListProperty == null ?
+                instances[currentlyDisplayedEventIndex] :
+                eventListProperty.GetArrayElementAtIndex(currentlyDisplayedEventIndex);
+
+        protected override bool HasCustomEditorProcess() => instances[currentlyDisplayedEventIndex] is IDisplayableDialogueEvent;
+
+        protected override bool RemoveInterfaceInstanceButton()
+        {
+            bool result = base.RemoveInterfaceInstanceButton();
+
+            if (!result && instances[currentlyDisplayedEventIndex] is IDisplayableDialogueEvent dialogueEvent && HandyFields.Button("?", "Show Help"))
+                dialogueEvent.ToggleHelpBox();
+
+            return result;
+        }
+    }
+}

package/Scripts/Editor/Dialogues/DialogueEventEditor.cs.meta

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

package/Scripts/Editor/Dialogues/DialogueEventsEditorUtility.cs

@@ -0,0 +1,137 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For DREditor.
+#if UNITY_EDITOR
+using DREditor.Dialogues;
+using DREditor.Dialogues.Events;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using UnityEditor;
+
+namespace DREditor.Editor.Dialogues
+{
+    /// <summary>
+    ///
+    /// </summary>
+    public static class DialogueEventsEditorUtility
+    {
+        private static readonly List<string> AllCustomEventNames = GetAllCustomEventNames();
+
+        [MenuItem("DREditor/Utility/Verify/Custom Events", false, 4)]
+        public static void Verify()
+        {
+            UnityEngine.Debug.Log("Verifying Custom Events....");
+
+            AssetDatabase.StartAssetEditing();
+
+            string report = "No issues found verifying Custom Events";
+
+            var assets = FindAssetsByType<Dialogue>();
+
+            try
+            {
+                for (int i = 0; i < assets.Count; i++)
+                    VerifyDialogueCustomEvents(assets[i], ref report);
+            }
+            catch (Exception exception)
+            {
+                report = "ALERT: There was an issue verifying the custom events, contact the developer for support.";
+
+                UnityEngine.Debug.LogException(exception);
+            }
+            finally
+            {
+                UnityEngine.Debug.LogWarning("VERIFICATION REPORT: \n" + report);
+
+                AssetDatabase.SaveAssets();
+
+                AssetDatabase.Refresh();
+
+                AssetDatabase.StopAssetEditing();
+            }
+        }
+
+        static void VerifyDialogueCustomEvents(Dialogue dia, ref string report)
+        {
+            for (int i = 0; i < dia.Lines.Count; i++)
+            {
+                Line currentLine = dia.Lines[i];
+
+                var dialogueEvent = currentLine.DiaEvents.Where(IsCustomEvent);
+
+                foreach (CustomEvent ev in dialogueEvent.Cast<CustomEvent>())
+                {
+                    bool valid = ev.toggleCustom && ev.index < AllCustomEventNames.Count;
+
+                    if (valid &&
+                        AllCustomEventNames[ev.index] != ev.EventName &&
+                        AllCustomEventNames.IndexOf(ev.EventName) is int num &&
+                        num != -1)
+                    {
+                        report += AppendLog("Changed Index", dia, i);
+
+                        ev.ReplaceList(AllCustomEventNames);
+
+                        ev.SetIndex(num);
+
+                        EditorUtility.SetDirty(dia);
+                    }
+                    else if (ev.toggleCustom && ev.index >= AllCustomEventNames.Count)
+                        report += AppendLog("Invalid Index", dia, i);
+                    else if (valid && AllCustomEventNames[ev.index] != ev.EventName)
+                        report += AppendLog("Suspected Renaming of: " + ev.EventName + " " + ev.index, dia, i);
+                }
+            }
+        }
+
+        static bool IsCustomEvent(IDialogueEvent dialogueEvent) => 
+            dialogueEvent != null && dialogueEvent.GetType() == typeof(CustomEvent);
+
+        public static string AppendLog(string report, Dialogue dia, int lineNum) =>
+            report + " On: " + dia.name + " Line: " + lineNum + "\n";
+
+        public static List<T> FindAssetsByType<T>() where T : UnityEngine.Object
+        {
+            List<T> assets = new();
+            string[] guids = AssetDatabase.FindAssets(string.Format("t:{0}", typeof(T)));
+            for (int i = 0; i < guids.Length; i++)
+            {
+                string assetPath = AssetDatabase.GUIDToAssetPath(guids[i]);
+                T asset = AssetDatabase.LoadAssetAtPath<T>(assetPath);
+                if (asset != null)
+                {
+                    assets.Add(asset);
+                }
+            }
+            return assets;
+        }
+
+        static List<string> GetAllCustomEventNames()
+        {
+            List<string> list = new();
+
+            LookForAttribute<CustomDialogueEventAttribute>((attribute) =>
+            {
+                list.Add(attribute.eventName);
+
+                return false;
+            });
+
+            return list;
+        }
+
+        static void LookForAttribute<T>(Func<T, bool> check) where T : Attribute
+        {
+            Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
+
+            foreach (Assembly assembly in assemblies)
+                foreach (Type type in assembly.GetTypes())
+                    if (type.GetCustomAttributes(typeof(T)) is IEnumerable<T> attributes &&
+                        attributes.Count() > 0)
+                        foreach (T attribute in attributes)
+                            if (attribute is T customAttribute && check(customAttribute))
+                                return;
+        }
+    }
+}
+#endif

package/Scripts/Editor/Dialogues/DialogueEventsEditorUtility.cs.meta

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