Merge pull request #41 from brunomikoski/feature/ui-manager-features

brunomikoski · web-flow · commit 8f5ee34a9698 · 2020-10-14T22:06:48.000+01:00
Feature/ui manager features
diff --git a/CHANGELOG.MD b/CHANGELOG.MD
@@ -4,6 +4,16 @@ All notable changes to this project will be documented 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).
 
+## [1.2.9]
+### Changed
+ - Fixed issue with the Foldout issue, now showing multiple inherited collectables should work fine
+ - Improved the ADD New on the collection and what is displayed, and the the creation of new types is on a subfolder.
+ - Added static access to the `ScriptableObjectCollection<>.Values`
+ - Renamed the generated Static value back to the `.Values` to keep in line with the static access. so you can now access by `Collection.Values` or `Collectable.Values`
+ 
+### Added
+ - Support to create Collections / Collectables based on a Utils script, useful for another packages creating the necessary Collection.
+ 
 ## [1.2.8]
 ### Changed
  - Fixed issue when trying to create a new type from abstract using the new Collectable editor.
@@ -143,9 +153,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
  - First initial working version 
 
 ### [Unreleased]
- - Proper setup for automatic creation of necessary collections 
 
-[1.2.7]: https://github.com/badawe/ScriptableObjectCollection/releases/tag/v1.2.8
+[1.2.9]: https://github.com/badawe/ScriptableObjectCollection/releases/tag/v1.2.9
+[1.2.8]: https://github.com/badawe/ScriptableObjectCollection/releases/tag/v1.2.8
 [1.2.7]: https://github.com/badawe/ScriptableObjectCollection/releases/tag/v1.2.7
 [1.2.6]: https://github.com/badawe/ScriptableObjectCollection/releases/tag/v1.2.6
 [1.2.5]: https://github.com/badawe/ScriptableObjectCollection/releases/tag/v1.2.5
diff --git a/Scripts/Editor/CollectableScriptableObjectPropertyDrawer.cs b/Scripts/Editor/CollectableScriptableObjectPropertyDrawer.cs
@@ -33,8 +33,7 @@ private CollectableEditorOptionsAttribute optionsAttribute
         private GUIContent[] GUIContents;
         
         private CollectableScriptableObject collectableItem;
-
-        private Object foldoutObject;
+        private Object currentObject;
 
         ~CollectableScriptableObjectPropertyDrawer()
         {
@@ -104,7 +103,7 @@ public override void OnGUI(Rect position, SerializedProperty property, GUIConten
 
                 if (collectableItem != null)
                 {
-                    if (CollectionUtility.IsFoldoutOpen(foldoutObject))
+                    if (CollectionUtility.IsFoldoutOpen(collectableItem, currentObject))
                     {
                         EditorGUI.indentLevel++;
                         using (new EditorGUILayout.VerticalScope("Box"))
@@ -162,7 +161,7 @@ private void Initialize(SerializedProperty property)
             optionsNames = displayOptions.ToArray();
             GUIContents = optionsNames.Select(s => new GUIContent(s)).ToArray();
 
-            foldoutObject = property.serializedObject.targetObject;
+            currentObject = property.serializedObject.targetObject;
             initialized = true;
         }
 
@@ -212,12 +211,12 @@ private void DrawEditFoldoutButton(ref Rect popupRect)
             buttonRect.x += popupRect.width;
 
             GUIContent guiContent = CollectionEditorGUI.EditGUIContent;
-            if (CollectionUtility.IsFoldoutOpen(foldoutObject))
+            if (CollectionUtility.IsFoldoutOpen(collectableItem, currentObject))
                 guiContent = CollectionEditorGUI.CloseGUIContent;
 
             if (GUI.Button(buttonRect, guiContent))
             {
-                CollectionUtility.SetFoldoutOpen(foldoutObject, !CollectionUtility.IsFoldoutOpen(foldoutObject));
+                CollectionUtility.SetFoldoutOpen(!CollectionUtility.IsFoldoutOpen(collectableItem, currentObject), collectableItem, currentObject);
                 ObjectUtility.SetDirty(collectableItem);
             }
         }
diff --git a/Scripts/Editor/CreateCollectionWizzard.cs b/Scripts/Editor/CreateCollectionWizzard.cs
@@ -215,7 +215,8 @@ private void CreateNewCollection()
                 CreateIndirectAccess();
             WaitingRecompileForContinue = true;
 
-            LastCollectionScriptableObjectPath = CreateCollectionObject();
+            ScriptableObjectCollection instance = ScriptableObjectCollectionUtils.CreateScriptableObjectOfType<ScriptableObjectCollection>(ScriptableObjectFolder, createFoldForThisCollection, collectionName);
+            LastCollectionScriptableObjectPath = AssetDatabase.GetAssetPath(instance);
             AssetDatabase.SaveAssets();
             AssetDatabase.Refresh();
 
@@ -262,22 +263,6 @@ private void CreateIndirectAccess()
             }
         }
 
