com.wallstop-studios.unity-helpers 1.0.0-rc4

package/Editor/AnimationEventEditor.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 0dc67c07c6dd5754eb9244c315c898fa
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Editor/PrefabCheckWizard.cs

@@ -0,0 +1,140 @@
+namespace UnityHelpers.Editor
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Linq;
+    using System.Reflection;
+    using Core.Attributes;
+    using UnityEditor;
+    using UnityEngine;
+    using Core.Extension;
+    using Core.Helper;
+    using Utils;
+    using Object = UnityEngine.Object;
+
+    public sealed class PrefabCheckWizard : ScriptableWizard
+    {
+        private static readonly Dictionary<Type, List<FieldInfo>> FieldsByType = new();
+
+        [Tooltip("Drag a folder from Unity here to validate all prefabs under it. Defaults to Assets/Prefabs and Assets/Resources if none specified.")]
+        public List<Object> assetPaths;
+
+        [MenuItem("Tools/Unity Helpers/Prefab Check Wizard")]
+        public static void CreatePrefabCheckWizard()
+        {
+            _ = DisplayWizard<PrefabCheckWizard>("Prefab sanity check", "Run");
+        }
+
+        private void OnWizardCreate()
+        {
+            List<string> parsedAssetPaths;
+            if (assetPaths is { Count: > 0 })
+            {
+                parsedAssetPaths = assetPaths.Select(AssetDatabase.GetAssetPath).ToList();
+                parsedAssetPaths.RemoveAll(string.IsNullOrEmpty);
+                if (parsedAssetPaths.Count <= 0)
+                {
+                    parsedAssetPaths = null;
+                }
+            }
+            else
+            {
+                parsedAssetPaths = null;
+            }
+
+            foreach (GameObject prefab in Helpers.EnumeratePrefabs(parsedAssetPaths))
+            {
+                List<MonoBehaviour> componentBuffer = Buffers<MonoBehaviour>.List;
+                prefab.GetComponentsInChildren(true, componentBuffer);
+                foreach (MonoBehaviour script in componentBuffer)
+                {
+                    if (!script)
+                    {
+                        Type scriptType = script?.GetType();
+                        if (scriptType == null)
+                        {
+                            prefab.LogError("Detected missing script.");
+                        }
+                        else
+                        {
+                            prefab.LogError("Detected missing script for script type {0}.", scriptType);
+                        }
+
+                        continue;
+                    }
+                    ValidateNoNullsInLists(script);
+                }
+            }
+        }
+
+        private static void ValidateNoNullsInLists(Object component)
+        {
+            foreach (FieldInfo field in FieldsByType.GetOrAdd(
+                         component.GetType(), type => type
+                             .GetFields(BindingFlags.Instance | BindingFlags.Public)
+                             .Concat(
+                                 type.GetFields(BindingFlags.Instance | BindingFlags.NonPublic).Where(
+                                     field => field.GetCustomAttributes(typeof(SerializeField)).Any() ||
+                                              field.GetCustomAttributes(typeof(ValidateAssignmentAttribute)).Any()))
+                             .Where(field => typeof(IEnumerable).IsAssignableFrom(field.FieldType) || field.FieldType.IsArray)
+                             .Where(field => !typeof(Transform).IsAssignableFrom(field.FieldType))
+                             .Where(field => !typeof(Object).IsAssignableFrom(field.FieldType))
+                             .ToList()))
+            {
+                bool LogIfNull(object thing, int? position = null)
+                {
+                    if (thing == null || (thing is Object unityThing && !unityThing))
+                    {
+                        if (position == null)
+                        {
+                            component.LogError("Field {0} has a null element in it.", field.Name);
+                        }
+                        else
+                        {
+                            component.LogError("Field {0} has a null element at position {1}.", field.Name, position);
+                        }
+
+                        return true;
+                    }
+
+                    return false;
+                }
+
+                object fieldValue = field.GetValue(component);
+
+                if (field.FieldType.IsArray)
+                {
+                    if (fieldValue == null)
+                    {
+                        component.LogError("Field {0} (array) was null.", field.Name);
+                        continue;
+                    }
+
+                    Array array = (Array)fieldValue;
+                    foreach (object thing in array)
+                    {
+                        bool nullElement = LogIfNull(thing);
+                        if (nullElement)
+                        {
+                            break;
+                        }
+                    }
+
+                    continue;
+                }
+
+                if (fieldValue is not IEnumerable list)
+                {
+                    continue;
+                }
+
+                int position = 0;
+                foreach (object thing in list)
+                {
+                    _ = LogIfNull(thing, position++);
+                }
+            }
+        }
+    }
+}

