net.dreditor.core 0.1.5 → 0.1.7

package/Scripts/Editor/Toolbox/CreateProjectVariantWizard.cs

@@ -0,0 +1,306 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using DREditor.Editor.Utility;
+using System;
+using System.IO;
+using UnityEditor;
+using UnityEngine;
+
+namespace DREditor.Editor.Toolbox
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public class CreateProjectVariantWizard : ScriptableWizard
+    {
+        /// <summary>
+        /// 
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected ProjectPrefabVariantSettings settings = null;
+
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <remarks>Purposly made a serialize field so the reference stays during a project reload when the wizard is open.</remarks>
+        [HideInInspector]
+        [SerializeField] protected GameObject target;
+
+
+        /// <summary>
+        /// 
+        /// </summary>
+        protected GameObject sourceAsset;
+
+        /// <summary>
+        /// 
+        /// </summary>
+        protected string assetPath;
+
+        /// <summary>
+        /// 
+        /// </summary>
+        protected string sourceName;
+
+        /// <summary>
+        /// 
+        /// </summary>
+        protected string trimmed;
+
+        /// <summary>
+        /// 
+        /// </summary>
+        protected bool running = false;
+
+
+        /// <summary>
+        /// 
+        /// </summary>
+        protected virtual bool SourceIsEmpty => sourceAsset == null;
+
+        /// <summary>
+        /// 
+        /// </summary>
+        protected virtual bool SuffixIsEmpty => trimmed.Length == 0;
+
+        /// <summary>
+        /// 
+        /// </summary>
+        protected virtual bool SuffixInvalid => trimmed.IndexOfAny(Path.GetInvalidFileNameChars()) >= 0;
+
+
+        /// <summary>
+        /// 
+        /// </summary>
+        private const string FolderPanelTitle = "Choose output folder for the Project Prefab Variant";
+
+        /// <summary>
+        /// 
+        /// </summary>
+        private const string MenuPath = "GameObject/DREditor/Create Project Prefab Variant";
+
+        /// <summary>
+        /// 
+        /// </summary>
+        private const int Priority = -20;
+
+        /// <summary>
+        /// 
+        /// </summary>
+        private const string PrefabExtension = ".prefab";
+
+
+        /// <summary>
+        /// 
+        /// </summary>
+        protected UnityEditor.Editor cachedEditor;
+
+
+        protected virtual void OnDisable()
+        {
+            if (cachedEditor != null)
+                DestroyImmediate(cachedEditor);
+        }
+
+
+        protected override bool DrawWizardGUI()
+        {
+            bool result = base.DrawWizardGUI();
+            
+            UnityEditor.Editor.DrawFoldoutInspector(settings, ref cachedEditor);
+            OnWizardUpdate();
+            return result;
+        }
+
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <returns></returns>
+        [MenuItem(MenuPath, true)]
+        public static bool IsSelectingPrefab() => DRETemplateUtility.GetSelectedPrefab() != null;
+
+        /// <summary>
+        /// 
+        /// </summary>
+        [MenuItem(MenuPath, false, Priority)]
+        public static void OpenWizard()
+        {
+            if (DRETemplateUtility.GetSelectedPrefab() is not GameObject instance)
+                return;
+
+            var wizard = DisplayWizard<CreateProjectVariantWizard>("Create Project Prefab Variant", "Create");
+
+            wizard.target = instance;
+
+            wizard.OnWizardUpdate();
+        }
+
+
+        protected virtual void OnWizardUpdate()
+        {
+            InitializeUpdate();
+
+            if (FoundNoIssues())
+                DisplayValidState();
+
+
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        protected virtual void InitializeUpdate()
+        {
+            isValid = false;
+
+            errorString = "";
+
+            helpString = "";
+
+            settings = ProjectPrefabVariantSettings.Instance;
+
+            sourceAsset = target != null ? PrefabUtility.GetCorrespondingObjectFromSource(target) : null;
+
+            if (sourceAsset != null)
+            {
+                sourceName = DRETemplateUtility.GetPrefabName(sourceAsset);
+
+                trimmed = (settings.suffix ?? "").Trim();
+            }
+        }
+
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <returns></returns>
+        protected virtual bool FoundNoIssues() =>
+            !FoundIssue(SourceIsEmpty, OnSourceEmpty) &&
+            !FoundIssue(SuffixIsEmpty, OnSuffixEmpty) &&
+            !FoundIssue(SuffixInvalid, OnSuffixInvalid);
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="issuePresent"></param>
+        /// <param name="setWizardString"></param>
+        /// <returns></returns>
+        protected virtual bool FoundIssue(bool issuePresent, Action setWizardString)
+        {
+            if (issuePresent)
+                setWizardString();
+
+            return issuePresent;
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        protected virtual void OnSourceEmpty() => errorString = "ALERT: " +
+            "\nThe selected object is no longer a valid prefab instance.";
+
+        /// <summary>
+        /// 
+        /// </summary>
+        protected virtual void OnSuffixEmpty() =>
+            helpString = $"ALERT: " +
+            $"\nSource prefab: {sourceName}\nEnter a suffix for the new Prefab Variant.";
+
+        /// <summary>
+        /// 
+        /// </summary>
+        protected virtual void OnSuffixInvalid() =>
+            errorString = "ALERT: " +
+            "\nThe suffix contains characters that are not allowed in a file name.";
+
+
+        /// <summary>
+        /// 
+        /// </summary>
+        protected virtual void DisplayValidState()
+        {
+            ResolveUpdate();
+
+            CheckAutoApply();
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        protected virtual void ResolveUpdate()
+        {
+            helpString = $"REPORT: " +
+                $"\nSource prefab: {sourceName}" +
+                $"\nNew prefab: {DRETemplateUtility.CreateProjectVariantName(sourceAsset, trimmed)}.prefab";
+
+            isValid = true;
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        protected virtual void CheckAutoApply()
+        {
+            if (settings.permanentlyUseSettings && !running)
+                OnWizardCreate();
+        }
+
+
+        protected virtual void OnWizardCreate()
+        {
+            running = true;
+
+            if (VariantCanBeCreated())
+                CreateProjectPrefabVariant();
+
+            Close();
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <returns></returns>
+        protected virtual bool VariantCanBeCreated() =>
+            SourceAssetValid() &&
+            TrySelectingOutputFolder(out string selectedPath) &&
+            !DRETemplateUtility.AssetExistsAt(selectedPath, out assetPath);
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <returns></returns>
+        protected virtual bool SourceAssetValid()
+        {
+            bool result = target != null && IsSelectingPrefab() && sourceAsset != null;
+
+            if (!result)
+                Debug.LogError("Create Prefab Variant: the selected object is no longer a prefab instance.");
+
+            return result;
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="assetPath"></param>
+        /// <returns></returns>
+        protected virtual bool TrySelectingOutputFolder(out string assetPath)
+        {
+            string projectVariantName = DRETemplateUtility.CreateProjectVariantName(sourceAsset, settings.suffix.Trim());
+
+            bool selectedFolder = FolderUtility.SelectFolderPanel(FolderPanelTitle, settings.targetDirectory, out string selectedFolderPath);
+
+            assetPath = selectedFolder ? $"{selectedFolderPath}/{projectVariantName + PrefabExtension}" : string.Empty;
+
+            return selectedFolder;
+        }
+
+
+        /// <summary>
+        /// 
+        /// </summary>
+        protected virtual void CreateProjectPrefabVariant() =>
+            DRETemplateUtility.CreateProjectPrefabVariant(target, assetPath);
+    }
+}

package/Scripts/Editor/Toolbox/CreateProjectVariantWizard.cs.meta

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

package/Scripts/Editor/Toolbox/DRETemplateUtility.cs

@@ -0,0 +1,258 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using System.IO;
+using UnityEditor;
+using UnityEditor.SceneManagement;
+using UnityEngine;
+
+namespace DREditor.Editor.Toolbox
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    public static class DRETemplateUtility
+    {
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <remarks>Must be Checked in order because "ETemplate" also ends with "Template".</remarks>
+        private static readonly string[] TemplateSuffixes = { "ETemplate", "Template", "Shell" };
+
+        /// <summary>
+        /// 
+        /// </summary>
+        private static readonly char TemplateNameSeparator = '_';
+
+
+        /// <summary>
+        /// 
+        /// </summary>
+        public static GameObject GetSelectedPrefab()
+        {
+            GameObject gameObject = Selection.activeGameObject;
+
+            if (Selection.gameObjects.Length != 1 ||
+                SelectedProjectWindowAsset(gameObject) ||
+                PrefabInvalid(gameObject))
+                return null;
+
+            return PrefabUtility.GetCorrespondingObjectFromSource(gameObject) != null ? gameObject : null;
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="gameObject"></param>
+        /// <returns></returns>
+        private static bool SelectedProjectWindowAsset(GameObject gameObject) =>
+            gameObject == null || EditorUtility.IsPersistent(gameObject);
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="gameObject"></param>
+        /// <returns></returns>
+        private static bool PrefabInvalid(GameObject gameObject) =>
+            !PrefabUtility.IsAnyPrefabInstanceRoot(gameObject) || PrefabUtility.IsPrefabAssetMissing(gameObject);
+
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="sentPath"></param>
+        /// <param name="assetPath"></param>
+        /// <returns></returns>
+        public static bool AssetExistsAt(string sentPath, out string assetPath)
+        {
+            assetPath = sentPath;
+
+            bool alreadyExists = File.Exists(sentPath) || AssetDatabase.LoadMainAssetAtPath(sentPath) != null;
+
+            return alreadyExists && !UniquePathPrompt(sentPath, out assetPath);
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="sentPath"></param>
+        /// <param name="unique"></param>
+        /// <returns></returns>
+        private static bool UniquePathPrompt(string sentPath, out string unique)
+        {
+            string uniquePath = AssetDatabase.GenerateUniqueAssetPath(sentPath);
+
+            bool useUnique = EditorUtility.DisplayDialog(
+                "Prefab already exists",
+                $"ALERT: '{sentPath}' already exists." +
+                $"\n\nPROPOSAL: Create '{Path.GetFileName(uniquePath)}' instead?",
+                "Use Unique Name", "Cancel");
+
+            unique = useUnique ? uniquePath : sentPath;
+
+            return useUnique;
+        }
+
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="instanceRoot"></param>
+        /// <param name="variantAssetPath"></param>
+        public static void CreateProjectPrefabVariant(GameObject instanceRoot, string variantAssetPath)
+        {
+            int undoGroup = Undo.GetCurrentGroup();
+
+            if (!TryMakeProjectPrefabVariant(instanceRoot, variantAssetPath, out GameObject variantAsset))
+                return;
+
+            RenameHierarchyObjectToVariantName(instanceRoot, variantAssetPath);
+
+            Undo.CollapseUndoOperations(undoGroup);
+
+            FlagSceneOrOpenedPrefabAsChanged(instanceRoot);
+
+            EditorGUIUtility.PingObject(variantAsset);
+
+            Debug.Log($"REPORT: Created Project Prefab Variant at: '{variantAssetPath}'.", variantAsset);
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="instanceRoot"></param>
+        /// <param name="variantAssetPath"></param>
+        /// <param name="variantAsset"></param>
+        /// <returns></returns>
+        private static bool TryMakeProjectPrefabVariant(GameObject instanceRoot, string variantAssetPath, out GameObject variantAsset)
+        {
+            variantAsset = null;
+
+            bool succeded = false;
+
+            try
+            {
+                variantAsset = PrefabUtility.SaveAsPrefabAssetAndConnect(instanceRoot, variantAssetPath, InteractionMode.UserAction,
+                    out succeded);
+            }
+            catch (System.Exception exception)
+            {
+                Debug.LogError($"ALERT: Create Prefab Variant failed!");
+
+                Debug.LogException(exception);
+            }
+
+            if (!succeded || variantAsset == null)
+                Debug.LogError($"ALERT: Create Prefab Variant: could not create a Prefab Variant at '{variantAssetPath}'.");
+
+            return succeded;
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="instanceRoot"></param>
+        /// <param name="variantAssetPath"></param>
+        private static void RenameHierarchyObjectToVariantName(GameObject instanceRoot, string variantAssetPath)
+        {
+            string variantName = Path.GetFileNameWithoutExtension(variantAssetPath);
+
+            if (instanceRoot.name != variantName)
+            {
+                Undo.RecordObject(instanceRoot, "Rename Prefab Variant Instance");
+
+                instanceRoot.name = variantName;
+            }
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="instanceRoot"></param>
+        private static void FlagSceneOrOpenedPrefabAsChanged(GameObject instanceRoot)
+        {
+            PrefabStage stage = PrefabStageUtility.GetPrefabStage(instanceRoot);
+
+            if (stage != null)
+                EditorSceneManager.MarkSceneDirty(stage.scene);
+            else if (instanceRoot.scene.IsValid())
+                EditorSceneManager.MarkSceneDirty(instanceRoot.scene);
+            else
+                Debug.LogWarning("ALERT: Somehow, there is no area in which to set what's currently happening as changed.");
+        }
+
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="sourceAsset"></param>
+        /// <param name="suffixText"></param>
+        /// <returns></returns>
+        public static string CreateProjectVariantName(GameObject sourceAsset, string suffixText) =>
+            CreateProjectVariantName(GetPrefabName(sourceAsset), suffixText);
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="prefabAsset"></param>
+        /// <returns></returns>
+        public static string GetPrefabName(GameObject prefabAsset) =>
+            Path.GetFileNameWithoutExtension(AssetDatabase.GetAssetPath(prefabAsset));
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="templateName"></param>
+        /// <param name="suffixText"></param>
+        /// <returns></returns>
+        private static string CreateProjectVariantName(string templateName, string suffixText)
+        {
+            string templateBaseName = ReplaceTemplateName(templateName);
+
+            string projectSuffix = TrimSuffix(templateBaseName, suffixText);
+
+            return templateBaseName + projectSuffix;
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="templateBaseName"></param>
+        /// <param name="suffixText"></param>
+        /// <returns></returns>
+        private static string TrimSuffix(string templateBaseName, string suffixText) =>
+            templateBaseName.EndsWith(TemplateNameSeparator) ? suffixText.TrimStart(TemplateNameSeparator) : suffixText;
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="replaceName"></param>
+        /// <returns></returns>
+        private static string ReplaceTemplateName(string replaceName)
+        {
+            string templateSuffix = replaceName.GetTemplateSuffix();
+
+            bool shouldReplacedTemplate = !string.IsNullOrEmpty(templateSuffix);
+
+            if (shouldReplacedTemplate)
+                replaceName = replaceName[..^templateSuffix.Length];
+
+            if (!shouldReplacedTemplate && !replaceName.EndsWith(TemplateNameSeparator))
+                replaceName += TemplateNameSeparator;
+
+            return replaceName;
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="objectName"></param>
+        /// <returns></returns>
+        private static string GetTemplateSuffix(this string objectName)
+        {
+            foreach (string ending in TemplateSuffixes)
+                if (objectName.EndsWith(ending, System.StringComparison.Ordinal))
+                    return ending;
+
+            return string.Empty;
+        }
+    }
+}

package/Scripts/Editor/Toolbox/DRETemplateUtility.cs.meta

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

package/Scripts/Editor/Toolbox/DialogueEventImporter.cs

@@ -0,0 +1,111 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For DREditor
+#if UNITY_EDITOR
+using DREditor.Dialogues;
+using DREditor.Dialogues.Events;
+using DREditor.Editor.Utility;
+using UnityEngine;
+
+namespace DREditor.Editor.Toolbox
+{
+    using Debug = UnityEngine.Debug;
+    //This shits getting reworked in the future.
+    public class DialogueEventImporter
+    {
+
+        #region Adding Events
+        bool cg = false;
+        bool miniCG = false;
+        //bool loadScene = false;
+        bool endCG = false;
+        bool endMiniCG = false;
+        string cgName = "";
+        public void EvalEvents(string l)
+        {
+
+            if (l.Contains("CG - ") && !l.Contains("Mini-CG - "))
+            {
+                cg = true;
+                cgName = l.Replace("//CG - ", "");
+            }
+            if (l.Contains("Mini-CG - "))
+            {
+                miniCG = true;
+                cgName = l.Replace("//Mini-CG - ", "");
+            }
+            if (l.Contains("End CG"))
+            {
+                endCG = true;
+            }
+            if (l.Contains("End Mini-CG"))
+            {
+                endMiniCG = true;
+            }
+
+        }
+        public T AddEvents<T>(T l) where T : Line
+        {
+            if (endCG)
+            {
+                endCG = false;
+                l.DiaEvents.Add(new CGDisplay());
+            }
+            if (endMiniCG)
+            {
+                endMiniCG = false;
+                l.DiaEvents.Add(new ShowItem());
+            }
+            if (cg)
+            {
+                cg = false;
+                Sprite s = null;
+                try
+                {
+                    s = BuilderUtility.FindAssetsByType<Sprite>(cgName)[0];
+                }
+                catch
+                {
+                    Debug.LogWarning("An Error Occurred trying to import cg: " + cgName);
+                    s = BuilderUtility.FindAssetsByType<Sprite>("Black Screen")[0];
+                }
+                if (s != null)
+                {
+                    l.DiaEvents.Add(new CGDisplay(s));
+                    Debug.Log("Added " + cgName);
+
+                }
+                else
+                {
+                    Debug.LogWarning("FAILED TO IMPORT CG");
+                }
+            }
+            if (miniCG)
+            {
+                miniCG = false;
+                Texture2D s = null;
+                try
+                {
+                    s = BuilderUtility.FindAssetsByType<Texture2D>(cgName)[0];
+                }
+                catch
+                {
+                    Debug.LogWarning("An Error Occurred trying to import Mini cg" + cgName);
+                    s = BuilderUtility.FindAssetsByType<Texture2D>("Black Screen")[0];
+                }
+
+                if (s != null)
+                {
+                    l.DiaEvents.Add(new ShowItem(s));
+                    Debug.Log("Added " + cgName);
+                }
+                else
+                {
+                    Debug.LogWarning("FAILED TO IMPORT MINICG");
+                }
+            }
+
+            return l;
+        }
+        #endregion
+    }
+}
+#endif

package/Scripts/Editor/Toolbox/DialogueEventImporter.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 27a064b4736cf914abcd721d127e9fd5