-        private string CreateCollectionObject()
-        {
-            ScriptableObjectCollection targetCollection = CreateInstance<ScriptableObjectCollection>();
-            targetCollection.name = collectionName;
-
-            string targetFolderPath = AssetDatabase.GetAssetPath(ScriptableObjectFolder);
-            if (createFoldForThisCollection)
-                targetFolderPath = Path.Combine(targetFolderPath, $"{collectionName}");
-            
-            AssetDatabaseUtils.CreatePathIfDontExist(Path.Combine(targetFolderPath, "Items"));
-
-            string collectionAssetPath = Path.Combine(targetFolderPath, $"{collectionName}.asset");
-            AssetDatabase.CreateAsset(targetCollection, collectionAssetPath);
-            return collectionAssetPath;
-        }
-
         private bool CreateCollectableScript()
         {
             string folder = AssetDatabase.GetAssetPath(ScriptsFolder);
diff --git a/Scripts/Editor/ScriptableObjectCollectionCustomEditor.cs b/Scripts/Editor/ScriptableObjectCollectionCustomEditor.cs
@@ -150,6 +150,9 @@ private void UpdateFilteredItemList()
 
             for (int i = 0; i < filteredItemList.Count; i++)
             {
+                if (filteredItemList[i] == null)
+                    continue;
+                
                 filteredSerializedList.Add(new SerializedObject(filteredItemList[i]));
             }
 
@@ -214,28 +217,35 @@ private void AddNewItem()
         {
             List<Type> collectableSubclasses = TypeUtility.GetAllSubclasses(collection.GetCollectionType(), true);
 
+            collectableSubclasses.Add(collection.GetCollectionType());
             GenericMenu optionsMenu = new GenericMenu();
-            if (!collection.GetCollectionType().IsAbstract)
-            {
-                AddMenuOption(optionsMenu,  collection.GetCollectionType().Name, () =>
-                {
-                    EditorApplication.delayCall += () => { AddNewItemOfType(collection.GetCollectionType()); };
-                });
-            }
 
             for (int i = 0; i < collectableSubclasses.Count; i++)
             {
                 Type collectableSubClass = collectableSubclasses[i];
+                if (collectableSubClass.IsAbstract)
+                    continue;
+                
                 AddMenuOption(optionsMenu, collectableSubClass.Name, () =>
                 {
                     EditorApplication.delayCall += () => { AddNewItemOfType(collectableSubClass); };
                 });
             }
                 
-            AddMenuOption(optionsMenu, $"Create new Type : {collection.GetCollectionType().Name}", () =>
+            optionsMenu.AddSeparator("");
+            
+            for (int i = 0; i < collectableSubclasses.Count; i++)
             {
-                EditorApplication.delayCall += () => { CreateAndAddNewItemOfType(collection.GetCollectionType()); };
-            });
+                Type collectableSubClass = collectableSubclasses[i];
+
+                if (collectableSubClass.IsSealed)
+                    continue;
+                
+                AddMenuOption(optionsMenu, $"Create New/class $NEW : {collectableSubClass.Name}", () =>
+                {
+                    EditorApplication.delayCall += () => { CreateAndAddNewItemOfType(collectableSubClass); };
+                });
+            }
                 
             optionsMenu.ShowAsContext();
         }