package/Editor/PrefabCheckWizard.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 25cf013a07239b04fa262ee9db2860ec
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Editor/WallstopStudios.UnityHelpers.Editor.asmdef

@@ -0,0 +1,16 @@
+{
+    "name": "WallstopStudios.UnityHelpers.Editor",
+    "rootNamespace": "",
+    "references": [
+        "WallstopStudios.UnityHelpers"
+    ],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}

package/Editor/WallstopStudios.UnityHelpers.Editor.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: de86e2706cb173041874cadb20669cb0
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Editor.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 09b16dc9463deb7499043e86335b41b8
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Eli Pinkerton
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/LICENSE.md

@@ -0,0 +1,7 @@
+Copyright 2023 Eli Pinkerton
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/LICENSE.md.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 8977dc43976e68c47948b5891b0db297
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/LICENSE.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: a6e47b47847d6be4ba31a4de140b068d
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/README.md

@@ -0,0 +1,2 @@
+# A Grab-Bag
+Various Unity Helpers. Includes deterministic randoms including a PCGRandom implementation,

package/README.md.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: d8a337245154754488809b2728b8931a
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Core/Attributes/AnimationEventAttribute.cs

@@ -0,0 +1,102 @@
+namespace UnityHelpers.Core.Attributes
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using System.Reflection;
+    using UnityEngine;
+
+    [AttributeUsage(AttributeTargets.Method)]
+    public sealed class AnimationEventAttribute : Attribute
+    {
+        public bool ignoreDerived = true;
+    }
+
+    public static class AnimationEventHelpers
+    {
+        public static readonly IReadOnlyDictionary<Type, IReadOnlyList<MethodInfo>> TypesToMethods;
+
+        static AnimationEventHelpers()
+        {
+            List<(Type, string)> ignoreDerived = new();
+            Dictionary<Type, List<MethodInfo>> typesToMethods = AppDomain.CurrentDomain.GetAssemblies()
+                .SelectMany(assembly => assembly.GetTypes())
+                .Where(type => type.IsClass)
+                .Where(type => typeof(MonoBehaviour).IsAssignableFrom(type))
+                .ToDictionary(
+                    type => type,
+                    type =>
+                    {
+                        List<MethodInfo> definedMethods = GetPossibleAnimatorEventsForType(type)
+                            .Where(method => Attribute.IsDefined(method, typeof(AnimationEventAttribute), true)).ToList();
+                        foreach (MethodInfo definedMethod in definedMethods)
+                        {
+                            // Only consider attributes on our specific method
+                            if (!Attribute.IsDefined(definedMethod, typeof(AnimationEventAttribute), false))
+                            {
+                                continue;
+                            }
+
+                            if (definedMethod.GetCustomAttributes(typeof(AnimationEventAttribute), false)[0] is
+                                AnimationEventAttribute { ignoreDerived: true })
+                            {
+                                ignoreDerived.Add((type, definedMethod.Name));
+                            }
+                        }
+
+                        return definedMethods;
+                    });
+
+            foreach (KeyValuePair<Type, List<MethodInfo>> entry in typesToMethods.ToList())
+            {
+                if (entry.Value.Count <= 0)
+                {
+                    _ = typesToMethods.Remove(entry.Key);
+                }
+
+                Type key = entry.Key;
+                foreach ((Type type, string methodName) in ignoreDerived)
+                {
+                    if (key == type)
+                    {
+                        continue;
+                    }
+
+                    if (!key.IsSubclassOf(type))
+                    {
+                        continue;
+                    }
+
+                    entry.Value.RemoveAll(method => method.Name == methodName);
+                    if (entry.Value.Count <= 0)
+                    {
+                        _ = typesToMethods.Remove(entry.Key);
+                        break;
+                    }
+                }
+            }
+
+            TypesToMethods = typesToMethods.ToDictionary(kvp => kvp.Key, kvp => (IReadOnlyList<MethodInfo>)kvp.Value);
+        }
+
+        public static List<MethodInfo> GetPossibleAnimatorEventsForType(this Type type)
+        {
+            return type.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).Where
+            (
+                p =>
+                    p.ReturnType == typeof(void) &&
+                    (p.GetParameters().Select(q => q.ParameterType).SequenceEqual(new Type[] { }) ||
+                     p.GetParameters().Select(q => q.ParameterType)
+                         .SequenceEqual(new Type[] { typeof(int) }) ||
+                     p.GetParameters().Select(q => q.ParameterType.BaseType)
+                         .SequenceEqual(new Type[] { typeof(Enum) }) ||
+                     p.GetParameters().Select(q => q.ParameterType)
+                         .SequenceEqual(new Type[] { typeof(float) }) ||
+                     p.GetParameters().Select(q => q.ParameterType)
+                         .SequenceEqual(new Type[] { typeof(string) }) ||
+                     p.GetParameters().Select(q => q.ParameterType)
+                         .SequenceEqual(new Type[] { typeof(UnityEngine.Object) }))
+            ).OrderBy(method => method.Name).ToList();
+        }
+    }
+}

