Merge pull request #185 from brunomikoski/feature/fix-picker-not-respecting-inheritance

brunomikoski · web-flow · commit 1ea45db04a5e · 2025-12-04T17:29:19.000-03:00
Feature/fix picker not respecting inheritance
diff --git a/Scripts/Editor/Core/CodeGenerationUtility.cs b/Scripts/Editor/Core/CodeGenerationUtility.cs
@@ -7,6 +7,7 @@
 using UnityEditor.Compilation;
 using UnityEditorInternal;
 using UnityEngine;
+using Object = UnityEngine.Object;
 #if ADDRESSABLES_ENABLED
 using UnityEditor.AddressableAssets;
 using UnityEditor.AddressableAssets.Settings;
@@ -330,9 +331,28 @@ public static bool CheckIfCanBePartial(ScriptableObjectCollection collection, st
 
         public static void GenerateIndirectAccessForCollectionItemType(Type collectionItemType)
         {
-            string baseClassPath = AssetDatabase.GetAssetPath(MonoScript.FromScriptableObject(ScriptableObject.CreateInstance(collectionItemType)));
-            string parentFolder = Path.GetDirectoryName(baseClassPath);
-            GenerateIndirectAccessForCollectionItemType(collectionItemType.Name, collectionItemType.Namespace, parentFolder);
+            List<Type> targetTypes = new List<Type>();
+            foreach (Type t in TypeCache.GetTypesDerivedFrom(collectionItemType))
+            {
+                targetTypes.Add(t);
+            }
+
+            targetTypes.Add(collectionItemType);
+
+            foreach (Type type in targetTypes)
+            {
+                if (type == null)
+                    continue;
+                
+                if (!ScriptUtility.TryGetFolderOfClass(type, out string parentFolder))
+                {
+                    Debug.LogError($"Could not find the script path for the collection item type '{collectionItemType.FullName}', " +
+                                   $"cannot generate indirect access class.");
+                    continue;
+                }
+
+                GenerateIndirectAccessForCollectionItemType(type.Name, type.Namespace, parentFolder);
+            }
         }
 
         public static void GenerateIndirectAccessForCollectionItemType(string collectionName, string collectionNamespace,
@@ -377,6 +397,12 @@ public static void GenerateIndirectAccessForCollectionItemType(string collection
                 AppendLine(writer, indentation,
                     $"public {collectionName}IndirectReference({collectionName} collectionItemScriptableObject) : base(collectionItemScriptableObject) {{}}");
 
+                AppendLine(writer, indentation,
+                    $"public static implicit operator {collectionName}IndirectReference({collectionName} item) => item == null ? null : new {collectionName}IndirectReference(item);");
+
+                AppendLine(writer, indentation,
+                    $"public static implicit operator ScriptableObjectCollectionItem({collectionName}IndirectReference reference) => reference?.Ref;");
+
                 indentation--;
                 AppendFooter(writer, ref indentation, collectionNamespace);
             }
@@ -536,9 +562,19 @@ private static void WriteDirectAccessCollectionStatic(ScriptableObjectCollection
 
             AppendLine(writer, indentation);
 
+            Type itemType = collection.GetItemType();
+            bool writeAsPartial = SOCSettings.Instance.GetWriteAsPartialClass(collection);
+            bool hasBaseTypeCollection = false;
 
-            AppendLine(writer, indentation,
-                $"public static {collection.GetType().FullName} {PublicValuesName}");
+            if (itemType != null && itemType.BaseType != null)
+            {
+                List<ScriptableObjectCollection> baseCollections = CollectionsRegistry.Instance.GetCollectionsByItemType(itemType.BaseType);
+                hasBaseTypeCollection = baseCollections != null && baseCollections.Count > 0;
+            }
+
+            bool addNewModifier = writeAsPartial && hasBaseTypeCollection;
+
+            AppendLine(writer, indentation, $"public {(addNewModifier ? "new " : string.Empty)}static {collection.GetType().FullName} {PublicValuesName}");
             
             AppendLine(writer, indentation, "{");
             indentation++;
diff --git a/Scripts/Editor/CustomEditors/CollectionCustomEditor.cs b/Scripts/Editor/CustomEditors/CollectionCustomEditor.cs
@@ -304,7 +304,10 @@ private void OnKeyUpOnCollectionListView(KeyUpEvent evt)
         {
             if (currentRenamingLabel != null)
                 return;
-
+            
+            if (EditorGUIUtility.editingTextField)
+                return;
+            
             switch (evt.keyCode)
             {
                 case KeyCode.F2:
diff --git a/Scripts/Editor/Extensions/SerializedPropertyExtensions.cs b/Scripts/Editor/Extensions/SerializedPropertyExtensions.cs
@@ -98,7 +98,7 @@ public static void SetValue(this SerializedProperty serializedProperty, object v
                     serializedProperty.objectReferenceValue = (UnityEngine.Object)value;
                     break;
                 case SerializedPropertyType.LayerMask:
-                    serializedProperty.intValue = (LayerMask)value;
+                    serializedProperty.intValue = ((LayerMask)value).value;
                     break;
                 case SerializedPropertyType.Enum:
                     serializedProperty.intValue = (int)value;
@@ -158,6 +158,7 @@ public static void SetValue(this SerializedProperty serializedProperty, object v
                 case SerializedPropertyType.Generic:
                     serializedProperty.SetValueReflective(value);
                     break;
+                
                 default:
                     Debug.LogWarning(
                         $"Tried to copy value '{value}' from a template to an SOC item but apparently that's not supported.");
diff --git a/Scripts/Editor/Generators/CollectionGenerators.cs b/Scripts/Editor/Generators/CollectionGenerators.cs
@@ -289,6 +289,7 @@ private static void CopyFieldToSerializedProperty(
             }
             
             serializedProperty.SetValue(value);
+            serializedProperty.serializedObject.ApplyModifiedProperties();
         }
     }
 }
diff --git a/Scripts/Editor/PropertyDrawers/CollectionItemIndirectReferencePropertyDrawer.cs b/Scripts/Editor/PropertyDrawers/CollectionItemIndirectReferencePropertyDrawer.cs
@@ -17,8 +17,7 @@ public sealed class CollectionItemIndirectReferencePropertyDrawer : PropertyDraw
         
         private Type collectionItemType;
         private CollectionItemPropertyDrawer collectionItemPropertyDrawer;
-
-        private SerializedProperty drawingProperty;
+        
         private SerializedProperty itemGUIDValueASerializedProperty;
         private SerializedProperty itemGUIDValueBSerializedProperty;
         private SerializedProperty itemLastKnowNameSerializedProperty;
@@ -43,7 +42,6 @@ public override void OnGUI(Rect position, SerializedProperty property, GUIConten
             if (collectionItemPropertyDrawer == null) 
                 CreateCollectionItemPropertyDrawer(property);
 
-            drawingProperty = property;
             itemGUIDValueASerializedProperty = property.FindPropertyRelative(COLLECTION_ITEM_GUID_VALUE_A_PROPERTY_PATH);
             itemGUIDValueBSerializedProperty = property.FindPropertyRelative(COLLECTION_ITEM_GUID_VALUE_B_PROPERTY_PATH);
             itemLastKnowNameSerializedProperty = property.FindPropertyRelative(COLLECTION_ITEM_LAST_KNOW_NAME_PROPERTY_PATH);
@@ -66,41 +64,47 @@ public override void OnGUI(Rect position, SerializedProperty property, GUIConten
             {
                 collectionItemPropertyDrawer.DrawCollectionItemDrawer(ref position, property, collectionItem, label, item =>
                 {
-                    SetSerializedPropertyGUIDs(item);
-                    drawingProperty.serializedObject.ApplyModifiedProperties();
+                    var element = property.serializedObject.FindProperty(property.propertyPath);
+                    SetSerializedPropertyGUIDs(element, item);
+                    property.serializedObject.ApplyModifiedProperties();
                 });
                 return;
             }
 
             EditorGUI.PropertyField(position, property, label, true);
         }
 
-        private void SetSerializedPropertyGUIDs(ScriptableObject item)
+        private void SetSerializedPropertyGUIDs(SerializedProperty element, ScriptableObject item)
         {
+            SerializedProperty itemA = element.FindPropertyRelative(COLLECTION_ITEM_GUID_VALUE_A_PROPERTY_PATH);
+            SerializedProperty itemB = element.FindPropertyRelative(COLLECTION_ITEM_GUID_VALUE_B_PROPERTY_PATH);
+            SerializedProperty itemName = element.FindPropertyRelative(COLLECTION_ITEM_LAST_KNOW_NAME_PROPERTY_PATH);
+            SerializedProperty colA = element.FindPropertyRelative(COLLECTION_GUID_VALUE_A_PROPERTY_PATH);
+            SerializedProperty colB = element.FindPropertyRelative(COLLECTION_GUID_VALUE_B_PROPERTY_PATH);
+            SerializedProperty colName = element.FindPropertyRelative(COLLECTION_LAST_KNOW_NAME_PROPERTY_PATH);
+
             if (item == null)
             {
-                itemGUIDValueASerializedProperty.longValue = 0;
-                itemGUIDValueBSerializedProperty.longValue = 0;
-                collectionGUIDValueASerializedProperty.longValue = 0;
-                collectionGUIDValueBSerializedProperty.longValue = 0;
-                itemLastKnowNameSerializedProperty.stringValue = string.Empty;
-                collectionLastKnowNameSerializedProperty.stringValue = string.Empty;
-
+                itemA.longValue = 0;
+                itemB.longValue = 0;
+                colA.longValue = 0;
+                colB.longValue = 0;
+                itemName.stringValue = string.Empty;
+                colName.stringValue = string.Empty;
+                return;
             }
-            else
+
+            if (item is ISOCItem socItem)
             {
-                if (item is ISOCItem socItem)
-                {
-                    (long, long) itemGUIDValues = socItem.GUID.GetRawValues();
-                    itemGUIDValueASerializedProperty.longValue = itemGUIDValues.Item1;
-                    itemGUIDValueBSerializedProperty.longValue = itemGUIDValues.Item2;
-                    itemLastKnowNameSerializedProperty.stringValue = socItem.name;
-
-                    (long, long) collectionGUIDValues = socItem.Collection.GUID.GetRawValues();
-                    collectionGUIDValueASerializedProperty.longValue = collectionGUIDValues.Item1;
-                    collectionGUIDValueBSerializedProperty.longValue = collectionGUIDValues.Item2;
-                    collectionLastKnowNameSerializedProperty.stringValue = socItem.Collection.name;
-                }
+                (long ia, long ib) = socItem.GUID.GetRawValues();
+                itemA.longValue = ia;
+                itemB.longValue = ib;
+                itemName.stringValue = socItem.name;
+
+                (long ca, long cb) = socItem.Collection.GUID.GetRawValues();
+                colA.longValue = ca;
+                colB.longValue = cb;
+                colName.stringValue = socItem.Collection.name;
             }
 
         }
@@ -152,4 +156,4 @@ private SOCItemEditorOptionsAttribute GetOptionsAttribute()
             return null;
         }
     }
-}
+}
diff --git a/Scripts/Editor/Utils/ScriptUtility.cs b/Scripts/Editor/Utils/ScriptUtility.cs
@@ -1,4 +1,5 @@
 using System;
+using System.IO;
 using UnityEditor;
 using UnityEngine;
 
@@ -9,20 +10,45 @@ namespace BrunoMikoski.ScriptableObjectCollections
     /// </summary>
     public static class ScriptUtility 
     {
+        public static bool TryGetFolderOfClass(Type classType, out string folderPath)
+        {
+            folderPath = null;
+
+            if (!TryGetScriptOfClass(classType, out MonoScript script))
+                return false;
+
+            string scriptPath = AssetDatabase.GetAssetPath(script);
+            if (string.IsNullOrEmpty(scriptPath))
+                return false;
+
+            folderPath = Path.GetDirectoryName(scriptPath);
+            return true;
+        }
+
         public static bool TryGetScriptOfClass(Type classType, out MonoScript script)
         {
             string[] scriptGuids = AssetDatabase.FindAssets($"t:script {classType.Name}");
             if (scriptGuids.Length == 0)
             {
                 Debug.LogWarning($"Could not find corresponding script for class '{classType.Name}'. " +
-                                 $"Check that the script is called '{classType.Name}'.");
+                                 $"Check that the script file name matches the class name.");
                 script = null;
                 return false;
             }
 
-            string scriptPath = AssetDatabase.GUIDToAssetPath(scriptGuids[0]);
-            script = AssetDatabase.LoadAssetAtPath<MonoScript>(scriptPath);
-            return true;
+            foreach (string guid in scriptGuids)
+            {
+                string path = AssetDatabase.GUIDToAssetPath(guid);
+                MonoScript candidate = AssetDatabase.LoadAssetAtPath<MonoScript>(path);
+                if (candidate != null && candidate.GetClass() == classType)
+                {
+                    script = candidate;
+                    return true;
+                }
+            }
+
+            script = null;
+            return false;
         }
     }
 }