@@ -339,9 +349,9 @@ private void DrawItem(int index)
             {
                 using (new EditorGUILayout.HorizontalScope())
                 {
-                    CollectionUtility.SetFoldoutOpen(collectionItem,
-                        EditorGUILayout.Toggle(GUIContent.none, CollectionUtility.IsFoldoutOpen(collectionItem), EditorStyles.foldout,
-                            GUILayout.Width(13)));
+                    CollectionUtility.SetFoldoutOpen(EditorGUILayout.Toggle(GUIContent.none,
+                        CollectionUtility.IsFoldoutOpen(collectionItem, target), EditorStyles.foldout,
+                        GUILayout.Width(13)), collectionItem, target);
 
                     using (EditorGUI.ChangeCheckScope changeCheck = new EditorGUI.ChangeCheckScope())
                     {
@@ -358,7 +368,7 @@ private void DrawItem(int index)
                     DrawDeleteButton(collectionItem);
                 }
                 
-                if (CollectionUtility.IsFoldoutOpen(collectionItem))
+                if (CollectionUtility.IsFoldoutOpen(collectionItem, target))
                 {
                     EditorGUI.indentLevel++;
                     Editor editor = CollectionUtility.GetOrCreateEditorForItem(collectionItem);
diff --git a/Scripts/Editor/ScriptableObjectCollectionUtils.cs b/Scripts/Editor/ScriptableObjectCollectionUtils.cs
@@ -0,0 +1,33 @@
+using System.IO;
+using UnityEditor;
+using UnityEngine;
+
+namespace BrunoMikoski.ScriptableObjectCollections
+{
+    public static class ScriptableObjectCollectionUtils
+    {
+        public static T CreateScriptableObjectOfType<T>(DefaultAsset parentFolder, bool createFolderForThisCollection,
+            string targetName) where T : ScriptableObject
+        {
+            return CreateScriptableObjectOfType<T>(AssetDatabase.GetAssetPath(parentFolder),
+                createFolderForThisCollection, targetName);
+        }
+
+        public static T CreateScriptableObjectOfType<T>(string parentFolderPath, bool createFolderForThisCollection,
+            string targetName) where T : ScriptableObject
+        {
+            T targetCollection = ScriptableObject.CreateInstance<T>();
+            targetCollection.name = targetName;
+
+            string targetFolderPath = parentFolderPath;
+            if (createFolderForThisCollection)
+                targetFolderPath = Path.Combine(targetFolderPath, $"{targetName}");
+
+            AssetDatabaseUtils.CreatePathIfDontExist(Path.Combine(targetFolderPath, "Items"));
+
+            string collectionAssetPath = Path.Combine(targetFolderPath, $"{targetName}.asset");
+            AssetDatabase.CreateAsset(targetCollection, collectionAssetPath);
+            return targetCollection;
+        }
+    }
+}
diff --git a/Scripts/Editor/ScriptableObjectCollectionUtils.cs.meta b/Scripts/Editor/ScriptableObjectCollectionUtils.cs.meta
diff --git a/Scripts/Editor/Utils/CodeGenerationUtility.cs b/Scripts/Editor/Utils/CodeGenerationUtility.cs
@@ -239,8 +239,8 @@ private static string[] GetCollectionDirectives(ScriptableObjectCollection colle
         private static void WriteTryGetAccessCollectionStatic(ScriptableObjectCollection collection, StreamWriter writer,
             ref int indentation)
         {
-            string cachedValuesName = $"collection";
-            string valuesName = $"Collection";
+            string cachedValuesName = $"values";
+            string valuesName = $"Values";
             string tryGetValuesName = $"TryGet{valuesName}";
 
             AppendLine(writer, indentation, $"private static {collection.GetType().Name} {cachedValuesName};");
@@ -336,7 +336,7 @@ private static void WriteDirectAccessCollectionStatic(ScriptableObjectCollection
         {
             bool isGeneratingCustomStaticFile = ScriptableObjectCollectionSettings.Instance.IsGeneratingCustomStaticFile(collection);
 
-            string cachedValuesName = "collection";
+            string cachedValuesName = "values";
             AppendLine(writer, indentation, $"private static {collection.GetType().Name} {cachedValuesName};");
 
             for (int i = 0; i < collection.Items.Count; i++)
@@ -348,12 +348,12 @@ private static void WriteDirectAccessCollectionStatic(ScriptableObjectCollection
 
             AppendLine(writer, indentation);
 
-            string valuesName = $"Collection";
+            string valuesName = $"Values";
 
             if(!isGeneratingCustomStaticFile)
             {
                 AppendLine(writer, indentation,
-                $"public new static {collection.GetType().Name} {valuesName}");
+                $"public static {collection.GetType().Name} {valuesName}");
             }
             else
             {
diff --git a/Scripts/Editor/Utils/CollectionUtility.cs b/Scripts/Editor/Utils/CollectionUtility.cs
@@ -10,7 +10,7 @@ public static class CollectionUtility
         private static Dictionary<Object, Editor> itemToEditor =
             new Dictionary<Object, Editor>();
 
-        private static Dictionary<Object, bool> objectToFoldOut = new Dictionary<Object, bool>();
+        private static Dictionary<int, bool> objectToFoldOut = new Dictionary<int, bool>();
 
         [MenuItem("Assets/Create/ScriptableObject Collection/New Collection", false, 100)]
         private static void CreateNewItem()
@@ -28,6 +28,23 @@ private static void CreateSettings()
             ScriptableObjectCollectionSettings.LoadOrCreateInstance<ScriptableObjectCollection>();
         }
         
+        
+        private static int GetHasCount(Object[] objects)
+        {
+            int hasValue = 0;
+            for (int i = 0; i < objects.Length; i++)
+            {
+                Object targetObj = objects[i];
+
+                if (targetObj == null)
+                    continue;
+
+                hasValue += targetObj.GetHashCode();
+            }
+
+            return hasValue;
+        }
+        
         public static Editor GetOrCreateEditorForItem(Object collectionItem)
         {
             if (itemToEditor.TryGetValue(collectionItem, out Editor customEditor))
@@ -37,28 +54,26 @@ public static Editor GetOrCreateEditorForItem(Object collectionItem)
             itemToEditor.Add(collectionItem, customEditor);
             return customEditor;
         }
-        
-        public static bool IsFoldoutOpen(Object targetObject)
+
+        public static bool IsFoldoutOpen(params Object[] objects)
         {
-            if (targetObject.IsNull())
+            int hashCount = GetHasCount(objects);
+           
+            if (hashCount == 0)
                 return false;
-            
-            bool value;
-            if(!objectToFoldOut.TryGetValue(targetObject, out value))
-                objectToFoldOut.Add(targetObject, value);
+
+            if(!objectToFoldOut.TryGetValue(hashCount, out bool value))
+                objectToFoldOut.Add(hashCount, value);
 
             return value;
         }
 
-        public static void SetFoldoutOpen(Object targetObject, bool value)
+        public static void SetFoldoutOpen(bool value, params Object[] objects)
         {
-            if (!objectToFoldOut.ContainsKey(targetObject))
-                objectToFoldOut.Add(targetObject, value);
-            else
-                objectToFoldOut[targetObject] = value;
-        }
+            int hashCount = GetHasCount(objects);
 
-       
+            objectToFoldOut[hashCount] = value;
+        }
     }
 }
 
diff --git a/Scripts/Editor/Utils/TypeUtility.cs b/Scripts/Editor/Utils/TypeUtility.cs
@@ -37,7 +37,7 @@ public static List<Type> GetAllSubclasses(Type targetType, bool ignoreCache = fa
         {
             if (ignoreCache || !typeToSubclasses.TryGetValue(targetType, out List<Type> results))
             {
-                results = AvailableTypes.Where(t => t.IsClass && !t.IsAbstract && t.IsSubclassOf(targetType)).ToList();
+                results = AvailableTypes.Where(t => t.IsClass && t.IsSubclassOf(targetType)).ToList();
                 if(!ignoreCache)
                     typeToSubclasses.Add(targetType, results);
             }
diff --git a/Scripts/Runtime/CollectableScriptableObject.cs b/Scripts/Runtime/CollectableScriptableObject.cs
@@ -19,7 +19,7 @@ public string GUID
         [SerializeField, HideInInspector]
         private ScriptableObjectCollection collection;
         public ScriptableObjectCollection Collection => collection;
-
+        
         public void SetCollection(ScriptableObjectCollection collection)
         {
             this.collection = collection;
diff --git a/Scripts/Runtime/CollectionsRegistry.cs b/Scripts/Runtime/CollectionsRegistry.cs
diff --git a/Scripts/Runtime/ScriptableObjectCollection.cs b/Scripts/Runtime/ScriptableObjectCollection.cs
diff --git a/package.json b/package.json

Original file line number	Diff line number	Diff line change
`@@ -33,8 +33,7 @@ private CollectableEditorOptionsAttribute optionsAttribute`
`33`	`33`	`private GUIContent[] GUIContents;`
`34`	`34`
`35`	`35`	`private CollectableScriptableObject collectableItem;`
`36`		`-`
`37`		`- private Object foldoutObject;`
	`36`	`+ private Object currentObject;`
`38`	`37`
`39`	`38`	`~CollectableScriptableObjectPropertyDrawer()`
`40`	`39`	`{`
`@@ -104,7 +103,7 @@ public override void OnGUI(Rect position, SerializedProperty property, GUIConten`
`104`	`103`
`105`	`104`	`if (collectableItem != null)`
`106`	`105`	`{`
`107`		`- if (CollectionUtility.IsFoldoutOpen(foldoutObject))`
	`106`	`+ if (CollectionUtility.IsFoldoutOpen(collectableItem, currentObject))`
`108`	`107`	`{`
`109`	`108`	`EditorGUI.indentLevel++;`
`110`	`109`	`using (new EditorGUILayout.VerticalScope("Box"))`
`@@ -162,7 +161,7 @@ private void Initialize(SerializedProperty property)`
`162`	`161`	`optionsNames = displayOptions.ToArray();`
`163`	`162`	`GUIContents = optionsNames.Select(s => new GUIContent(s)).ToArray();`
`164`	`163`
`165`		`- foldoutObject = property.serializedObject.targetObject;`
	`164`	`+ currentObject = property.serializedObject.targetObject;`
`166`	`165`	`initialized = true;`
`167`	`166`	`}`
`168`	`167`
`@@ -212,12 +211,12 @@ private void DrawEditFoldoutButton(ref Rect popupRect)`
`212`	`211`	`buttonRect.x += popupRect.width;`
`213`	`212`
`214`	`213`	`GUIContent guiContent = CollectionEditorGUI.EditGUIContent;`
`215`		`- if (CollectionUtility.IsFoldoutOpen(foldoutObject))`
	`214`	`+ if (CollectionUtility.IsFoldoutOpen(collectableItem, currentObject))`
`216`	`215`	`guiContent = CollectionEditorGUI.CloseGUIContent;`
`217`	`216`
`218`	`217`	`if (GUI.Button(buttonRect, guiContent))`
`219`	`218`	`{`
`220`		`- CollectionUtility.SetFoldoutOpen(foldoutObject, !CollectionUtility.IsFoldoutOpen(foldoutObject));`
	`219`	`+ CollectionUtility.SetFoldoutOpen(!CollectionUtility.IsFoldoutOpen(collectableItem, currentObject), collectableItem, currentObject);`
`221`	`220`	`ObjectUtility.SetDirty(collectableItem);`
`222`	`221`	`}`
`223`	`222`	`}`
Original file line number	Diff line number	Diff line change
`@@ -150,6 +150,9 @@ private void UpdateFilteredItemList()`
`150`	`150`
`151`	`151`	`for (int i = 0; i < filteredItemList.Count; i++)`
`152`	`152`	`{`
	`153`	`+ if (filteredItemList[i] == null)`
	`154`	`+ continue;`
	`155`	`+`
`153`	`156`	`filteredSerializedList.Add(new SerializedObject(filteredItemList[i]));`
`154`	`157`	`}`
`155`	`158`
`@@ -214,28 +217,35 @@ private void AddNewItem()`
`214`	`217`	`{`
`215`	`218`	`List<Type> collectableSubclasses = TypeUtility.GetAllSubclasses(collection.GetCollectionType(), true);`
`216`	`219`
	`220`	`+ collectableSubclasses.Add(collection.GetCollectionType());`
`217`	`221`	`GenericMenu optionsMenu = new GenericMenu();`
`218`		`- if (!collection.GetCollectionType().IsAbstract)`
`219`		`- {`
`220`		`- AddMenuOption(optionsMenu, collection.GetCollectionType().Name, () =>`
`221`		`- {`
`222`		`- EditorApplication.delayCall += () => { AddNewItemOfType(collection.GetCollectionType()); };`
`223`		`- });`
`224`		`- }`
`225`	`222`
`226`	`223`	`for (int i = 0; i < collectableSubclasses.Count; i++)`
`227`	`224`	`{`
`228`	`225`	`Type collectableSubClass = collectableSubclasses[i];`
	`226`	`+ if (collectableSubClass.IsAbstract)`
	`227`	`+ continue;`
	`228`	`+`
`229`	`229`	`AddMenuOption(optionsMenu, collectableSubClass.Name, () =>`
`230`	`230`	`{`
`231`	`231`	`EditorApplication.delayCall += () => { AddNewItemOfType(collectableSubClass); };`
`232`	`232`	`});`
`233`	`233`	`}`
`234`	`234`
`235`		`- AddMenuOption(optionsMenu, $"Create new Type : {collection.GetCollectionType().Name}", () =>`
	`235`	`+ optionsMenu.AddSeparator("");`
	`236`	`+`
	`237`	`+ for (int i = 0; i < collectableSubclasses.Count; i++)`
`236`	`238`	`{`
`237`		`- EditorApplication.delayCall += () => { CreateAndAddNewItemOfType(collection.GetCollectionType()); };`
`238`		`- });`
	`239`	`+ Type collectableSubClass = collectableSubclasses[i];`
	`240`	`+`
	`241`	`+ if (collectableSubClass.IsSealed)`
	`242`	`+ continue;`
	`243`	`+`
	`244`	`+ AddMenuOption(optionsMenu, $"Create New/class $NEW : {collectableSubClass.Name}", () =>`
	`245`	`+ {`
	`246`	`+ EditorApplication.delayCall += () => { CreateAndAddNewItemOfType(collectableSubClass); };`
	`247`	`+ });`
	`248`	`+ }`
`239`	`249`
`240`	`250`	`optionsMenu.ShowAsContext();`
`241`	`251`	`}`
`@@ -339,9 +349,9 @@ private void DrawItem(int index)`
`339`	`349`	`{`
`340`	`350`	`using (new EditorGUILayout.HorizontalScope())`
`341`	`351`	`{`
`342`		`- CollectionUtility.SetFoldoutOpen(collectionItem,`
`343`		`- EditorGUILayout.Toggle(GUIContent.none, CollectionUtility.IsFoldoutOpen(collectionItem), EditorStyles.foldout,`
`344`		`- GUILayout.Width(13)));`
	`352`	`+ CollectionUtility.SetFoldoutOpen(EditorGUILayout.Toggle(GUIContent.none,`
	`353`	`+ CollectionUtility.IsFoldoutOpen(collectionItem, target), EditorStyles.foldout,`
	`354`	`+ GUILayout.Width(13)), collectionItem, target);`
`345`	`355`
`346`	`356`	`using (EditorGUI.ChangeCheckScope changeCheck = new EditorGUI.ChangeCheckScope())`
`347`	`357`	`{`
`@@ -358,7 +368,7 @@ private void DrawItem(int index)`
`358`	`368`	`DrawDeleteButton(collectionItem);`
`359`	`369`	`}`
`360`	`370`
`361`		`- if (CollectionUtility.IsFoldoutOpen(collectionItem))`
	`371`	`+ if (CollectionUtility.IsFoldoutOpen(collectionItem, target))`
`362`	`372`	`{`
`363`	`373`	`EditorGUI.indentLevel++;`
`364`	`374`	`Editor editor = CollectionUtility.GetOrCreateEditorForItem(collectionItem);`
Original file line number	Diff line number	Diff line change
`@@ -239,8 +239,8 @@ private static string[] GetCollectionDirectives(ScriptableObjectCollection colle`
`239`	`239`	`private static void WriteTryGetAccessCollectionStatic(ScriptableObjectCollection collection, StreamWriter writer,`
`240`	`240`	`ref int indentation)`
`241`	`241`	`{`
`242`		`- string cachedValuesName = $"collection";`
`243`		`- string valuesName = $"Collection";`
	`242`	`+ string cachedValuesName = $"values";`
	`243`	`+ string valuesName = $"Values";`
`244`	`244`	`string tryGetValuesName = $"TryGet{valuesName}";`
`245`	`245`
`246`	`246`	`AppendLine(writer, indentation, $"private static {collection.GetType().Name} {cachedValuesName};");`
`@@ -336,7 +336,7 @@ private static void WriteDirectAccessCollectionStatic(ScriptableObjectCollection`
`336`	`336`	`{`
`337`	`337`	`bool isGeneratingCustomStaticFile = ScriptableObjectCollectionSettings.Instance.IsGeneratingCustomStaticFile(collection);`
`338`	`338`
`339`		`- string cachedValuesName = "collection";`
	`339`	`+ string cachedValuesName = "values";`
`340`	`340`	`AppendLine(writer, indentation, $"private static {collection.GetType().Name} {cachedValuesName};");`
`341`	`341`
`342`	`342`	`for (int i = 0; i < collection.Items.Count; i++)`
`@@ -348,12 +348,12 @@ private static void WriteDirectAccessCollectionStatic(ScriptableObjectCollection`
`348`	`348`
`349`	`349`	`AppendLine(writer, indentation);`
`350`	`350`
`351`		`- string valuesName = $"Collection";`
	`351`	`+ string valuesName = $"Values";`
`352`	`352`
`353`	`353`	`if(!isGeneratingCustomStaticFile)`
`354`	`354`	`{`
`355`	`355`	`AppendLine(writer, indentation,`
`356`		`- $"public new static {collection.GetType().Name} {valuesName}");`
	`356`	`+ $"public static {collection.GetType().Name} {valuesName}");`
`357`	`357`	`}`
`358`	`358`	`else`
`359`	`359`	`{`
Original file line number	Diff line number	Diff line change
`@@ -37,7 +37,7 @@ public static List<Type> GetAllSubclasses(Type targetType, bool ignoreCache = fa`
`37`	`37`	`{`
`38`	`38`	`if (ignoreCache \|\| !typeToSubclasses.TryGetValue(targetType, out List<Type> results))`
`39`	`39`	`{`
`40`		`- results = AvailableTypes.Where(t => t.IsClass && !t.IsAbstract && t.IsSubclassOf(targetType)).ToList();`
	`40`	`+ results = AvailableTypes.Where(t => t.IsClass && t.IsSubclassOf(targetType)).ToList();`
`41`	`41`	`if(!ignoreCache)`
`42`	`42`	`typeToSubclasses.Add(targetType, results);`
`43`	`43`	`}`
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ public string GUID`
`19`	`19`	`[SerializeField, HideInInspector]`
`20`	`20`	`private ScriptableObjectCollection collection;`
`21`	`21`	`public ScriptableObjectCollection Collection => collection;`
`22`		`-`
	`22`	`+`
`23`	`23`	`public void SetCollection(ScriptableObjectCollection collection)`
`24`	`24`	`{`
`25`	`25`	`this.collection = collection;`