package/Runtime/Core/Attributes/AnimationEventAttribute.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 813e6dba6f6598740b2950ce37ef1570
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Core/Attributes/AutomaticallyFindAttribute.cs

@@ -0,0 +1,43 @@
+namespace UnityHelpers.Core.Attributes
+{
+    using System;
+    using System.Linq;
+    using System.Reflection;
+    using JetBrains.Annotations;
+    using UnityEngine;
+
+    [AttributeUsage(AttributeTargets.Field)]
+    [MeansImplicitUse]
+    public sealed class AutomaticallyFindAttribute : Attribute
+    {
+        public readonly string Tag = string.Empty;
+    }
+
+    public static class AutomaticallyFindExtensions
+    {
+        public static void AutomaticallyFind(this Component component)
+        {
+            var properties = component
+                .GetType()
+                .GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
+                .Where(prop => Attribute.IsDefined(prop, typeof(AutomaticallyFindAttribute)));
+
+            foreach (FieldInfo field in properties)
+            {
+                Type fieldType = field.FieldType;
+                Type type = fieldType.IsArray ? fieldType.GetElementType() : fieldType;
+
+                if (type == typeof(GameObject))
+                {
+                    var attribute = field.GetCustomAttributes(typeof(AutomaticallyFindAttribute), false)[0] as AutomaticallyFindAttribute;
+                    GameObject gameObject = GameObject.FindWithTag(attribute.Tag);
+                    field.SetValue(component, gameObject);
+                    return;
+                }
+
+                object foundObject = type.GetMethod("Find", BindingFlags.Public | BindingFlags.Static).Invoke(null, null);
+                field.SetValue(component, foundObject);
+            }
+        }
+    }
+}

package/Runtime/Core/Attributes/AutomaticallyFindAttribute.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 26082413782e4f3e800873e5495f494b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Core/Attributes/ChildComponentAttribute.cs