diff --git a/Scripts/Runtime/Core/CollectionItemIndirectReference.cs b/Scripts/Runtime/Core/CollectionItemIndirectReference.cs
@@ -82,6 +82,21 @@ public TObject Ref
                 return cachedRef;
             }
         }
+        
+        public static implicit operator TObject(CollectionItemIndirectReference<TObject> reference)
+        {
+            return reference?.Ref;
+        }
+
+        public static implicit operator ScriptableObjectCollectionItem(CollectionItemIndirectReference<TObject> reference)
+        {
+            return reference?.Ref as ScriptableObjectCollectionItem;
+        }
+
+        public static implicit operator CollectionItemIndirectReference<TObject>(TObject item)
+        {
+            return item == null ? null : new CollectionItemIndirectReference<TObject>(item);
+        }
 
         private bool TryResolveReference(out TObject result)
         {
@@ -153,4 +168,4 @@ public void SetCollection(ScriptableObjectCollection targetCollection)
             collectionLastKnowName = targetCollection.name;
         }
     }
-}
+}
diff --git a/Scripts/Runtime/Core/CollectionItemQuery.cs b/Scripts/Runtime/Core/CollectionItemQuery.cs
diff --git a/Scripts/Runtime/Core/CollectionsRegistry.cs b/Scripts/Runtime/Core/CollectionsRegistry.cs

