feat: link to datanodes runtime serialization

Author: Tr0sT

Packages/com.nuclearband.sodatabase/Editor/ScriptableObjectDatabaseEditorWindow.cs

@@ -6,7 +6,6 @@
 using System.Linq;
 using System.Reflection;
 using Newtonsoft.Json;
-using Newtonsoft.Json.Serialization;
 using Sirenix.OdinInspector.Editor;
 using Sirenix.Utilities;
 using Sirenix.Utilities.Editor;
@@ -24,11 +23,6 @@ private static void Open()
         {
             var window = GetWindow<ScriptableObjectDatabaseEditorWindow>();
             window.position = GUIHelper.GetEditorWindowRect().AlignCenter(800, 500);
-            window.OnClose += () =>
-            {
-                AssetDatabase.SaveAssets();
-                AssetDatabase.Refresh();
-            };
         }
 
         [MenuItem("Tools/NuclearBand/ScriptableObjectDatabase-ClearSave")]
@@ -51,15 +45,39 @@ private static async void ClearSave()
 
                 EditorUtility.SetDirty(model);
             }
+
             AssetDatabase.SaveAssets();
         }
-        
+
         [MenuItem("Tools/NuclearBand/ScriptableObjectDatabase-OpenSaveFolder")]
         private static void OpenSaveFolder()
         {
             EditorUtility.RevealInFinder(Application.persistentDataPath);
         }
 
+        [InitializeOnEnterPlayMode]
+        private static async void ResetOnPlay()
+        {
+            await SODatabase.InitAsync(null, null);
+            await SODatabase.LoadAsync();
+            var models = SODatabase.GetModels<DataNode>("", true);
+            foreach (var model in models)
+            {
+                var typeInfo = model.GetType().GetTypeInfo();
+                var fields = typeInfo.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
+                foreach (var field in fields)
+                {
+                    var attributes = field.GetCustomAttributes(typeof(ResetOnPlay), false);
+                    if (attributes.Length > 0)
+                        field.SetValue(model, default);
+                }
+
+                EditorUtility.SetDirty(model);
+            }
+
+            AssetDatabase.SaveAssets();
+        }
+
         protected override OdinMenuTree BuildMenuTree()
         {
             var tree = new OdinMenuTree(true)
@@ -98,7 +116,7 @@ private void SelectionChanged(SelectionChangedType obj)
                     throw new ArgumentOutOfRangeException(nameof(obj), obj, null);
             }
         }
-        
+
         void AddAllAssetsAtPath(
             OdinMenuTree tree,
             string assetFolderPath,
@@ -217,14 +235,45 @@ protected override void OnBeginDrawEditors()
                     AssetDatabase.CreateFolder(path, uniqName);
                     AssetDatabase.Refresh();
                 }
+
+                if (SirenixEditorGUI.ToolbarButton(new GUIContent("Save")))
+                    Save();
             }
             SirenixEditorGUI.EndHorizontalToolbar();
         }
 
+        private void Save()
+        {
+            Flatten(MenuTree.MenuItems).ForEach(item =>
+            {
+                if (!(item.Value is DataNodeHolder dataNodeHolder))
+                    return;
+                var fullPath = $"{(string.IsNullOrEmpty(dataNodeHolder.Path) ? string.Empty : $"{dataNodeHolder.Path}/")}{dataNodeHolder.DataNode.name}";
+                if (dataNodeHolder.DataNode.FullPath == fullPath)
+                    return;
+                dataNodeHolder.DataNode.SetFullPath(dataNodeHolder.Path);
+                EditorUtility.SetDirty(dataNodeHolder.DataNode);
+            });
+
+            AssetDatabase.SaveAssets();
+            AssetDatabase.Refresh();
+        }
+
+        static IEnumerable<OdinMenuItem> Flatten(List<OdinMenuItem> collection)
+        {
+            foreach (var o in collection)
+            {
+                foreach (var o1 in Flatten(o.ChildMenuItems))
+                    yield return o1;
+                
+                yield return o;
+            }
+        }
+
         private void AddDragHandles(OdinMenuItem menuItem)
         {
             menuItem.OnDrawItem += x => DragAndDropUtilities.DragZone(menuItem.Rect, (menuItem.Value as DataNodeHolder)!.DataNode, false, false);
         }
     }
 }
-#endif
+#endif

Packages/com.nuclearband.sodatabase/Runtime/DataNode.cs

