net.dreditor.core 0.1.4 → 0.1.6

package/Scripts/Editor/Dialogues/EndEventEditor.cs

@@ -0,0 +1,128 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For DREditor
+#if UNITY_EDITOR
+using DREditor.Dialogues;
+using DREditor.Editor.Utility;
+using DREditor.Progressing;
+using System;
+using UnityEditor;
+using UnityEngine;
+
+namespace DREditor.Editor.Dialogues
+{
+    [Serializable]
+    public class EndEventEditor<T> where T : Line
+	{
+		protected DialogueBase<T> dia;
+
+        protected int value;
+
+
+        [SerializeField] protected VariableEventEditor<T> VariableEditor;
+
+        [SerializeField] protected TriggerFlagEditor FlagEditor;
+        protected readonly SceneTransitionEditor SceneEditor = new();
+
+
+        public DialogueBase<T> GetDialogue() => dia;
+
+        public virtual void DisplayEndEvents(DialogueBase<T> dia)
+		{
+            this.dia = dia == null ? ScriptableObject.CreateInstance<DialogueBase<T>>() : dia;
+
+            if (VariableEditor == null || FlagEditor == null)
+                Initialize();
+
+            DisplayEvents();
+        }
+
+        protected virtual void Initialize()
+        {
+            DatabaseUtility.InitializeDatabase(null, out ProgressionDatabase progression);
+
+            VariableEditor ??= new(progression);
+
+            FlagEditor ??= new(progression);
+        }
+
+
+        protected virtual void DisplayEvents()
+		{
+            if (VariableEditor.Display(dia.Variable) is Variable<T> variable)
+                dia.SetVariable(variable);
+
+            if (dia.DirectTo.Enabled)
+            {
+                using (new EditorGUILayout.VerticalScope("Box", GUILayout.Width(400)))
+                {
+                    using (new EditorGUILayout.HorizontalScope())
+                    {
+                        GUILayout.Label("Next Dialogue:", GUILayout.Width(90));
+
+                        if (dia.DirectTo.NewDialogue == null)
+                        {
+                            GUI.backgroundColor = Color.cyan;
+                        }
+
+                        dia.DirectTo.SetNewDialogue(
+                            (DialogueBase<T>)EditorGUILayout.ObjectField(dia.DirectTo.NewDialogue, typeof(DialogueBase<T>), false,
+                                GUILayout.Width(180)));
+
+                        GUI.backgroundColor = dia.Color;
+
+                        if (dia.DirectTo.NewDialogue != null)
+                        {
+                            string[] nextDialogueTexts = new string[dia.DirectTo.NewDialogue.Lines.Count];
+
+                            int[] optValues = new int[dia.DirectTo.NewDialogue.Lines.Count];
+
+                            for (int j = 0; j < dia.DirectTo.NewDialogue.Lines.Count; j++)
+                            {
+                                nextDialogueTexts[j] = dia.DirectTo.NewDialogue.Lines[j].Text;
+                                optValues[j] = value;
+                                value++;
+                            }
+
+                            dia.DirectTo.SetNewDialogueIndex(EditorGUILayout.IntPopup(
+                                dia.DirectTo.NewDialogueIndex, nextDialogueTexts, optValues, GUILayout.Width(100)));
+                        }
+
+                    }
+                    value = 0;
+
+                    if (GUILayout.Button("Remove", GUILayout.Width(80)))
+                    {
+                        dia.DirectTo.SetNewDialogue(null);
+
+                        dia.DirectTo.SetEnabled(false);
+                    }
+                }
+            }
+
+            dia.SetSceneTransition(SceneEditor.Display(dia.SceneTransition));
+
+            dia.SetTriggerFlag(FlagEditor.Display(dia.FlagTrigger));
+        }
+
+        public virtual void DisplayEndEventsButtons()
+		{
+            if (dia.LineCount != 0)
+                CustomLayoutUtility.MassHorizontal(DisplayVariableButtons, DisplayButtons);
+        }
+
+		protected virtual void DisplayVariableButtons()
+		{
+            VariableEditor.DisplayAddButton();
+
+            if (!dia.Variable.Enabled && !dia.DirectTo.Enabled && GUILayout.Button("Direct to...", GUILayout.Width(100)))
+                dia.DirectTo.SetEnabled(true);
+        }
+
+        protected virtual void DisplayButtons()
+        {
+            SceneEditor.DisplayAddButton();
+
+            FlagEditor.DisplayAddButton();
+        }
+	}
+}
+#endif

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

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: c40cdee4baa50e14e85497f09f97b416

