net.dreditor.core 0.1.5 → 0.1.6

package/Scripts/Editor/Utility/DialogueSplitter.cs

@@ -0,0 +1,137 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+#if UNITY_EDITOR
+using DREditor.Dialogues;
+using System;
+using System.Reflection;
+using UnityEditor;
+using UnityEngine;
+
+namespace DREditor.Editor.Utility
+{
+    /// <summary>
+    ///
+    /// </summary>
+    public class DialogueSplitter : ScriptableWizard
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        [Header("")]
+        [Divider]
+        [Tooltip("")]
+        [SerializeField] protected Dialogue DialogueToSplit = null;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected int splitAtLine = 0;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected string targetDirectory = "";
+
+
+        public DialogueSplitter()
+        {
+            Type projectWindowUtilType = typeof(ProjectWindowUtil);
+
+            MethodInfo getActiveFolderPath = projectWindowUtilType
+                .GetMethod("GetActiveFolderPath", BindingFlags.Static | BindingFlags.NonPublic);
+
+            object obj = getActiveFolderPath.Invoke(null, new object[0]);
+
+            string pathToCurrentFolder = obj.ToString();
+
+            pathToCurrentFolder = pathToCurrentFolder.Replace("Assets/", "");
+
+            targetDirectory = pathToCurrentFolder;
+
+            UnityEngine.Debug.Log(pathToCurrentFolder);
+        }
+
+
+        [MenuItem("DREditor/Dialogue/Split Dialogues")]
+        public static void CreateWizard() => DisplayWizard<DialogueSplitter>("Split Dialogue", "Split");
+
+        protected virtual void OnWizardCreate() => CreateSplitDialogue();
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void CreateSplitDialogue()
+        {
+            if (splitAtLine == 0)
+            {
+                UnityEngine.Debug.LogWarning("You cannot split at the first line!");
+
+                return;
+            }
+
+            Dialogue currentDialogue = CreateInstance<Dialogue>();
+
+            CopySplitLines(currentDialogue);
+
+            CopyDirectTo(currentDialogue);
+
+            CreateSplitAsset(currentDialogue);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="currentDialogue"></param>
+        protected virtual void CopySplitLines(Dialogue currentDialogue)
+        {
+            for (int i = splitAtLine; i < DialogueToSplit.Lines.Count; i++)
+            {
+                Line line = DialogueToSplit.Lines[i];
+
+                line = CustomEditorUtility.DeepCopyJson(line);
+
+                currentDialogue.Lines.Add(line);
+            }
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="currentDialogue"></param>
+        protected virtual void CopyDirectTo(Dialogue currentDialogue)
+        {
+            if (DialogueToSplit.DirectTo.Enabled)
+            {
+                currentDialogue.SetDirectTo(new DirectTo<Line>());
+
+                currentDialogue.DirectTo.SetEnabled(true);
+
+                currentDialogue.DirectTo.SetNewDialogue(DialogueToSplit.DirectTo.NewDialogue);
+            }
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="currentDialogue"></param>
+        protected virtual void CreateSplitAsset(Dialogue currentDialogue)
+        {
+            currentDialogue.name = DialogueToSplit.name;
+
+            string folder = FolderUtility.CreateIntermediateFolders(targetDirectory);
+
+            AssetDatabase.StartAssetEditing();
+
+            string diaPath = folder + "/" + currentDialogue.name + "_Split.asset";
+
+            AssetDatabase.CreateAsset(currentDialogue, diaPath);
+
+            AssetDatabase.StopAssetEditing();
+
+            AssetDatabase.SaveAssets();
+        }
+    }
+#endif
+}

package/Scripts/Editor/Utility/DialogueSplitter.cs.meta

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

package/Scripts/Editor/Utility/DialogueUtility.cs

@@ -0,0 +1,84 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using DREditor.Characters;
+using DREditor.Dialogues;
+using DREditor.Editor;
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+
+namespace DREditor.Editor.Utility
+{
+    /// <summary>
+    ///
+    /// </summary>
+    public static class DialogueUtility
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        [MenuItem("DREditor/Dialogue/Spawn Relevant Characters")]
+        public static void SpawnRelevantCharacters()
+        {
+            List<Character> characters = GetCharactersInSelectedDialogues();
+
+            if (characters.Count == 0)
+            {
+                UnityEngine.Debug.LogWarning("ALERT: Could not spawn relevant characters " +
+                    "as none could be found in the dialogue asset(s).");
+
+                return;
+            }
+
+            foreach (var character in characters)
+            {
+                if (character.ActorPrefab != null)
+                {
+                    GameObject gameObject = MonoBehaviour.Instantiate(character.ActorPrefab);
+
+                    gameObject.name = gameObject.name.Replace("(Clone)", "");
+                }
+            }
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <returns></returns>
+        private static List<Character> GetCharactersInSelectedDialogues()
+        {
+            List<Character> characters = new();
+
+            foreach (var obj in Selection.objects)
+                if (obj is Dialogue dialogue)
+                    characters.AddRange(dialogue.GetCharactersInDialogue());
+                else
+                    continue;
+
+            return characters;
+        }
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        [MenuItem("DREditor/Dialogue/Find Empty Scene Events In Dialogue")]
+        public static void FindDialogueWithText()
+        {
+            var assets = BuilderUtility.FindAssetsByType<DialogueCore>();
+
+            bool foundOne = false;
+
+            for (int i = 0; i < assets.Count; i++)
+                for (int x = 0; x < assets[i].GetLines<Line>().Count; x++)
+                    if (assets[i].GetLines<Line>()[x].HasEmptySceneEvents())
+                    {
+                        foundOne = true;
+
+                        UnityEngine.Debug.Log("REPORT: Empty Scene Event Found On: " + assets[i].name + " on line: " + x);
+                    }
+
+            if (!foundOne)
+                UnityEngine.Debug.LogWarning("ALERT: Couldn't find a trial dialogue that fit.");
+        }
+    }
+}

package/Scripts/Editor/Utility/DialogueUtility.cs.meta

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

package/Scripts/Editor/Utility/FilteredSOPickerWindow.cs

@@ -0,0 +1,157 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For DREditor
+#if UNITY_EDITOR
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditor;
+using UnityEngine;
+
+namespace DREditor.Editor.Utility
+{
+    /// <summary>
+    ///
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    public abstract class FilteredSOPickerWindow<T> : PickerWindowBase<ScriptableObject>
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        protected readonly List<ScriptableObject> allAssets = new();
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected List<ScriptableObject> filteredObjects = new();
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected string search = string.Empty;
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected Vector2 scroll;
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected List<Type> types;
+
+
+        protected virtual void OnEnable() => GenericTypeList<T>.UpdateTypeList(out types, out _);
+
+
+        protected override void Initialize() => RefreshAssets();
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void RefreshAssets()
+        {
+            allAssets.Clear();
+
+            foreach (Type type in types)
+            {
+                string[] guids = AssetDatabase.FindAssets($"t:{type.Name}");
+
+                foreach (string guid in guids)
+                {
+                    string path = AssetDatabase.GUIDToAssetPath(guid);
+
+                    var scriptableObject = AssetDatabase.LoadAssetAtPath(path, type) as ScriptableObject;
+
+                    if (scriptableObject != null && !allAssets.Contains(scriptableObject))
+                        allAssets.Add(scriptableObject);
+                }
+            }
+
+            allAssets.Sort((a, b) => string.Compare(a.name, b.name, StringComparison.OrdinalIgnoreCase));
+
+            ApplySearch();
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void ApplySearch()
+        {
+            filteredObjects = string.IsNullOrWhiteSpace(search) ?
+                new List<ScriptableObject>(allAssets) :
+                allAssets.Where(so => SearchInString(so.name) || SearchInString(so.GetType().Name)).ToList();
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="input"></param>
+        /// <returns></returns>
+        protected virtual bool SearchInString(string input)
+            => input.IndexOf(search, StringComparison.OrdinalIgnoreCase) >= 0;
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void DrawFilteredAssetList()
+        {
+            scroll = EditorGUILayout.BeginScrollView(scroll);
+
+            if (filteredObjects.Count == 0)
+                EditorGUILayout.HelpBox(
+                    $"No ScriptableObjects implementing {typeof(T).Name} found in the project.",
+                    MessageType.Info);
+            else
+                foreach (var asset in filteredObjects)
+                    DrawRow(asset);
+
+            EditorGUILayout.EndScrollView();
+        }
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="asset"></param>
+        protected abstract void DrawRow(ScriptableObject asset);
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="asset"></param>
+        protected virtual void Assign(ScriptableObject asset)
+        {
+            if (targetObject != null)
+                ApplyAssignedModifications(asset);
+            else
+                UnityEngine.Debug.LogWarning($"ALERT: {nameof(SimpleFilteredSOWindow<T>)} " +
+                    $"SerializedObject was destroyed — reopen the picker from the inspector.");
+
+            Close();
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="asset"></param>
+        protected virtual void ApplyAssignedModifications(ScriptableObject asset)
+        {
+            targetObject.Update();
+
+            SerializedProperty prop = targetObject.FindProperty(propertyPath);
+
+            if (prop != null)
+            {
+                prop.objectReferenceValue = asset;
+
+                targetObject.ApplyModifiedProperties();
+            }
+            else
+                UnityEngine.Debug.LogWarning($"ALERT: {nameof(SimpleFilteredSOWindow<T>)} " +
+                    $"Property path '{propertyPath}' not found.");
+        }
+    }
+}
+#endif

package/Scripts/Editor/Utility/FilteredSOPickerWindow.cs.meta

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

package/Scripts/Editor/Utility/FolderUtility.cs

@@ -0,0 +1,183 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For DREditor
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using UnityEditor;
+using UnityEngine;
+
+namespace DREditor.Editor.Utility
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public static class FolderUtility
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="asset"></param>
+        /// <returns></returns>
+        public static string GetAssetFolderPath(UnityEngine.Object asset)
+        {
+            string assetPath = AssetDatabase.GetAssetPath(asset);
+
+            assetPath = assetPath.Replace("/" + asset.name + ".asset", "");
+
+            return assetPath;
+        }
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="assetPath"></param>
+        /// <param name="assetName"></param>
+        /// <returns></returns>
+        public static bool TryCreateFolder(ref string assetPath, string assetName)
+        {
+            assetPath = assetPath.Replace(".asset", "");
+
+            if (!ProjectFolderExists(assetPath + "/" + assetName))
+            {
+                string shellFolder = AssetDatabase.CreateFolder(assetPath, assetName);
+
+                if (string.IsNullOrEmpty(shellFolder))
+                {
+                    UnityEngine.Debug.LogWarning("ALERT: Could not create folder. Canceling Initialization.");
+
+                    UnityEngine.Debug.Log("REPORT: Builder Path: " + assetPath);
+
+                    return false;
+                }
+            }
+
+            assetPath = assetPath + "/" + assetName;
+
+            return true;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="relativePath"></param>
+        /// <returns></returns>
+        public static bool ProjectFolderExists(string relativePath)
+        {
+            string fullPath = Path.Combine(Application.dataPath, "..", relativePath);
+
+            return !string.IsNullOrEmpty(relativePath) && Directory.Exists(fullPath);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="targetDirectory"></param>
+        /// <returns></returns>
+        public static string CreateIntermediateFolders(string targetDirectory)
+        {
+            string folderPath = targetDirectory.Replace('\\', '/');
+
+            List<string> folders = folderPath.Split('/').ToList();
+
+            string tempPath = "Assets";
+
+            if (folders[0] == tempPath)
+                folders.RemoveAt(0);
+
+            foreach (string folder in folders)
+            {
+                if (folder.Length == 0)
+                    continue;
+
+                if (!Directory.Exists(tempPath + "/" + folder))
+                    AssetDatabase.CreateFolder(tempPath, folder);
+
+                tempPath += "/" + folder;
+            }
+
+            return tempPath;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <returns></returns>
+        public static bool SelectedObjectIsFolder()
+        {
+            if (Selection.activeObject == null)
+            {
+                UnityEngine.Debug.LogWarning("ALERT: No object selected.");
+
+                return false;
+            }
+
+            string assetPath = AssetDatabase.GetAssetPath(Selection.activeObject);
+
+            if (string.IsNullOrEmpty(assetPath))
+            {
+                UnityEngine.Debug.LogWarning("ALERT: Selected object does not have a valid asset path.");
+
+                return false;
+            }
+
+            return Directory.Exists(assetPath);
+        }
+
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="title"></param>
+        /// <param name="startingFolderPath"></param>
+        /// <param name="selectedFolderPath"></param>
+        /// <param name="relative"></param>
+        /// <returns></returns>
+        public static bool SelectFolderPanel(string title, string startingFolderPath, out string selectedFolderPath, bool relative = true)
+        {
+            Func<string, string, string> openFolderPanel = relative ? SelectRelativeFolderPanel : SelectFullFolderPanel;
+
+            selectedFolderPath = openFolderPanel(title, startingFolderPath);
+
+            return ProjectFolderExists(selectedFolderPath);
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="title"></param>
+        /// <param name="startingFolderPath"></param>
+        /// <returns></returns>
+        private static string SelectRelativeFolderPanel(string title, string startingFolderPath)
+        {
+            string selectedFolderPath = SelectFullFolderPanel(title, startingFolderPath);
+
+            return GetRelativePath(selectedFolderPath);
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="title"></param>
+        /// <param name="startingFolderPath"></param>
+        /// <returns></returns>
+        private static string SelectFullFolderPanel(string title, string startingFolderPath)
+        {
+            string validStartFolder = CreateIntermediateFolders(startingFolderPath);
+
+            string selectedFolderPath = EditorUtility.OpenFolderPanel(title, validStartFolder, "");
+
+            // So folders made while the panels open are still valid :3
+            AssetDatabase.Refresh();
+
+            return selectedFolderPath;
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="fullPath"></param>
+        /// <returns></returns>
+        private static string GetRelativePath(string fullPath) => fullPath[(Application.dataPath.Length - "Assets".Length)..];
+    }
+}

package/Scripts/Editor/Utility/FolderUtility.cs.meta

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