Additional Support & APIs

CHANGELOG.md

@@ -4,6 +4,15 @@ All package updates & migration steps will be listed in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [4.5.0] - 2025-03-18
+### Added
+- `InfoExists` and `HasAssignedValue` getters added to the `ParameterReference<T>`
+- Support for `AssetReferenceGameObject`
+- Versioning for code gen.
+- Support to pass in infos to the `Error` and `Warn` methods in validators.
+### Fixed
+- Unclear error message when trying to set an incorrect scriptable object by name in a csv.
+
 ## [4.4.0] - 2025-03-11
 ### Added
 - Support for circular references of structs if using a `IReadOnlyList`

Editor/Common/PropertyTypes/AssetReferenceGameObjectListPropertyType.cs

@@ -0,0 +1,16 @@
+#if ADDRESSABLE_PARAMS
+using System.Reflection;
+using UnityEngine.AddressableAssets;
+
+namespace PocketGems.Parameters.Common.PropertyTypes.Editor
+{
+    internal class AssetReferenceGameObjectListPropertyType : AssetReferenceListPropertyType
+    {
+        public AssetReferenceGameObjectListPropertyType(PropertyInfo propertyInfo) : base(propertyInfo)
+        {
+        }
+
+        protected override string ClassName => nameof(AssetReferenceGameObject);
+    }
+}
+#endif

Editor/Common/PropertyTypes/AssetReferenceGameObjectPropertyType.cs

@@ -0,0 +1,16 @@
+#if ADDRESSABLE_PARAMS
+using System.Reflection;
+using UnityEngine.AddressableAssets;
+
+namespace PocketGems.Parameters.Common.PropertyTypes.Editor
+{
+    internal class AssetReferenceGameObjectPropertyType : AssetReferencePropertyType
+    {
+        public AssetReferenceGameObjectPropertyType(PropertyInfo propertyInfo) : base(propertyInfo)
+        {
+        }
+
+        protected override string ClassName => nameof(AssetReferenceGameObject);
+    }
+}
+#endif

Editor/Common/PropertyTypes/PropertyTypeFactory.cs