package/Scripts/Editor/Dialogues/ExpressionPreviewer.cs

@@ -0,0 +1,58 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For DREditor
+#if UNITY_EDITOR
+using DREditor.Characters;
+using DREditor.Editor.Utility;
+using System;
+using UnityEditor;
+using UnityEngine;
+
+namespace DREditor.Editor.Dialogues
+{
+    [Serializable]
+    public class ExpressionPreviewer
+	{
+		[SerializeField] protected Material expressionMaterial;
+		[SerializeField] protected Rect expressionRect;
+        
+        public virtual void SetExpression(Expression expression)
+		{
+			if (expressionMaterial != null || expression == null || expression.Sprite == null)
+                return;
+
+            expressionRect = GUILayoutUtility.GetLastRect();
+
+            if (expressionRect.Contains(Event.current.mousePosition))
+                expressionMaterial = expression.Sprite;
+        }
+
+        public virtual void DrawHoveredSprite()
+        {
+			if (expressionMaterial == null || !expressionRect.Contains(Event.current.mousePosition))
+            {
+                expressionMaterial = null;
+
+                return;
+            }
+
+            GUI.backgroundColor = Color.white;
+            
+            GUI.color = Color.white;
+
+            GUIStyle exprstyle = new();
+
+            var expressionTexture = HandyFields.GetMaterialTexture(expressionMaterial);
+
+            exprstyle.normal.background = expressionTexture;
+
+            if (exprstyle != null)
+                EditorGUI.LabelField(
+                    new Rect(
+						Event.current.mousePosition.x,
+						Event.current.mousePosition.y,
+						expressionTexture.width / 5,
+						expressionTexture.height / 5),
+                    GUIContent.none, exprstyle);
+        }
+    }
+}
+#endif

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

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 21ba7a9ca9bf2334ca59a5d4d9184b7a

package/Scripts/Editor/Dialogues/LineButtonEditor.cs

@@ -0,0 +1,161 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For DREditor
+#if UNITY_EDITOR
+using DREditor.Dialogues;
+using DREditor.Dialogues.Events;
+using DREditor.Editor.Utility;
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+
+namespace DREditor.Editor.Dialogues
+{
+    public class LineButtonEditor<T> where T : Line, new()
+    {
+        SerializedObject serializedObject; 
+
+        int i; 
+
+        List<T> Lines;
+
+        public virtual void Display(SerializedObject serializedObject, int i, List<T> Lines)
+        {
+            Initialize(serializedObject, i, Lines);
+
+            Display();
+
+            Resolve();
+        }
+
+        protected virtual void Initialize(SerializedObject serializedObject, int i, List<T> Lines)
+        {
+            this.serializedObject = serializedObject;
+
+            this.i = i;
+
+            this.Lines = Lines;
+        }
+
+        protected virtual void Resolve()
+        {
+            serializedObject = null;
+
+            Lines = null;
+        }
+
+        protected virtual void Display() =>
+            CustomLayoutUtility.DisplayScoped(
+                new EditorGUILayout.VerticalScope(GUILayout.MaxWidth(25)),
+                RemoveLine,
+                MoveLine,
+                DuplicateButton,
+                AddLine);
+
+
+        protected virtual void RemoveLine()
+        {
+            if (Lines.Count > 1 && GUILayout.Button(new GUIContent("-", "Delete this Line."), GUILayout.Width(20)))
+            {
+                GUI.FocusControl(null);
+                Lines.Remove(Lines[i]);
+                serializedObject.ApplyModifiedProperties();
+                serializedObject.Update();
+            }
+        }
+
+        protected virtual void MoveLine()
+        {
+            if (i > 0)
+            {
+                if (GUILayout.Button(new GUIContent("ʌ", "Move this line up."), GUILayout.Width(20)))
+                {
+                    GUI.FocusControl(null);
+                    Lines.Swap(i, i - 1);
+                }
+            }
+            else
+                GUILayout.Space(20f);
+
+            if (i < Lines.Count - 1)
+            {
+                if (GUILayout.Button(new GUIContent("v", "Move this line down."), GUILayout.Width(20)))
+                {
+                    GUI.FocusControl(null);
+                    Lines.Swap(i, i + 1);
+                }
+            }
+            else
+                GUILayout.Space(20f);
+
+            GUILayout.Space(25f);
+
+            GUILayout.FlexibleSpace();
+        }
+
+        protected virtual void DuplicateButton()
+        {
+            if (GUILayout.Button(new GUIContent("*", "Duplicate this Line below."), GUILayout.Width(20)))
+            {
+                T Copy = new()
+                {
+                    TranslationKey = Lines[i].TranslationKey,
+                    VoiceSFX = Lines[i].VoiceSFX,
+                    TimeToNextLine = Lines[i].TimeToNextLine,
+                    AutomaticLine = Lines[i].AutomaticLine,
+                };
+
+                foreach (var audio in Lines[i].SFXs)
+                    Copy.SFXs.Add(audio);
+
+                foreach (var sceneEvents in Lines[i].Events)
+                    Copy.Events.Add(sceneEvents);
+
+                Copy.SetSpeaker(Lines[i].Speaker);
+
+                Copy.SetSpeakerNum(Lines[i].SpeakerNumber);
+
+                Copy.SetExpression(Lines[i].Expression);
+
+                Copy.SetExpressionNum(Lines[i].ExpressionNumber);
+
+                Copy.SetText(Lines[i].Text);
+
+                Copy.SetAliasNumber(Lines[i].AliasNumber);
+
+                Copy.SetDiaEvents(new List<IDialogueEvent>());
+
+                foreach (IDialogueEvent ev in Lines[i].DiaEvents)
+                    Copy.DiaEvents.Add(ev);
+
+                Lines.Insert(i + 1, Copy);
+
+                serializedObject.Update();
+            }
+        }
+
+        protected virtual void AddLine()
+        {
+            if (GUILayout.Button(new GUIContent("+", "Add a new Line below."), GUILayout.Width(20)))
+            {
+                Lines.Insert(i + 1, InsertNewLine());
+
+                serializedObject.Update();
+            }
+
+            GUILayout.FlexibleSpace();
+        }
+
+        protected virtual T InsertNewLine()
+        {
+            T _neoLine = new();
+
+            _neoLine.SetSpeaker(null);
+
+            _neoLine.SetSpeakerNum(-1);
+
+            _neoLine.SetDiaEvents(new List<IDialogueEvent>());
+
+            return _neoLine;
+        }
+    }
+}
+#endif

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

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 450fd10e9253f7c43b64550a69b4ea7a

package/Scripts/Editor/Dialogues/LineCharacterColumnEditor.cs

@@ -0,0 +1,173 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For DREditor
+#if UNITY_EDITOR
+using DREditor.Dialogues;
+using DREditor.EventObjects;
+using DREditor.Editor.Utility;
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+
+namespace DREditor.Editor.Dialogues
+{
+    public class LineCharacterColumnEditor<T> where T : Line, new()
+    {
+        DialogueCore dia;
+
+        int i;
+
+        List<T> Lines;
+
+        public virtual void Display(SerializedObject serializedObject, int i, List<T> Lines)
+        {
+            Initialize(serializedObject, i, Lines);
+
+            Display();
+
+            Resolve();
+        }
+
+        protected virtual void Initialize(SerializedObject serializedObject, int i, List<T> Lines)
+        {
+            this.i = i;
+
+            this.Lines = Lines;
+
+            dia = serializedObject.targetObject as DialogueCore;
+        }
+
+        protected virtual void Resolve()
+        {
+            dia = null;
+
+            Lines = null;
+        }
+
+        protected virtual void Display()
+        {
+            CustomLayoutUtility.DisplayScoped(new EditorGUILayout.VerticalScope(GUILayout.MaxWidth(130)),
+                DisplayCharacter,
+                DisplayAlias,
+                DisplaySceneEvents,
+                DisplayOptions);
+        }
+
+        protected virtual void DisplayCharacter()
+        {
+            var prependedArray = ContainerUtil.PrependedList(dia.GetCharacterNames(), "<No Character>");
+
+            Lines[i].SetSpeakerNum(EditorGUILayout.IntPopup(Lines[i].SpeakerNumber, prependedArray,
+                ContainerUtil.Iota(prependedArray.Length, -1), GUILayout.MaxWidth(130)));
+
+            Lines[i].SetSpeaker(Lines[i].SpeakerNumber == -1 ? null : dia.Speakers.Characters[Lines[i].SpeakerNumber]);
+
+            if (Lines[i].SpeakerNumber == -1)
+            {
+                Lines[i].SetSpeaker(null);
+                Lines[i].VoiceSFX = null;
+                Lines[i].SetExpression(null);
+                Lines[i].SetExpressionNum(0);
+                Lines[i].SetAliasNumber(0);
+            }
+            else
+                Lines[i].SetSpeaker(dia.Speakers.Characters[Lines[i].SpeakerNumber]);
+        }
+
+        protected virtual void DisplayAlias()
+        {
+            if (Lines[i].Speaker == null || Lines[i].Speaker.Aliases.Count == 0)
+                return;
+
+            var aliasNames = new string[Lines[i].Speaker.Aliases.Count + 1];
+
+            aliasNames[0] = "(No Alias)";
+
+            for (int j = 1; j < Lines[i].Speaker.Aliases.Count + 1; j++)
+                aliasNames[j] = Lines[i].Speaker.Aliases[j - 1].Name;
+
+            Lines[i].SetAliasNumber(EditorGUILayout.IntPopup(Lines[i].AliasNumber,
+                aliasNames, dia.GetIntValues(Lines[i].Speaker.Aliases.Count + 1),
+                    GUILayout.MaxWidth(130)));
+        }
+
+        protected virtual void DisplaySceneEvents()
+        {
+            if (Lines[i].Events != null)
+            {
+                for (var j = 0; j < Lines[i].Events.Count; j++)
+                {
+                    using (new EditorGUILayout.HorizontalScope())
+                    {
+                        Lines[i].Events[j] = (SceneEvent)EditorGUILayout.ObjectField(
+                            Lines[i].Events[j], typeof(SceneEvent), false, GUILayout.Width(100));
+
+                        if (HandyFields.SkinnyButton("x", GUILayout.Width(20)))
+                            Lines[i].Events.Remove(Lines[i].Events[j]);
+                    }
+                }
+            }
+
+            if (HandyFields.Button("Add Scene Event"))
+                Lines[i].Events.Add(ScriptableObject.CreateInstance<SceneEvent>());
+        }
+
+
+
+        protected virtual void ToggleOptionsButton() =>
+            Lines[i].ShowOptions = HandyFields.Button("Toggle Options") ? !Lines[i].ShowOptions : Lines[i].ShowOptions;
+
+        protected virtual void DisplayOptions() =>
+            CustomLayoutUtility.MassHorizontal(
+                    ToggleOptionsButton,
+                    DontPanOption,
+                    PanToCharacterOption,
+                    PanToCharacterDropdown,
+                    DisplayAutoOption);
+
+        protected virtual void DontPanOption()
+        {
+            if (!Lines[i].ShowOptions && !Lines[i].DontPan)
+                return;
+
+            Lines[i].DontPan = HandyFields.Option(Lines[i].DontPan, "Don't Pan: ");
+        }
+
+        protected virtual void PanToCharacterOption()
+        {
+            if (!Lines[i].ShowOptions && !Lines[i].PanToChar)
+                return;
+
+            Lines[i].PanToChar = HandyFields.Option(Lines[i].PanToChar, "Pan To Character: ");
+        }
+
+        protected virtual void PanToCharacterDropdown()
+        {
+            if (!Lines[i].PanToChar)
+                return;
+
+            var prependedArray = ContainerUtil.PrependedList(dia.GetCharacterNames(), "<No Character>");
+
+            Lines[i].CharToPanNum = EditorGUILayout.IntPopup(Lines[i].CharToPanNum, prependedArray,
+                ContainerUtil.Iota(prependedArray.Length, -1), GUILayout.Width(130));
+
+            Lines[i].CharToPan = Lines[i].CharToPanNum == -1 ? null : dia.Speakers.Characters[Lines[i].CharToPanNum];
+        }
+
+        protected virtual void DisplayAutoOption()
+        {
+            if (!Lines[i].ShowOptions && !Lines[i].AutomaticLine)
+                return;
+
+            HandyFields.Label("Auto:");
+
+            Lines[i].AutomaticLine = EditorGUILayout.Toggle(Lines[i].AutomaticLine, GUILayout.Width(15));
+
+            if (Lines[i].AutomaticLine)
+            {
+                Lines[i].TimeToNextLine = EditorGUILayout.FloatField(Lines[i].TimeToNextLine, GUILayout.Width(24));
+
+                EditorGUILayout.LabelField("sec", GUILayout.Width(22));
+            }
+        }
+    }
+}
+#endif

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

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 427939503d778f54f96347005288eec5