@@ -1,23 +1,20 @@
 #nullable enable
-using System.Reflection;
 using Newtonsoft.Json;
 using Sirenix.OdinInspector;
+using UnityEngine;
 
 namespace NuclearBand
 {
-    [JsonObject(MemberSerialization.OptIn)]
+    [JsonObject(MemberSerialization.OptIn, IsReference = true)]
     public class DataNode : SerializedScriptableObject
     {
-        protected virtual void OnEnable()
-        {
-            var typeInfo = GetType().GetTypeInfo();
-            var fields = typeInfo.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
-            foreach (var field in fields)
-            {
-                var attributes = field.GetCustomAttributes(typeof(ResetOnPlay), false);
-                if (attributes.Length > 0)
-                    field.SetValue(this, default);
-            }
-        }
+        [SerializeField, HideInInspector]
+        private string fullPath = string.Empty;
+
+        public string FullPath => $"{(string.IsNullOrEmpty(fullPath) ? string.Empty : $"{fullPath}/")}{name}";
+
+#if UNITY_EDITOR
+        public void SetFullPath(string fullPath) => this.fullPath = fullPath;
+#endif
     }
-}
+}

Packages/com.nuclearband.sodatabase/Runtime/SODatabase.cs

@@ -17,6 +17,12 @@ public static class SODatabase
 
         private static FolderHolder root = null!;
 
+        private static JsonSerializerSettings jsonSerializerSettings => new JsonSerializerSettings
+        {
+            Formatting = Formatting.None,
+            ReferenceResolverProvider = () => new DataNodeReferenceResolver()
+        };
+
         public static async void Init(Action<float>? onProgress, Action? onComplete)
         {
             await InitAsync(onProgress, onComplete);
@@ -127,7 +133,8 @@ static Dictionary<string, string> SaveFolderHolder(FolderHolder folderHolder, st
                 var fullPath = dataNodePair.Key;
                 if (!string.IsNullOrEmpty(path))
                     fullPath = path + '/' + fullPath;
-                var json = JsonConvert.SerializeObject(dataNodePair.Value);
+                DataNodeReferenceResolver.CurrentDataNode = dataNodePair.Value;
+                var json = JsonConvert.SerializeObject(dataNodePair.Value, jsonSerializerSettings);
                 res.Add(fullPath, json);
             }
 
@@ -136,6 +143,7 @@ static Dictionary<string, string> SaveFolderHolder(FolderHolder folderHolder, st
                 var fullPath = folderHolderPair.Key;
                 if (!string.IsNullOrEmpty(path))
                     fullPath = path + '/' + fullPath;
+                
                 var resAdd = SaveFolderHolder(folderHolderPair.Value, fullPath);
                 resAdd.ForEach(x => res.Add(x.Key, x.Value));
             }
@@ -170,7 +178,8 @@ static void LoadFolderHolder(FolderHolder folderHolder, string path, Dictionary<
                 var json = data.ContainsKey(fullPath) ? data[fullPath] : string.Empty;
                 if (string.IsNullOrEmpty(json))
                     continue;
-                JsonConvert.PopulateObject(json, dataNodePair.Value);
+                DataNodeReferenceResolver.CurrentDataNode = dataNodePair.Value; 
+                JsonConvert.PopulateObject(json, dataNodePair.Value, jsonSerializerSettings);
             }
 
             foreach (var folderHolderPair in folderHolder.FolderHolders)

Packages/com.nuclearband.sodatabase/Runtime/SerializationUtilities.meta

@@ -0,0 +1,33 @@
+#nullable enable
+using System;
+using Newtonsoft.Json.Serialization;
+using NuclearBand;
+
+public class DataNodeReferenceResolver : IReferenceResolver
+{
+    public static DataNode CurrentDataNode = null!;
+    
+    public object ResolveReference(object context, string reference)
+    {
+        try
+        {
+            return SODatabase.GetModel<DataNode>(reference);
+        }
+        catch (Exception)
+        {
+            return null;
+        }
+    }
+
+    public string GetReference(object context, object value)
+    {
+        var dataNode = (DataNode) value;
+        return dataNode.FullPath;
+    }
+
+    public bool IsReferenced(object context, object value) => !ReferenceEquals(value, CurrentDataNode);
+
+    public void AddReference(object context, string reference, object value)
+    {
+    }
+}