@@ -0,0 +1,85 @@
+namespace UnityHelpers.Core.Attributes
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Linq;
+    using System.Reflection;
+    using Extension;
+    using JetBrains.Annotations;
+    using UnityEngine;
+
+    [AttributeUsage(AttributeTargets.Field)]
+    [MeansImplicitUse]
+    public sealed class ChildComponentAttribute : Attribute
+    {
+        public bool optional = false;
+    }
+
+    public static class ChildComponentExtensions
+    {
+        private static readonly Dictionary<Type, List<FieldInfo>> FieldsByType = new();
+
+        public static void AssignChildComponents(this Component component)
+        {
+            Type componentType = component.GetType();
+            List<FieldInfo> fields = FieldsByType.GetOrAdd(componentType, type =>
+            {
+                FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
+                return fields
+                    .Where(prop => Attribute.IsDefined(prop, typeof(ChildComponentAttribute)))
+                    .ToList();
+            });
+
+            foreach (FieldInfo field in fields)
+            {
+                Type fieldType = field.FieldType;
+                bool isArray = fieldType.IsArray;
+                Type childComponentType = isArray ? fieldType.GetElementType() : fieldType;
+
+                bool foundChild;
+                if (isArray)
+                {
+                    Component[] childComponents = component.GetComponentsInChildren(childComponentType, true);
+                    foundChild = 0 < childComponents.Length;
+                    
+                    Array correctTypedArray = Array.CreateInstance(childComponentType, childComponents.Length);
+                    Array.Copy(childComponents, correctTypedArray, childComponents.Length);
+                    field.SetValue(component, correctTypedArray);
+                }
+                else if (fieldType.IsGenericType && fieldType.GetGenericTypeDefinition() == typeof(List<>))
+                {
+                    childComponentType = fieldType.GenericTypeArguments[0];
+                    Type constructedListType = typeof(List<>).MakeGenericType(childComponentType);
+                    IList instance = (IList) Activator.CreateInstance(constructedListType);
+
+                    foundChild = false;
+                    foreach (Component childComponent in component.GetComponentsInChildren(childComponentType, true))
+                    {
+                        instance.Add(childComponent);
+                        foundChild = true;
+                    }
+
+                    field.SetValue(component, instance);
+                }
+                else
+                {
+                    Component childComponent = component.GetComponentInChildren(childComponentType, true);
+                    foundChild = childComponent != null;
+                    if (foundChild)
+                    {
+                        field.SetValue(component, childComponent);
+                    }
+                }
+
+                if (!foundChild)
+                {
+                    if (field.GetCustomAttributes(typeof(ChildComponentAttribute), false)[0] is ChildComponentAttribute { optional: false } _)
+                    {
+                        component.LogError($"Unable to find child component of type {fieldType}");
+                    }
+                }
+            }
+        }
+    }
+}

package/Runtime/Core/Attributes/ChildComponentAttribute.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 2944db3ec3c23a34d94063750dca2739
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Core/Attributes/KSerializableAttribute.cs

@@ -0,0 +1,23 @@
+namespace UnityHelpers.Core.Attributes
+{
+    using System;
+
+    /// <summary>
+    ///     If specified on a field or property, will automatically attempt to serialize that property
+    ///     on MonoBehaviors when SerializedWorld is being constructed.
+    ///     If specified on a class, will automatically attempt to serialize all fields and properties.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Field | AttributeTargets.Property | AttributeTargets.Class)]
+    public sealed class KSerializableAttribute : Attribute
+    {
+    }
+
+    /// <summary>
+    ///     For classes where KSerializableAttribute is used, specifying this on fields or properties
+    ///     will ignore them for the purpose of serialization into SerializedWorld.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Field | AttributeTargets.Property)]
+    public sealed class KNonSerializableAttribute : Attribute
+    {
+    }
+}

package/Runtime/Core/Attributes/KSerializableAttribute.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6ebdc43388637b440aa75f5f9c92a4de
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Core/Attributes/NotNullAttribute.cs

@@ -0,0 +1,33 @@
+namespace UnityHelpers.Core.Attributes
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using System.Reflection;
+
+    [AttributeUsage(AttributeTargets.Field)]
+    public sealed class NotNullAttribute : Attribute
+    {
+    }
+
+    public static class NotNullAttributeExtensions
+    {
+        public static void CheckForNulls(this object o)
+        {
+#if UNITY_EDITOR
+            IEnumerable<FieldInfo> properties = o.GetType().GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
+                .Where(prop => Attribute.IsDefined(prop, typeof(NotNullAttribute)));
+
+            foreach (FieldInfo field in properties)
+            {
+                object fieldValue = field.GetValue(o);
+
+                if (fieldValue == null)
+                {
+                    throw new ArgumentNullException(field.Name);
+                }
+            }
+#endif
+        }
+    }
+}

package/Runtime/Core/Attributes/NotNullAttribute.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 3e6951fbb938059438d1637f3873a7bc
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: