cz.xprees.variables 1.0.19 → 1.0.22

package/Runtime/Base/ReferenceBase.cs

@@ -3,20 +3,47 @@
 // ------------------------------------------------------------------------------------------------------
 
 using System;
+using UnityEngine;
 using UnityEngine.Events;
 using Xprees.Core;
+using Xprees.Variables.Utils;
 
 namespace Xprees.Variables.Base
 {
+    /// <summary>
+    /// Base class for all variable references used in the game. It can either use an inlined value or reference a VariableBaseSO Scriptable Object. The Value property abstracts this choice away, so users of ReferenceBase don't have to care about it.
+    /// </summary>
+    /// <typeparam name="T">Unity Serializable</typeparam>
     [Serializable]
-    public class ReferenceBase<T> : IResettable
+    public class ReferenceBase<T> : IResettable, ISerializationCallbackReceiver
     {
+        private bool _hasCapturedBaseline; // Used to check if baseline has been captured
         private T _defaultInlinedValue; // Used to reset state of inlined value
 
         public bool useInlined = true;
         public T inlinedValue;
         public VariableBaseSO<T> variable;
 
+        public void OnBeforeSerialize()
+        {
+        }
+
+        public void OnAfterDeserialize()
+        {
+            if (!PlayModeStateTracker.IsPlaying)
+            {
+                _defaultInlinedValue = CloningTools.Clone(inlinedValue);
+                _hasCapturedBaseline = false;
+                return;
+            }
+
+            if (!_hasCapturedBaseline)
+            {
+                _defaultInlinedValue = CloningTools.Clone(inlinedValue);
+                _hasCapturedBaseline = true;
+            }
+        }
+
         // Internal event for inlined value changes, since VariableBaseSO already has its own onValueChanged event.
         private UnityAction<T> _onInlinedValueChanged;
 
@@ -26,7 +53,7 @@ namespace Xprees.Variables.Base
         {
             add
             {
-                var shouldRedirectToVarEvent = !useInlined && variable != null;
+                var shouldRedirectToVarEvent = !useInlined && variable;
                 if (shouldRedirectToVarEvent)
                 {
                     variable.onValueChanged += value;
@@ -38,7 +65,7 @@ namespace Xprees.Variables.Base
 
             remove
             {
-                var shouldRedirectToVarEvent = !useInlined && variable != null;
+                var shouldRedirectToVarEvent = !useInlined && variable;
                 if (shouldRedirectToVarEvent)
                 {
                     variable.onValueChanged -= value;
@@ -58,6 +85,7 @@ namespace Xprees.Variables.Base
             useInlined = true;
             inlinedValue = value;
             _defaultInlinedValue = value;
+            _hasCapturedBaseline = true;
         }
 
         public T Value
@@ -83,14 +111,15 @@ namespace Xprees.Variables.Base
         {
             if (!useInlined) return; // Variables does that by themselves
 
-            _defaultInlinedValue = inlinedValue;
+            _defaultInlinedValue = CloningTools.Clone(inlinedValue);
+            _hasCapturedBaseline = true;
         }
 
         public virtual void ResetState()
         {
             if (useInlined)
             {
-                inlinedValue = _defaultInlinedValue;
+                inlinedValue = CloningTools.Clone(_defaultInlinedValue);
                 return;
             }
 

package/Runtime/Base/VariableBaseSO.cs

@@ -1,6 +1,7 @@
 using UnityEngine;
 using UnityEngine.Events;
 using Xprees.Core;
+using Xprees.Variables.Utils;
 
 namespace Xprees.Variables.Base
 {
@@ -22,7 +23,7 @@ namespace Xprees.Variables.Base
     /// Base class for all variables ScriptableObjects.
     /// Object holds the state on runtime, but reset every time OnEnable to defaultValue.
     /// </summary>
-    /// <typeparam name="T">Unity Serializable</typeparam>
+    /// <typeparam name="T">Unity Serializable or System.Serializable</typeparam>
     public class VariableBaseSO<T> : VariableBaseSO
     {
         [Tooltip("Value to which the variable will be reset on OnEnable or ResetState call.")]
@@ -42,6 +43,13 @@ namespace Xprees.Variables.Base
             get => currentValue;
             set
             {
+#if UNITY_EDITOR
+                // If not already captured in Editor capture before changing the value
+                if (PlayModeStateTracker.IsPlaying)
+                {
+                    StateSnapshotService.EnsureCaptured(this);
+                }
+#endif
                 currentValue = value;
                 onValueChanged?.Invoke(value);
             }
@@ -64,7 +72,6 @@ namespace Xprees.Variables.Base
             ForceResetState();
         }
 
-        public override void ForceResetState() => CurrentValue = defaultValue;
-
+        public override void ForceResetState() => CurrentValue = CloningTools.Clone(defaultValue);
     }
 }

package/Runtime/Base/VariableModifierBaseSO.cs

@@ -38,9 +38,14 @@ namespace Xprees.Variables.Base
 
         public override void ResetState()
         {
-            base.ResetState();
-            variable?.ResetState();
+            if (protectedDontReset) return;
+            ForceResetState();
+        }
+
+        public override void ForceResetState()
+        {
             disableWrite?.ResetState();
+            variable?.ResetState();
         }
     }
 }

package/Runtime/Utils/CloningTools.cs

@@ -0,0 +1,129 @@
+using System;
+using System.Collections;
+using System.Runtime.CompilerServices;
+using UnityEngine;
+using UnityEngine.Scripting;
+using Object = UnityEngine.Object;
+
+namespace Xprees.Variables.Utils
+{
+    public static class CloningTools
+    {
+        /// <summary>
+        /// Helper to clone a value of type T. It handles value types, reference types that implement ICloneable, and other reference types by serializing and deserializing them using Unity's JsonUtility. Note that the serialization approach only works for types that are compatible with JsonUtility (e.g., they must be Unity serializable). For more complex types, you might need to implement custom cloning logic or use a different serialization method.
+        /// </summary>
+        /// <param name="value">Value to clone</param>
+        /// <typeparam name="T">primitive/value type/Unity serializable</typeparam>
+        /// <returns>A clone of input value</returns>
+        [Preserve]
+        public static T Clone<T>(T value)
+        {
+            if (value == null) return default;
+
+            // Value types can be returned directly since they are copied by value. However, we can optimize for value types that do not contain references to avoid unnecessary cloning.
+            var canReturnAsIs = typeof(T).IsValueType && !RuntimeHelpers.IsReferenceOrContainsReferences<T>();
+            if (canReturnAsIs) return value;
+
+            // Strings are immutable in .NET, so return directly without JsonUtility
+            if (typeof(T) == typeof(string)) return value;
+
+            // UnityEngine.Object references (ScriptableObjects, MonoBehaviours, Assets, GameObjects)
+            // are reference-assigned; we must not deep-clone or call CreateInstance during serialization.
+            if (typeof(Object).IsAssignableFrom(typeof(T)) || value is Object) return value;
+
+            if (value is ICloneable cloneable) return (T) cloneable.Clone();
+
+            // Handle collections (List<T>, arrays, etc.) - JsonUtility doesn't support them directly
+            if (value is IList sourceList)
+            {
+                var listType = value.GetType();
+                if (listType.IsArray)
+                {
+                    var elementType = listType.GetElementType();
+                    var array = Array.CreateInstance(elementType!, sourceList.Count);
+                    for (var i = 0; i < sourceList.Count; i++)
+                    {
+                        var clonedItem = CloneItem(sourceList[i]);
+                        array.SetValue(clonedItem, i);
+                    }
+
+                    return (T) (object) array;
+                }
+
+                var clonedList = (IList) Activator.CreateInstance(listType);
+                foreach (var item in sourceList)
+                {
+                    clonedList.Add(CloneItem(item));
+                }
+
+                return (T) clonedList;
+            }
+
+            // For other types, we can try to serialize and deserialize to create a deep clone.
+            // JsonUtility only supports a subset of types. Guard against unsupported types and failed serialization.
+            var type = typeof(T);
+
+            // Allow UnityEngine.Object subclasses, or types explicitly marked as [Serializable].
+            var isUnityObject = typeof(Object).IsAssignableFrom(type);
+            var isSerializable = Attribute.IsDefined(type, typeof(SerializableAttribute));
+            if (!isUnityObject && !isSerializable)
+            {
+                throw new InvalidOperationException(
+                    $"Type '{type.FullName}' is not supported for JsonUtility-based cloning. " +
+                    "Ensure the type is Unity-serializable (e.g., marked with [Serializable]) or implements ICloneable.");
+            }
+
+            try
+            {
+                var json = JsonUtility.ToJson(value);
+                if (string.IsNullOrEmpty(json) || json == "{}" || json == "null")
+                {
+                    throw new InvalidOperationException(
+                        $"JsonUtility failed to serialize an instance of type '{type.FullName}' " +
+                        "for cloning. The resulting clone would be incomplete or empty.");
+                }
+
+                return JsonUtility.FromJson<T>(json);
+            }
+            catch (Exception ex) when (ex is not InvalidOperationException)
+            {
+                throw new InvalidOperationException(
+                    $"AOT/IL2CPP error cloning type '{type.FullName}'. " +
+                    "Ensure the type is preserved and AOT-compatible.", ex);
+            }
+        }
+
+        /// Helper to clone individual items in collections, using the same logic as the main Clone method.
+        private static object CloneItem(object item)
+        {
+            if (item == null) return null;
+
+            var itemType = item.GetType();
+
+            // Value types are copied by value
+            if (itemType.IsValueType) return item;
+
+            // Strings are immutable
+            if (item is string) return item;
+
+            // ICloneable
+            if (item is ICloneable cloneable) return cloneable.Clone();
+
+            // UnityEngine.Object - return reference (can't deep clone ScriptableObjects easily)
+            if (item is Object) return item;
+
+            // Try JSON serialization for other serializable types
+            if (Attribute.IsDefined(itemType, typeof(SerializableAttribute)))
+            {
+                var json = JsonUtility.ToJson(item);
+                if (!string.IsNullOrEmpty(json) && json != "{}" && json != "null")
+                {
+                    return JsonUtility.FromJson(json, itemType);
+                }
+            }
+
+            // Fallback: return the same reference
+            return item;
+        }
+    }
+}

package/Runtime/Utils/CloningTools.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: c9c3981f4d224c10860d1627fb51bd33
+timeCreated: 1770985135

package/Runtime/Utils.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: cd80394a0cb2475ca81f67dcd7bb38d8
+timeCreated: 1770985115

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "cz.xprees.variables",
   "displayName": "Variables",
-  "version": "1.0.19",
+  "version": "1.0.22",
   "unity": "2021.3",
   "description": "This package contains a system for creating variables based on ScriptableObjects in Editor.",
   "license": "Apache-2.0",