package/Scripts/Editor/Dialogues/LineEditor.cs

@@ -0,0 +1,147 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For DREditor
+#if UNITY_EDITOR
+using DREditor.Characters;
+using DREditor.Dialogues;
+using DREditor.Editor.Utility;
+using System;
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+
+namespace DREditor.Editor.Dialogues
+{
+    [Serializable]
+    public class LineEditor<T> : LineEditorBase where T : Line, new()
+    {
+        
+
+        protected SerializedObject serializedObject;
+
+        protected SerializedProperty propLines;
+
+        protected UnityEditor.Editor parentEditor;
+
+        protected readonly LineCharacterColumnEditor<T> characterColumnEditor = new();
+
+        protected readonly LineExpressionColumnEditor<T> expressionColumnEditor = new();
+
+        protected readonly LineTextColumnEditor<T> textColumnEditor = new();
+
+
+        protected readonly LineButtonEditor<T> buttonEditor = new();
+        protected readonly LineLowerEditor<T> lineLowerEditor = new();
+
+
+        protected List<T> Lines;
+
+        protected DialogueCore dia;
+
+
+        
+
+        public virtual void Initialize(DialogueCore dia, SerializedObject serializedObject = null, UnityEditor.Editor parentEditor = null,
+            SerializedProperty linesProperty = null, List<T> lines = null)
+        {
+            this.dia = dia;
+
+            this.serializedObject = serializedObject;
+
+            this.parentEditor = parentEditor;
+
+            Lines = lines ?? dia.GetLines<T>();
+
+            propLines = serializedObject != null ? linesProperty ?? serializedObject.FindProperty("lines") : null;
+        }
+
+        public override void DrawHoverSprite() => expressionColumnEditor.DrawHoveredSprite();
+
+        protected override void DisplayDialogueLine()
+        {
+            CustomLayoutUtility.DisplayScoped(new EditorGUILayout.HorizontalScope("Box"),
+                DisplayColoredLine);
+
+            ResolveColoredLine();
+        }
+
+
+        protected virtual void DisplayColoredLine() => CustomLayoutUtility.DisplayVertical(SetLineBGColor, DisplayLine);
+
+        protected override void DisplayLineNumberSplitter() => HandySplitters.LineNumSplitter(dia.Color, 1, 125);
+
+        protected virtual void ResolveColoredLine()
+        {
+            GUI.color = Color.white;
+
+            HandySplitters.UISplitterCustom(dia.Color);
+        }
+
+        protected virtual void SetLineBGColor()
+        {
+            if (Lines[i].Speaker is not Student student)
+                return;
+
+            GUI.backgroundColor = Color.white;
+
+            Color.RGBToHSV(student.StudentCard.Color, out float H, out float S, out float _);
+
+            Color color = Color.HSVToRGB(H, Mathf.Min(S, 0.35f), 1f);
+
+            GUI.color = color;
+        }
+
+
+        protected virtual void DisplayLine()
+        {
+            CustomLayoutUtility.DisplayScoped(
+                new EditorGUILayout.HorizontalScope(GUILayout.MaxWidth(EditorGUIUtility.currentViewWidth)),
+                DisplayCharacterPanel,
+                DisplayExpressionPanel,
+                DisplayDialoguePanel,
+                DisplayLinePositionPanel);
+
+            GUILayout.Space(5f);
+
+            DisplayLowerLine();
+        }
+
+        //Column 1
+        protected virtual void DisplayCharacterPanel() =>
+            CustomLayoutUtility.DisplayScoped(new EditorGUILayout.VerticalScope(GUILayout.MaxWidth(130)),
+                DisplayLineNumberBar,
+                DisplayCharacterColumn);
+
+        protected override void OnTestButtonPressed()
+        {
+            if (Application.isPlaying)
+                DialogueCore.InvokeDebugLine(dia, Lines[i]);
+            else
+                EditorUtility.DisplayDialog("Must be in Play Mode", "You must be in play mode to test lines!", "Ok");
+        }
+
+
+
+
+        protected virtual void DisplayCharacterColumn() => characterColumnEditor.Display(serializedObject, i, Lines);
+
+
+        protected virtual void DisplayExpressionPanel() => DisplayExpressionColumn();
+
+        protected virtual void DisplayExpressionColumn() => expressionColumnEditor.Display(serializedObject, i, Lines);
+
+        protected virtual void DisplayDialoguePanel()
+        {
+            if (!SkipDisplayingText())
+                DisplayTextColumn();
+        }
+
+        protected virtual bool SkipDisplayingText() => i >= propLines.arraySize;
+
+        protected virtual void DisplayTextColumn() => textColumnEditor.Display(propLines, i, Lines);
+
+        protected virtual void DisplayLinePositionPanel() => buttonEditor.Display(serializedObject, i, Lines);
+
+
+        protected virtual void DisplayLowerLine() => lineLowerEditor.Display(propLines, i, Lines, parentEditor);
+    }
+}
+#endif

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

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: ceba361231f3ef94db3c224fee37185c