Original file line number	Diff line number	Diff line change
`@@ -304,7 +304,10 @@ private void OnKeyUpOnCollectionListView(KeyUpEvent evt)`
`304`	`304`	`{`
`305`	`305`	`if (currentRenamingLabel != null)`
`306`	`306`	`return;`
`307`		`-`
	`307`	`+`
	`308`	`+ if (EditorGUIUtility.editingTextField)`
	`309`	`+ return;`
	`310`	`+`
`308`	`311`	`switch (evt.keyCode)`
`309`	`312`	`{`
`310`	`313`	`case KeyCode.F2:`
Original file line number	Diff line number	Diff line change
`@@ -289,6 +289,7 @@ private static void CopyFieldToSerializedProperty(`
`289`	`289`	`}`
`290`	`290`
`291`	`291`	`serializedProperty.SetValue(value);`
	`292`	`+ serializedProperty.serializedObject.ApplyModifiedProperties();`
`292`	`293`	`}`
`293`	`294`	`}`
`294`	`295`	`}`
Original file line number	Diff line number	Diff line change
`@@ -82,6 +82,21 @@ public TObject Ref`
`82`	`82`	`return cachedRef;`
`83`	`83`	`}`
`84`	`84`	`}`
	`85`	`+`
	`86`	`+ public static implicit operator TObject(CollectionItemIndirectReference<TObject> reference)`
	`87`	`+ {`
	`88`	`+ return reference?.Ref;`
	`89`	`+ }`
	`90`	`+`
	`91`	`+ public static implicit operator ScriptableObjectCollectionItem(CollectionItemIndirectReference<TObject> reference)`
	`92`	`+ {`
	`93`	`+ return reference?.Ref as ScriptableObjectCollectionItem;`
	`94`	`+ }`
	`95`	`+`
	`96`	`+ public static implicit operator CollectionItemIndirectReference<TObject>(TObject item)`
	`97`	`+ {`
	`98`	`+ return item == null ? null : new CollectionItemIndirectReference<TObject>(item);`
	`99`	`+ }`
`85`	`100`
`86`	`101`	`private bool TryResolveReference(out TObject result)`
`87`	`102`	`{`
`@@ -153,4 +168,4 @@ public void SetCollection(ScriptableObjectCollection targetCollection)`
`153`	`168`	`collectionLastKnowName = targetCollection.name;`
`154`	`169`	`}`
`155`	`170`	`}`
`156`		`-}`
	`171`	`+}`