@@ -136,6 +136,10 @@ public static IPropertyType Create(IParameterInterface parameterInterface, Prope
                 return new AssetReferencePropertyType(propertyInfo);
             if (propertyType == typeof(IReadOnlyList<AssetReference>))
                 return new AssetReferenceListPropertyType(propertyInfo);
+            if (propertyType == typeof(AssetReferenceGameObject))
+                return new AssetReferenceGameObjectPropertyType(propertyInfo);
+            if (propertyType == typeof(IReadOnlyList<AssetReferenceGameObject>))
+                return new AssetReferenceGameObjectListPropertyType(propertyInfo);
             if (propertyType == typeof(AssetReferenceSprite))
                 return new AssetReferenceSpritePropertyType(propertyInfo);
             if (propertyType == typeof(IReadOnlyList<AssetReferenceSprite>))

README/InterfacesAndEnums.md

@@ -245,9 +245,11 @@ IReadOnlyList<ParameterStructReference<ITransactionStruct>> Rewards { get; }
 Addressable asset & sprite references are supported if the [`com.unity.addressables`](https://docs.unity3d.com/Packages/com.unity.addressables@latest/index.html) package is added to the Unity project.
 ```C#
 AssetReference WorldItemPrefab { get; }
+AssetReferenceGameObject Node { get; }
 AssetReferenceSprite Icon { get; }
 AssetReferenceAtlasedSprite Image { get; }
 IReadOnlyList<AssetReference> Doobers { get; }
+IReadOnlyList<AssetReferenceGameObject> Nodes { get; }
 IReadOnlyList<AssetReferenceSprite> LoadingImages { get; }
 IReadOnlyList<AssetReferenceAtlasedSprite> Images { get; }
 ```

Runtime/LocalCSV/CSVValueConverter.cs

@@ -248,7 +248,7 @@ public static ParameterReference<T> FromString<T>(string value)
                 if (ScriptableObjectLookupCache.Enabled)
                 {
                     var data = ScriptableObjectLookupCache.LookUp(value);
-                    for (int i = 0; i < data.Count; i++)
+                    for (int i = 0; i < data?.Count; i++)
                     {
                         var path = data[i].Item2;
                         var asset = AssetDatabase.LoadAssetAtPath<ScriptableObject>(path);

Runtime/LocalCSV/CSVValueConverter_Addressable.cs

@@ -60,6 +60,24 @@ public static UnityEngine.AddressableAssets.AssetReference FromString(string val
             }
         }
 
+        public static class AssetReferenceGameObject
+        {
+            public static string ToString(UnityEngine.AddressableAssets.AssetReferenceGameObject value)
+            {
+                return AssetReference.ToString(value);
+            }
+
+            public static UnityEngine.AddressableAssets.AssetReferenceGameObject FromString(string value,
+                bool validateGuid = false)
+            {
+                (string guid, string subObjectName) = AssetReference.ParseString(value, validateGuid);
+                var reference = new UnityEngine.AddressableAssets.AssetReferenceGameObject(guid);
+                if (subObjectName != null)
+                    reference.SubObjectName = subObjectName;
+                return reference;
+            }
+        }
+
         public static class AssetReferenceSprite
         {
             public static string ToString(UnityEngine.AddressableAssets.AssetReferenceSprite value)
@@ -120,6 +138,32 @@ public static UnityEngine.AddressableAssets.AssetReference[] FromString(string v
             }
         }
 
+        public static class AssetReferenceGameObjectArray
+        {
+            public static string ToString(UnityEngine.AddressableAssets.AssetReferenceGameObject[] value)
+            {
+                if (value == null)
+                    return "";
+                var guids = new string[value.Length];
+                for (int i = 0; i < value.Length; i++)
+                    guids[i] = AssetReferenceGameObject.ToString(value[i]);
+                return string.Join(ListDelimiter.ToString(), guids);
+            }
+
+            public static UnityEngine.AddressableAssets.AssetReferenceGameObject[] FromString(string value,
+                bool validateGuid = false)
+            {
+                // must return a non null value so we can detect overriding of properties by checking non null
+                if (string.IsNullOrWhiteSpace(value))
+                    return Array.Empty<UnityEngine.AddressableAssets.AssetReferenceGameObject>();
+                var guids = value.Split(ListDelimiter);
+                var assetRefs = new UnityEngine.AddressableAssets.AssetReferenceGameObject[guids.Length];
+                for (int i = 0; i < guids.Length; i++)
+                    assetRefs[i] = AssetReferenceGameObject.FromString(guids[i], validateGuid);
+                return assetRefs;
+            }
+        }
+
         public static class AssetReferenceSpriteArray
         {
             public static string ToString(UnityEngine.AddressableAssets.AssetReferenceSprite[] value)

Runtime/ParameterReference.cs

@@ -12,13 +12,16 @@ namespace PocketGems.Parameters
     public abstract class ParameterReference
     {
         [SerializeField] protected string guid;
+        [NonSerialized] protected string _identifier;
 
         /// <summary>
-        ///  Identifier is only set at runtime (abtesting) and not serialized in the editor.
+        /// The assigned guid that is set typically from in the editor or when loaded from the parameter manager.
         /// </summary>
-        [NonSerialized] protected string _identifier;
-
         public string AssignedGUID => guid;
+
+        /// <summary>
+        ///  Identifier is only set at runtime (abtesting) and not serialized in the editor.
+        /// </summary>
         public string AssignedIdentifier => _identifier;
 
         /// <summary>
@@ -82,6 +85,9 @@ public int CompareTo(ParameterReference<T> other)
             return string.Compare(info.Identifier, otherInfo.Identifier);
         }
 
+        /// <summary>
+        /// A getter return the parameter info.  Null if it doesn't exist.
+        /// </summary>
         public T Info
         {
             get
@@ -104,6 +110,26 @@ public T Info
             }
         }
 
+        /// <summary>
+        /// Returns true if an info exists for the reference.
+        ///
+        /// A ParameterReference could have HasAssignedValue be true but InfoExists return false.
+        /// This could happen if the assigned guid/identifier doesn't exist in the ParameterManager
+        /// due to an incorrect assignment (validation wasn't ran or the identifier was assigned at
+        /// runtime and incorrect).
+        /// </summary>
+        public bool InfoExists => Info != null;
+
+        /// <summary>
+        /// True if this reference has been assigned a guid/identifier that might exist.
+        ///
+        /// A ParameterReference could have HasAssignedValue be true but InfoExists return false.
+        /// This could happen if the assigned guid/identifier doesn't exist in the ParameterManager
+        /// due to an incorrect assignment (validation wasn't ran or the identifier was assigned at
+        /// runtime and incorrect).
+        /// </summary>
+        public bool HasAssignedValue => !string.IsNullOrWhiteSpace(guid) || !string.IsNullOrWhiteSpace(_identifier);
+
         internal T GetInfo(IParameterManager parameterManager)
         {
             // parameterManager.GetWithGUID will throw a LogError if it doesn't exist since

Runtime/Validation/BaseDataValidator.cs

@@ -29,6 +29,18 @@ public abstract class BaseDataValidator<T> : ITypedDataValidator<T> where T : cl
         /// <param name="parameterManager">parameter manager to query if needed during validation</param>
         protected abstract void ValidateParameters(IParameterManager parameterManager);
 
+        /// <summary>
+        /// Log an error during validation.
+        /// </summary>
+        /// <param name="info">the info with the issue</param>
+        /// <param name="propertyName">property name with the error</param>
+        /// <param name="message">user facing message about the error</param>
+        protected void Error(T info, string propertyName, string message)
+        {
+            var error = new ValidationError(typeof(T), info.Identifier, propertyName, message);
+            _errors.Add(error);
+        }
+
         /// <summary>
         /// Log an error during validation.
         /// </summary>
@@ -40,6 +52,17 @@ protected void Error(string propertyName, string message)
             _errors.Add(error);
         }
 
+        /// <summary>
+        /// Log an error during validation.
+        /// </summary>
+        /// <param name="info">the info with the issue</param>
+        /// <param name="message">user facing message about the error</param>
+        protected void Error(T info, string message)
+        {
+            var error = new ValidationError(typeof(T), info.Identifier, null, message);
+            _errors.Add(error);
+        }
+
         /// <summary>
         /// General error during validation.
         /// </summary>
@@ -50,6 +73,19 @@ protected void Error(string message)
             _errors.Add(error);
         }
 
+        /// <summary>
+        /// Log a warning during validation.
+        /// </summary>
+        /// <param name="info">the info with the issue</param>
+        /// <param name="propertyName">property name with the warning</param>
+        /// <param name="message">user facing message about the warning</param>
+        protected void Warn(T info, string propertyName, string message)
+        {
+            var error = new ValidationError(typeof(T), info.Identifier, propertyName, message,
+                severity: ValidationError.Severity.Warning);
+            _errors.Add(error);
+        }
+
         /// <summary>
         /// Log a warning during validation.
         /// </summary>
@@ -62,6 +98,18 @@ protected void Warn(string propertyName, string message)
             _errors.Add(error);
         }
 
+        /// <summary>
+        /// General warning during validation.
+        /// </summary>
+        /// <param name="info">the info with the issue</param>
+        /// <param name="message">user facing message about the warning</param>
+        protected void Warn(T info, string message)
+        {
+            var error = new ValidationError(typeof(T), info.Identifier, null, message,
+                severity: ValidationError.Severity.Warning);
+            _errors.Add(error);
+        }
+
         /// <summary>
         /// General warning during validation.
         /// </summary>

Tests/Editor/Common/PropertyTypes/PropertyTypesTest.cs

@@ -86,9 +86,11 @@ private interface ITestInfo : IBaseInfo
 
 #if ADDRESSABLE_PARAMS
             AssetReference MyAsset { get; }
+            AssetReferenceGameObject MyGameObject { get; }
             AssetReferenceSprite MyAssetSprite { get; }
             AssetReferenceAtlasedSprite MyAssetAltasdSprite { get; }
             IReadOnlyList<AssetReference> MyAssets { get; }
+            IReadOnlyList<AssetReferenceGameObject> MyGameObjects { get; }
             IReadOnlyList<AssetReferenceSprite> MyAssetSprites { get; }
             IReadOnlyList<AssetReferenceAtlasedSprite> MyAssetAltasdSprites { get; }
 #endif
@@ -228,9 +230,11 @@ public void ValidateIdentifier()
         [TestCase(nameof(ITestInfo.MyStructs))]
 #if ADDRESSABLE_PARAMS
         [TestCase(nameof(ITestInfo.MyAsset))]
+        [TestCase(nameof(ITestInfo.MyGameObject))]
         [TestCase(nameof(ITestInfo.MyAssetSprite))]
         [TestCase(nameof(ITestInfo.MyAssetAltasdSprite))]
         [TestCase(nameof(ITestInfo.MyAssets))]
+        [TestCase(nameof(ITestInfo.MyGameObjects))]
         [TestCase(nameof(ITestInfo.MyAssetSprites))]
         [TestCase(nameof(ITestInfo.MyAssetAltasdSprites))]
 #endif