net.dreditor.editor.utility.converting 0.0.0-stage → 0.1.7

package/ActorConversion.cs

@@ -0,0 +1,105 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using DREditor.Characters;
+using DREditor.EventObjects;
+using DREditor.Processables;
+using UnityEditor;
+using UnityEngine;
+
+namespace DREditor.Editor.Utility.Converting
+{
+    /// <summary>
+    ///
+    /// </summary>
+    public static class ActorConversion
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        [MenuItem("DREditor/Convert/Actors/Update Selected Actor Display Names.")]
+        public static void UpdateName()
+        {
+            CharacterDatabase database = DatabaseUtility.LoadDatabase<CharacterDatabase>();
+
+            foreach (Character character in database.Characters)
+                foreach (var obj in Selection.objects)
+                    if (obj is GameObject gameObject && gameObject.name == character.FirstName)
+                        UpdateObject(character, gameObject);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="character"></param>
+        /// <param name="go"></param>
+        static void UpdateObject(Character character, GameObject go)
+        {
+            if (go.TryGetComponent<INameDisplayable>(out var component))
+                component.DisplayName = character.FirstName + " " + character.LastName;
+
+            EditorUtility.SetDirty(go);
+
+            AssetDatabase.SaveAssets();
+        }
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        [MenuItem("DREditor/Convert/Actors/Update Selected Actor Colliders.")]
+        public static void UpdateColliders()
+        {
+            foreach (var obj in Selection.objects)
+                if (obj is GameObject go)
+                    UpdateCollider(go);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="gameObject"></param>
+        static void UpdateCollider(GameObject gameObject)
+        {
+            BoxCollider parentCollider = gameObject.GetComponent<BoxCollider>();
+
+            BoxCollider childCollider = gameObject.transform.GetChild(0).GetComponent<BoxCollider>();
+
+            if (!parentCollider || !childCollider || parentCollider == childCollider)
+            {
+                UnityEngine.Debug.LogWarning("ALERT: Invalid collider setup. Either your missing a parent or child collider, or " +
+                    "the child and parent colliders are the same, which is not allowed.");
+
+                return;
+            }
+
+            Undo.RecordObject(parentCollider, "Copy Collider From Child (Apply Scale)");
+
+            Transform parentTransform = parentCollider.transform;
+
+            Transform childTransform = childCollider.transform;
+
+            var bounds = new Bounds(
+                childTransform.TransformPoint(childCollider.center),
+                Vector3.Scale(childCollider.size, childTransform.lossyScale)
+            );
+
+            Vector3 localCenter = parentTransform.InverseTransformPoint(bounds.center);
+
+            Vector3 localSize = Vector3.Scale(bounds.size, InverseScale(parentTransform.lossyScale));
+
+            parentCollider.center = localCenter;
+
+            parentCollider.size = localSize;
+
+            EditorUtility.SetDirty(parentCollider);
+
+            UnityEngine.Debug.Log($"Copied scaled collider from '{childCollider.name}' to '{parentCollider.name}'.");
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="vector"></param>
+        /// <returns></returns>
+        static Vector3 InverseScale(Vector3 vector) => new(1f / vector.x, 1f / vector.y, 1f / vector.z);
+    }
+}

package/ActorConversion.cs.meta

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

package/ConvertRoomDataRegion.cs

@@ -0,0 +1,438 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using DREditor.Doors;
+using DREditor.Editor;
+using DREditor.Progressing;
+using DREditor.RoomBuilding;
+using DREditor.RoomBuilding.Implementation;
+using DREditor.RoomBuilding.Implementation.Actors;
+using DREditor.RoomBuilding.Old;
+using DREditor.SubAreas;
+using DREditor.Talkables;
+using DREditor.Triggers;
+using System.Collections.Generic;
+using System.IO;
+using UnityEditor;
+using UnityEngine;
+
+namespace DREditor.Editor.Utility.Converting
+{
+    /// <summary>
+    ///
+    /// </summary>
+    public class ConvertRoomDataRegion
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        protected ProgressionDatabase pDB;
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected RoomBuilder currentRoomBuilder;
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected RoomSection currentRoomSection;
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected RoomData currentRoomData;
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected RoomStateBuilder currentRoomStateBuilder;
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected RoomStateSection currentRoomStateSection;
+
+
+        [MenuItem("DREditor/Convert/Convert First Room Data Builder")]
+        public static void ConvertFirstRoomDataBuilders() => new ConvertRoomDataRegion().ConvertFirst();
+
+        /// <summary>
+        ///
+        /// </summary>
+        public virtual void ConvertFirst()
+        {
+            var roomBuilders = BuilderUtility.FindAssetsByType<RoomBuilder>();
+
+            currentRoomBuilder = roomBuilders[0];
+
+            CreateRoomStateBuilder(roomBuilders[0]);
+        }
+
+
+        [MenuItem("DREditor/Convert/Convert All Room Data Builders")]
+        public static void ConvertAllRoomDataBuilders() => new ConvertRoomDataRegion().ConvertAll();
+
+        /// <summary>
+        ///
+        /// </summary>
+        public virtual void ConvertAll()
+        {
+            if (!DatabaseUtility.InitializeDatabase(pDB, out pDB))
+                return;
+
+            var roomBuilders = BuilderUtility.FindAssetsByType<RoomBuilder>();
+
+            foreach (var roomBuilder in roomBuilders)
+                CreateRoomStateBuilder(roomBuilder);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="roomBuilder"></param>
+        public virtual void CreateRoomStateBuilder(RoomBuilder roomBuilder)
+        {
+            currentRoomBuilder = roomBuilder;
+
+            InitializeBuilder(roomBuilder.name.Replace(".asset", ""));
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="builderName"></param>
+        protected virtual void InitializeBuilder(string builderName)
+        {
+            var builderAsset = ScriptableObject.CreateInstance<RoomStateBuilder>();
+
+            string buildFolderPath = "Assets/RoomBuilding";
+
+            if (!ConvertUtility.ProjectFolderExists(buildFolderPath))
+                AssetDatabase.CreateFolder("Assets", "RoomBuilding");
+
+            string buildFolder = AssetDatabase.CreateFolder(buildFolderPath, builderName);
+
+            if (buildFolder == "")
+            {
+                UnityEngine.Debug.LogWarning("Could not create folder. Canceling Initialization.");
+
+                UnityEngine.Debug.Log("Builder Path: " + buildFolderPath);
+
+                return;
+            }
+
+            string newFolderPath = AssetDatabase.GUIDToAssetPath(buildFolder);
+
+            AssetDatabase.CreateAsset(builderAsset, newFolderPath + "/" + builderName + ".asset");
+
+            AssetDatabase.SaveAssets();
+
+            EditorUtility.SetDirty(builderAsset);
+
+            InitializeSections(builderAsset);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="builder"></param>
+        protected virtual void InitializeSections(RoomStateBuilder builder)
+        {
+            foreach (Chapter chapter in pDB.Chapters)
+            {
+                var sectionAsset = ScriptableObject.CreateInstance<RoomStateSection>();
+
+                sectionAsset.SetChapter(chapter);
+
+
+                string newAssetPath = CreateSectionAssetPath(chapter, builder);
+
+                if (newAssetPath == "")
+                    return;
+
+
+                AssetDatabase.CreateAsset(sectionAsset, newAssetPath);
+
+                AssetDatabase.SaveAssets();
+
+                EditorUtility.SetDirty(sectionAsset);
+
+                builder.Sections.Add(sectionAsset);
+
+                EditorUtility.SetDirty(builder);
+            }
+
+            currentRoomStateBuilder = builder;
+
+            CreateDataAssets();
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="chapter"></param>
+        /// <param name="builder"></param>
+        /// <returns></returns>
+        protected virtual string CreateSectionAssetPath(Chapter chapter, RoomStateBuilder builder)
+        {
+            string builderPath = AssetDatabase.GetAssetPath(builder);
+
+            string builderPrefix = builder.name.Replace(".asset", "");
+
+            string sectionPath = builderPath.Replace("/" + builder.name + ".asset", "");
+
+            string sectionFolderName = builderPrefix + $"_{pDB.GetChapterIndex(chapter)}";
+
+            string sectionFolder = AssetDatabase.CreateFolder(sectionPath, sectionFolderName);
+
+            if (sectionFolder == "")
+            {
+                UnityEngine.Debug.LogWarning("Could not create folder. Canceling Initialization.");
+
+                UnityEngine.Debug.Log("Builder Path: " + sectionPath);
+
+                return "";
+            }
+
+            string newFolderPath = AssetDatabase.GUIDToAssetPath(sectionFolder);
+
+            return newFolderPath + "/" + builderPrefix + $"_{pDB.GetChapterIndex(chapter)}.asset";
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void CreateDataAssets()
+        {
+            foreach (var section in currentRoomBuilder.Sections)
+            {
+                currentRoomSection = section;
+
+                currentRoomStateSection = currentRoomStateBuilder.Sections[currentRoomBuilder.Sections.IndexOf(section)];
+
+                ConvertRoom();
+            }
+
+            for (int i = 0; i < currentRoomBuilder.Shells.Count; i++)
+                CreateShellSave(i);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void ConvertRoom()
+        {
+            for (int i = 0; i < currentRoomSection.Rooms.Count; i++)
+            {
+                currentRoomData = currentRoomSection.Rooms[i];
+
+                SaveRoom(currentRoomData.progressionValue);
+            }
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="pValue"></param>
+        protected virtual void SaveRoom(Objective pValue)
+        {
+            int index = pDB.Chapters.IndexOf(currentRoomStateSection.Chapter);
+
+            string sectionPath = currentRoomStateBuilder.Sections[index].GetFolderPath();
+
+            string sectionPrefix = currentRoomStateBuilder.Sections[index].name.Replace(".asset", "");
+
+            string roomStateName = sectionPrefix + "_" + pValue.Description;
+
+            if (!ConvertUtility.TryCreateFolder(ref sectionPath, roomStateName))
+                return;
+
+            string newAssetPath = sectionPath + "/" + roomStateName + ".asset";
+
+            RoomStateData room = CreateRoomState(pValue, newAssetPath);
+
+            room.SetPersistent(currentRoomData.isPersistent);
+
+            currentRoomStateBuilder.Sections[index].Rooms.Add(room);
+
+            string path = AssetDatabase.GetAssetPath(room);
+
+            if (path.Length >= 252)
+                UnityEngine.Debug.LogWarning("path too long for: " + path);
+
+            EditorUtility.SetDirty(currentRoomStateBuilder);
+
+            EditorUtility.SetDirty(currentRoomStateBuilder.Sections[index]);
+
+            EditorUtility.SetDirty(room);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="pValue"></param>
+        /// <param name="path"></param>
+        /// <param name="data"></param>
+        /// <returns></returns>
+        protected virtual RoomStateData CreateRoomState(Objective pValue, string path, RoomStateData data = null)
+        {
+            bool createAsset = false;
+
+            if (data == null)
+            {
+                data = ScriptableObject.CreateInstance<RoomStateData>();
+
+                data.SetProgressionValue(pValue);
+
+
+                createAsset = true;
+            }
+
+            string dataAssetPath = path.Replace(".asset", "");
+
+            data = ConvertRoomData(data, dataAssetPath);
+
+            if (createAsset)
+                ConvertUtility.CreateAssetAt(data, path);
+
+            return data;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="data"></param>
+        /// <param name="path"></param>
+        /// <returns></returns>
+        protected virtual RoomStateData ConvertRoomData(RoomStateData data, string path)
+        {
+            data.dataStates.Add(SaveDataAsset<SpawnableStateData, GameObject>(path, "Spawnables", currentRoomData.spawnDatas));
+
+            data.dataStates.Add(SaveDataAsset<ActorStateData, ActorData>(path, "Actors", currentRoomData.actorDatas));
+
+            data.dataStates.Add(SaveDataAsset<ItemStateData, ItemData>(path, "Items", currentRoomData.itemDatas));
+
+            data.dataStates.Add(SaveDataAsset<TriggerStateData, EventTrigger>(path, "Triggers", currentRoomData.triggers));
+
+            data.dataStates.Add(SaveDataAsset<SubAreaStateData, SubAreaData>(path, "SubAreas", currentRoomData.subAreas));
+
+            data.dataStates.Add(SaveDataAsset<DoorStateData, DoorData>(path, "Doors", currentRoomData.doorDatas));
+
+            data.dataStates.Add(SaveDataAsset<MoveStateData, MoveData>(path, "Moveables", currentRoomData.moveDatas));
+
+            data.dataStates
+                .Add(SaveDataAsset<SaveableStateData, SaveableDataSet>(path, "Saveables", currentRoomData.saveables.dataSets));
+
+            data.dataStates.RemoveAll(item => item == null);
+
+            return data;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <typeparam name="T2"></typeparam>
+        /// <param name="path"></param>
+        /// <param name="dataAssetName"></param>
+        /// <param name="list"></param>
+        /// <returns></returns>
+        protected virtual ScriptableObject SaveDataAsset<T, T2>(string path, string dataAssetName, List<T2> list)
+            where T : StateDataAsset<T2>
+        {
+            if (list.Count == 0)
+                return null;
+
+            string[] guids = AssetDatabase.FindAssets($"t:{typeof(T).Name}", 
+                new[] { Path.GetDirectoryName(path.TrimEnd(Path.DirectorySeparatorChar)) });
+
+            T dataAsset;
+
+            if (guids.Length > 0)
+                dataAsset = ConvertUtility.GetAssetFromGUID<T>(guids[0]);
+            else
+                dataAsset = ScriptableObject.CreateInstance<T>();
+
+            dataAsset.SetDatas(list);
+
+            if (!(guids.Length > 0) && dataAsset.datas != null && dataAsset.datas.Count != 0)
+                AssetDatabase.CreateAsset(dataAsset, path + "_" + dataAssetName + ".asset");
+
+            EditorUtility.SetDirty(dataAsset);
+
+            AssetDatabase.SaveAssets();
+
+            if (guids.Length > 0)
+                return null;
+
+            return dataAsset;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="i"></param>
+        protected virtual void CreateShellSave(int i)
+        {
+            if (!CreateShellPath($"_{i}_Shell", out string newAssetPath))
+            {
+                UnityEngine.Debug.LogWarning("ALERT: Had trouble creating shell path, aborting for index: " + i);
+
+                return;
+            }
+
+            currentRoomData = currentRoomBuilder.Shells[i];
+
+            RoomStateData shellAsset = CreateRoomState(null, newAssetPath);
+
+            CheckFillShells(i);
+
+            if (currentRoomStateBuilder.Shells.HasValidIndexFor(i))
+                currentRoomStateBuilder.Shells[i] = shellAsset;
+            else
+                currentRoomStateBuilder.Shells.Add(shellAsset);
+
+            EditorUtility.SetDirty(currentRoomStateBuilder);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="builderSuffix"></param>
+        /// <param name="newAssetPath"></param>
+        /// <returns></returns>
+        protected virtual bool CreateShellPath(string builderSuffix, out string newAssetPath)
+        {
+            newAssetPath = "";
+
+            string shellPath = currentRoomStateBuilder.GetFolderPath();
+
+            if (!ConvertUtility.TryCreateFolder(ref shellPath, currentRoomStateBuilder.name + "_Shell"))
+                return false;
+
+            string builderPrefix = currentRoomStateBuilder.name.Replace(".asset", "");
+
+            string shellAssetName = builderPrefix + builderSuffix;
+
+            if (!ConvertUtility.TryCreateFolder(ref shellPath, shellAssetName))
+                return false;
+
+            newAssetPath = shellPath + "/" + shellAssetName + ".asset";
+
+            return true;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="i"></param>
+        protected virtual void CheckFillShells(int i)
+        {
+            if (currentRoomStateBuilder.Shells.Count < i)
+            {
+                currentRoomStateBuilder.Shells.Add(null);
+
+                CheckFillShells(i);
+            }
+        }
+    }
+}

package/ConvertRoomDataRegion.cs.meta

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

package/ConvertRoomDataScenes.cs

@@ -0,0 +1,169 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using DREditor.RoomBuilding;
+using DREditor.RoomBuilding.Old;
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEditor.SceneManagement;
+using UnityEngine;
+
+namespace DREditor.Editor.Utility.Converting
+{
+    /// <summary>
+    ///
+    /// </summary>
+    public class ConvertRoomDataScenes : ScriptableWizard
+    {
+        // Get the asset of the RoomStateManager Prefab
+
+        // Get all valid scenes guids
+        // Get all valid scene assets
+        // Get the paths to each valid scene
+        // Open each scene 
+
+        // If that scene contains a RoomManager, 
+        // Then 
+        // Instantiate the prefab in the scene
+        // Select Prefab
+        // Delete the RoomManager GameObject
+        // Set the scene dirty and save
+        // ELSE
+        // Move to the next scene
+
+        /// <summary>
+        ///
+        /// </summary>
+        static readonly List<RoomStateBuilder> Builders = new();
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Header("")]
+        [Tooltip("")]
+        [SerializeField] protected GameObject roomStateManagerPrefab = null;
+
+
+        [MenuItem("DREditor/Convert/Convert Scene Room Managers")]
+        public static void CreateWizard() => DisplayWizard<ConvertRoomDataScenes>("Convert Room Data", "Convert");
+
+        protected virtual void OnWizardCreate()
+        {
+            if (EditorUtility.DisplayDialog("Confirm", "You MUST convert the Room Data Assets FIRST." +
+                "\nYou can do this by calling: DREditor/Convert/Convert All Room Data Builders." +
+                "\nHave you done this?", "Yes", "No"))
+                ConvertSceneRoomManagers();
+        }
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void ConvertSceneRoomManagers()
+        {
+            InitializeBuilders();
+
+            ConvertAllValidScenes();
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void InitializeBuilders()
+        {
+            Builders.Clear();
+
+            var found = AssetDatabase.FindAssets("t:RoomStateBuilder");
+
+            if (found.Length != 0)
+                foreach (var asset in found)
+                {
+                    string path = AssetDatabase.GUIDToAssetPath(asset);
+
+                    var roomStateBuilder = AssetDatabase.LoadAssetAtPath<RoomStateBuilder>(path);
+
+                    Builders.Add(roomStateBuilder);
+                }
+        }
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void ConvertAllValidScenes()
+        {
+            var scenes = CustomEditorUtility.GetAllValidSceneAssets();
+
+            foreach (var scene in scenes)
+                ConvertScene(scene);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="scene"></param>
+        protected virtual void ConvertScene(SceneAsset scene)
+        {
+            try
+            {
+                CustomEditorUtility.LoadScene(scene);
+            }
+            catch
+            {
+                UnityEngine.Debug.LogWarning("Had trouble opening scene: " + scene.name + " , Skipping conversion.");
+
+                return;
+            }
+
+            ExecuteRoomConvert();
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void ExecuteRoomConvert()
+        {
+            var roomManagers = MonoBehaviour.FindObjectsByType<RoomManager>();
+
+            if (roomManagers.Length > 0 && HasExistingBuilder(out RoomStateBuilder builder))
+            {
+                var managerObject = (GameObject)PrefabUtility.InstantiatePrefab(roomStateManagerPrefab);
+
+                var manager = managerObject.GetComponent<RoomStateManager>();
+
+                manager.SetBuilder(builder);
+
+                EditorUtility.SetDirty(manager);
+
+                MonoBehaviour.DestroyImmediate(roomManagers[0].gameObject);
+
+                EditorUtility.SetDirty(managerObject);
+
+                EditorSceneManager.SaveScene(EditorSceneManager.GetActiveScene());
+            }
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="builder"></param>
+        /// <returns></returns>
+        protected virtual bool HasExistingBuilder(out RoomStateBuilder builder)
+        {
+            builder = null;
+
+            if (Builders.Count != 0)
+            {
+                foreach (var roomStateBuilder in Builders)
+                {
+                    if (roomStateBuilder != null && roomStateBuilder.name == EditorSceneManager.GetActiveScene().name)
+                    {
+                        builder = roomStateBuilder;
+
+                        return true;
+                    }
+                }
+            }
+
+            return false;
+        }
+    }
+}

package/ConvertRoomDataScenes.cs.meta

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

package/ConvertUtility.cs

@@ -0,0 +1,108 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using System.Collections.Generic;
+using System.IO;
+using UnityEditor;
+using UnityEngine;
+
+namespace DREditor.Editor.Utility.Converting
+{
+    /// <summary>
+    ///
+    /// </summary>
+    public static class ConvertUtility
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="list"></param>
+        /// <param name="index"></param>
+        /// <returns></returns>
+        public static bool HasValidIndexFor<T>(this List<T> list, int index) => index >= 0 && index < list.Count;
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="asset"></param>
+        /// <returns></returns>
+        public static string GetFolderPath(this Object asset)
+        {
+            string assetPath = AssetDatabase.GetAssetPath(asset);
+
+            assetPath = assetPath.Replace("/" + asset.name + ".asset", "");
+
+            return assetPath;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="guid"></param>
+        /// <returns></returns>
+        public static T GetAssetFromGUID<T>(string guid) where T : UnityEngine.Object
+        {
+            string path = AssetDatabase.GUIDToAssetPath(guid);
+
+            return AssetDatabase.LoadAssetAtPath<T>(path);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="obj"></param>
+        /// <param name="path"></param>
+        public static void CreateAssetAt(UnityEngine.Object obj, string path)
+        {
+            if (!path.EndsWith(".asset"))
+                path += ".asset";
+
+            AssetDatabase.CreateAsset(obj, path);
+
+            AssetDatabase.SaveAssets();
+
+            EditorUtility.SetDirty(obj);
+        }
+
+        /// <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 (shellFolder == "")
+                {
+                    UnityEngine.Debug.LogWarning("Could not create folder. Canceling Initialization.");
+
+                    UnityEngine.Debug.Log("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 Directory.Exists(fullPath);
+        }
+    }
+}

package/ConvertUtility.cs.meta

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

package/DREditor.Editor.Utility.Converting.asmdef

@@ -0,0 +1,34 @@
+{
+    "name": "DREditor.Editor.Utility.Converting",
+    "rootNamespace": "",
+    "references": [
+        "Unity.RenderPipelines.Universal.Runtime",
+        "Unity.InputSystem",
+        "DREditor.Editor",
+        "DREditor",
+        "DREditor.Controls",
+        "DREditor.States",
+        "DREditor.Progressing.Handling",
+        "DREditor.DialogueMechanics.Investigation",
+        "DREditor.RoomStateBuilding",
+        "DREditor.RoomBuilding",
+        "DREditor.Actors",
+        "DREditor.Doors",
+        "DREditor.Talkables",
+        "DREditor.SubAreas",
+        "DREditor.Triggers",
+        "DREditor.DebugTesting",
+        "DREditor.UI"
+    ],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}

package/DREditor.Editor.Utility.Converting.asmdef.meta

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

package/MigrationUtility.cs

@@ -0,0 +1,129 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+#if UNITY_EDITOR
+using DREditor.UI.Buttons;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace DREditor.Editor.Utility.Converting
+{
+    /// <summary>
+    ///
+    /// </summary>
+    public static class MigrationUtility
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        static readonly string MonoscriptSearch = "t:MonoScript ";
+
+        /// <summary>
+        ///
+        /// </summary>
+        static readonly string PrefabSearch = "t:Prefab";
+
+        /// <summary>
+        ///
+        /// </summary>
+        static readonly string ScriptPropertyName = "m_Script";
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        [MenuItem("DREditor/Convert/Buttons/Migrate Buttons to DREButton")]
+        public static void MigrateButtons() => MigrateType<Button, DREButton>();
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <typeparam name="T2"></typeparam>
+        public static void MigrateType<T, T2>() where T : Object
+        {
+            if (FindTypeScript<T2>(out var childScript))
+            {
+                MigrateSceneObjects<T>(childScript);
+
+                MigratePrefabs<T>(childScript);
+
+                AssetDatabase.SaveAssets();
+            }
+            else
+                UnityEngine.Debug.LogError($"ALERT: {typeof(T2).Name} script not found in project.");
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="childScript"></param>
+        /// <returns></returns>
+        private static bool FindTypeScript<T>(out MonoScript childScript)
+        {
+            childScript = AssetDatabase.FindAssets(MonoscriptSearch + typeof(T).Name)
+                .Select(guid => AssetDatabase.LoadAssetAtPath<MonoScript>(AssetDatabase.GUIDToAssetPath(guid)))
+                .FirstOrDefault(s => s != null && s.GetClass() == typeof(T));
+
+            return childScript != null;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="childScript"></param>
+        private static void MigrateSceneObjects<T>(MonoScript childScript) where T : Object
+            => SwappedReferences(UnityEngine.Object.FindObjectsByType<T>(), childScript);
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="childScript"></param>
+        private static void MigratePrefabs<T>(MonoScript childScript) where T : Object
+        {
+            foreach (string guid in AssetDatabase.FindAssets(PrefabSearch))
+            {
+                string path = AssetDatabase.GUIDToAssetPath(guid);
+
+                GameObject prefab = PrefabUtility.LoadPrefabContents(path);
+
+                bool modified = SwappedReferences(prefab.GetComponentsInChildren<Button>(true), childScript);
+
+                if (modified)
+                    PrefabUtility.SaveAsPrefabAsset(prefab, path);
+
+                PrefabUtility.UnloadPrefabContents(prefab);
+            }
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="references"></param>
+        /// <param name="childScript"></param>
+        /// <returns></returns>
+        /// <remarks></remarks>
+        private static bool SwappedReferences<T>(IEnumerable<T> references, MonoScript childScript) where T : Object
+        {
+            bool modified = false;
+
+            foreach (T reference in references.Where(b => b.GetType() == typeof(T)))
+            {
+                SerializedObject serializedButton = new(reference);
+
+                serializedButton.FindProperty(ScriptPropertyName).objectReferenceValue = childScript;
+
+                serializedButton.ApplyModifiedPropertiesWithoutUndo();
+
+                modified = true;
+            }
+
+            return modified;
+        }
+    }
+}
+#endif

package/MigrationUtility.cs.meta

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

package/package.json

@@ -1,6 +1,53 @@
 {
   "name": "net.dreditor.editor.utility.converting",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.7",
+  "displayName": "DREditor Editor Utility Converting",
+  "description": "The beta for DREditor. A tool to create death game style projects without having to code.",
+  "unity": "6000.4",
+  "dependencies": {
+    "com.unity.render-pipelines.universal": "17.4.0",
+    "com.unity.inputsystem": "1.19.0",
+    "net.dreditor.core": "0.1.7",
+    "net.dreditor.states": "0.1.7",
+    "net.dreditor.progressing.handling": "0.1.7",
+    "net.dreditor.dialoguemechanics.investigation": "0.1.7",
+    "net.dreditor.roomstatebuilding": "0.1.7",
+    "net.dreditor.roombuilding": "0.1.7",
+    "net.dreditor.actors": "0.1.7",
+    "net.dreditor.doors": "0.1.7",
+    "net.dreditor.talkables": "0.1.7",
+    "net.dreditor.subareas": "0.1.7",
+    "net.dreditor.triggers": "0.1.7",
+    "net.dreditor.debugtesting": "0.1.7",
+    "net.dreditor.ui": "0.1.7"
+  },
+  "keywords": [
+    "editor",
+    "tool",
+    "dreditor"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "author": {
+    "name": "Benjamin \"Sweden\" Jillson",
+    "email": "dreditortool@gmail.com",
+    "url": "https://dreditor.net"
+  },
+  "samples": [
+    {
+      "displayName": "Samples",
+      "description": "",
+      "path": "Samples~"
+    }
+  ],
+  "documentationUrl": "https://dreditor.net",
+  "license": "Apache-2.0",
+  "licensesUrl": "https://dreditor.net/docs/LICENSE.html",
+  "changelogUrl": "https://dreditor.net/docs/CHANGELOG.html",
+  "repository": {
+    "url": "https://github.com/CertifiedSharp/DREditor",
+    "type": "git",
+    "revision": "14ca252fbb33eb6f53557ecaed1c10902877698f"
+  }
+}

package/package.json.meta

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

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.