cz.xprees.variables 1.0.18 → 1.0.20

package/Runtime/Base/ReferenceBase.cs

@@ -5,9 +5,14 @@
 using System;
 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
     {
@@ -17,7 +22,37 @@ namespace Xprees.Variables.Base
         public T inlinedValue;
         public VariableBaseSO<T> variable;
 
-        public UnityAction<T> onValueChanged = delegate { };
+        // Internal event for inlined value changes, since VariableBaseSO already has its own onValueChanged event.
+        private UnityAction<T> _onInlinedValueChanged;
+
+        // ReSharper disable once InconsistentNaming
+        /// Event invoked when Value changes.
+        public event UnityAction<T> onValueChanged
+        {
+            add
+            {
+                var shouldRedirectToVarEvent = !useInlined && variable != null;
+                if (shouldRedirectToVarEvent)
+                {
+                    variable.onValueChanged += value;
+                    return;
+                }
+
+                _onInlinedValueChanged += value;
+            }
+
+            remove
+            {
+                var shouldRedirectToVarEvent = !useInlined && variable != null;
+                if (shouldRedirectToVarEvent)
+                {
+                    variable.onValueChanged -= value;
+                    return;
+                }
+
+                _onInlinedValueChanged -= value;
+            }
+        }
 
         public ReferenceBase()
         {
@@ -38,12 +73,12 @@ namespace Xprees.Variables.Base
                 if (useInlined)
                 {
                     inlinedValue = value;
-                    onValueChanged?.Invoke(value);
+                    _onInlinedValueChanged?.Invoke(value); // Invoke inlined value change event
                     return;
                 }
 
+                // VariableBaseSO will invoke its own onValueChanged event, so no need to invoke here.
                 variable.SetValue(value);
-                onValueChanged?.Invoke(value); // ignores that variable has its own onValueChanged
             }
         }
 
@@ -53,14 +88,14 @@ namespace Xprees.Variables.Base
         {
             if (!useInlined) return; // Variables does that by themselves
 
-            _defaultInlinedValue = inlinedValue;
+            _defaultInlinedValue = CloningTools.Clone(inlinedValue);
         }
 
         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.")]
@@ -64,7 +65,6 @@ namespace Xprees.Variables.Base
             ForceResetState();
         }
 
-        public override void ForceResetState() => CurrentValue = defaultValue;
-
+        public override void ForceResetState() => CurrentValue = CloningTools.Clone(defaultValue);
     }
 }

package/Runtime/Utils/CloningTools.cs

@@ -0,0 +1,119 @@
+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;
+
+            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;
+
+            // 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.18",
+  "version": "1.0.20",
   "unity": "2021.3",
   "description": "This package contains a system for creating variables based on ScriptableObjects in Editor.",
   "license": "Apache-2.0",