com.wallstop-studios.unity-helpers 2.0.0-rc22 → 2.0.0-rc23

package/Editor/CustomEditors/MatchColliderToSpriteEditor.cs

@@ -17,7 +17,10 @@
             if (matchColliderToSprite == null)
             {
                 this.LogError(
-                    "Target was of type {0}, expected {1}.", target?.GetType(), typeof(MatchColliderToSprite));
+                    "Target was of type {0}, expected {1}.",
+                    target?.GetType(),
+                    typeof(MatchColliderToSprite)
+                );
                 return;
             }
 
@@ -28,4 +31,4 @@
         }
     }
 #endif
-}
+}

package/Editor/PrefabCheckWizard.cs

@@ -18,7 +18,9 @@
     {
         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.")]
+        [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")]
@@ -59,7 +61,10 @@
                         }
                         else
                         {
-                            prefab.LogError("Detected missing script for script type {0}.", scriptType);
+                            prefab.LogError(
+                                "Detected missing script for script type {0}.",
+                                scriptType
+                            );
                         }
 
                         continue;
@@ -71,17 +76,31 @@
 
         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()))
+            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)
                 {
@@ -93,7 +112,11 @@
                         }
                         else
                         {
-                            component.LogError("Field {0} has a null element at position {1}.", field.Name, position);
+                            component.LogError(
+                                "Field {0} has a null element at position {1}.",
+                                field.Name,
+                                position
+                            );
                         }
 
                         return true;

package/Editor/SpriteSettingsApplier.cs

@@ -29,11 +29,13 @@
         public List<string> spriteFileExtensions = new() { ".png" };
 
         [Tooltip(
-            "Drag various sprite settings here, where the name property matches a sprite asset name. The first settings with an empty or matching name will be applied to each and every sprite.")]
+            "Drag various sprite settings here, where the name property matches a sprite asset name. The first settings with an empty or matching name will be applied to each and every sprite."
+        )]
         public List<SpriteSettings> spriteSettings = new() { new SpriteSettings() };
 
         [Tooltip(
-            "Drag a folder from Unity here to apply the configuration to all settings under it. No sprites are modified if no directories are provided.")]
+            "Drag a folder from Unity here to apply the configuration to all settings under it. No sprites are modified if no directories are provided."
+        )]
         public List<Object> directories = new();
 
         [MenuItem("Tools/Unity Helpers/Sprite Settings Applier")]
@@ -67,14 +69,19 @@
                         continue;
                     }
 
-                    int index = fullFilePath.LastIndexOf(directoryPath, StringComparison.OrdinalIgnoreCase);
+                    int index = fullFilePath.LastIndexOf(
+                        directoryPath,
+                        StringComparison.OrdinalIgnoreCase
+                    );
                     if (index < 0)
                     {
                         continue;
                     }
 
                     string filePath = fullFilePath.Substring(index);
-                    if (processedSpritePaths.Add(fullFilePath) && TryUpdateTextureSettings(filePath))
+                    if (
+                        processedSpritePaths.Add(fullFilePath) && TryUpdateTextureSettings(filePath)
+                    )
                     {
                         ++spriteCount;
                     }
@@ -82,7 +89,10 @@
 
                 foreach (string subDirectory in Directory.EnumerateDirectories(directoryPath))
                 {
-                    int index = subDirectory.LastIndexOf(directoryPath, StringComparison.OrdinalIgnoreCase);
+                    int index = subDirectory.LastIndexOf(
+                        directoryPath,
+                        StringComparison.OrdinalIgnoreCase
+                    );
                     if (index < 0)
                     {
                         continue;
@@ -100,7 +110,10 @@
                 }
 
                 string filePath = AssetDatabase.GetAssetPath(sprite);
-                if (processedSpritePaths.Add(Application.dataPath + filePath) && TryUpdateTextureSettings(filePath))
+                if (
+                    processedSpritePaths.Add(Application.dataPath + filePath)
+                    && TryUpdateTextureSettings(filePath)
+                )
                 {
                     ++spriteCount;
                 }
@@ -121,8 +134,9 @@
                 return false;
             }
 
-            SpriteSettings spriteData = spriteSettings.FirstOrDefault(
-                settings => string.IsNullOrEmpty(settings.name) || filePath.Contains(settings.name));
+            SpriteSettings spriteData = spriteSettings.FirstOrDefault(settings =>
+                string.IsNullOrEmpty(settings.name) || filePath.Contains(settings.name)
+            );
             if (spriteData == null)
             {
                 return false;
@@ -151,4 +165,4 @@
         }
     }
 #endif
-}
+}

package/Editor/TextureResizerWizard.cs

@@ -20,14 +20,15 @@
         public enum ResizeAlgorithm
         {
             Bilinear,
-            Point
+            Point,
         }
 
         public List<Texture2D> textures = new();
 
         [FormerlySerializedAs("animationSources")]
         [Tooltip(
-            "Drag a folder from Unity here to apply the configuration to all textures under it. No textures are modified if no directories are provided.")]
+            "Drag a folder from Unity here to apply the configuration to all textures under it. No textures are modified if no directories are provided."
+        )]
         public List<Object> textureSourcePaths = new();
 
         public int numResizes = 1;
@@ -61,7 +62,12 @@
 
             if (animationPaths.Any())
             {
-                foreach (string assetGuid in AssetDatabase.FindAssets("t:texture2D", animationPaths.ToArray()))
+                foreach (
+                    string assetGuid in AssetDatabase.FindAssets(
+                        "t:texture2D",
+                        animationPaths.ToArray()
+                    )
+                )
                 {
                     string path = AssetDatabase.GUIDToAssetPath(assetGuid);
                     if (string.IsNullOrEmpty(path))
@@ -94,7 +100,8 @@
                         continue;
                     }
 
-                    TextureImporter tImporter = AssetImporter.GetAtPath(assetPath) as TextureImporter;
+                    TextureImporter tImporter =
+                        AssetImporter.GetAtPath(assetPath) as TextureImporter;
                     if (tImporter == null)
                     {
                         continue;
@@ -112,9 +119,10 @@
                     Texture2D copy = Instantiate(texture);
                     try
                     {
-                        int extraWidth = (int)Math.Round(copy.width / (pixelsPerUnit * widthMultiplier));
-                        int extraHeight = (int)Math.Round(
-                            copy.height / (pixelsPerUnit * heightMultiplier));
+                        int extraWidth = (int)
+                            Math.Round(copy.width / (pixelsPerUnit * widthMultiplier));
+                        int extraHeight = (int)
+                            Math.Round(copy.height / (pixelsPerUnit * heightMultiplier));
                         if (extraWidth == 0 && extraHeight == 0)
                         {
                             continue;
@@ -123,22 +131,37 @@
                         switch (scalingResizeAlgorithm)
                         {
                             case ResizeAlgorithm.Bilinear:
-                                TextureScale.Bilinear(copy, copy.width + extraWidth, copy.height + extraHeight);
+                                TextureScale.Bilinear(
+                                    copy,
+                                    copy.width + extraWidth,
+                                    copy.height + extraHeight
+                                );
                                 break;
                             case ResizeAlgorithm.Point:
-                                TextureScale.Point(copy, copy.width + extraWidth, copy.height + extraHeight);
+                                TextureScale.Point(
+                                    copy,
+                                    copy.width + extraWidth,
+                                    copy.height + extraHeight
+                                );
                                 break;
                             default:
                                 throw new InvalidEnumArgumentException(
-                                    nameof(scalingResizeAlgorithm), (int)scalingResizeAlgorithm,
-                                    typeof(ResizeAlgorithm));
+                                    nameof(scalingResizeAlgorithm),
+                                    (int)scalingResizeAlgorithm,
+                                    typeof(ResizeAlgorithm)
+                                );
                         }
 
                         byte[] bytes = copy.EncodeToPNG();
                         File.WriteAllBytes(assetPath, bytes);
                         this.Log(
-                            "Resized {0} from [{1}x{2}] to [{3}x{4}]", texture.name, texture.width, texture.height,
-                            copy.width, copy.height);
+                            "Resized {0} from [{1}x{2}] to [{3}x{4}]",
+                            texture.name,
+                            texture.width,
+                            texture.height,
+                            copy.width,
+                            copy.height
+                        );
                     }
                     catch (Exception e)
                     {
@@ -155,4 +178,4 @@
         }
     }
 #endif
-}
+}

package/Editor/TextureSettingsApplier.cs

@@ -31,7 +31,8 @@
         public List<Texture2D> textures = new();
 
         [Tooltip(
-            "Drag a folder from Unity here to apply the configuration to all settings under it. No sprites are modified if no directories are provided.")]
+            "Drag a folder from Unity here to apply the configuration to all settings under it. No sprites are modified if no directories are provided."
+        )]
         public List<Object> directories = new();
 
         [MenuItem("Tools/Unity Helpers/Texture Settings Applier")]
@@ -54,10 +55,12 @@
 
             int textureCount = 0;
             HashSet<string> processedPaths = new();
-            foreach (Texture2D texture in textures?
-                                              .Distinct()
-                                              .OrderBy(texture => texture != null ? texture.name : string.Empty) ??
-                                          Enumerable.Empty<Texture2D>())
+            foreach (
+                Texture2D texture in textures
+                    ?.Distinct()
+                    .OrderBy(texture => texture != null ? texture.name : string.Empty)
+                    ?? Enumerable.Empty<Texture2D>()
+            )
             {
                 if (texture == null)
                 {
@@ -65,7 +68,10 @@
                 }
 
                 string assetPath = AssetDatabase.GetAssetPath(texture);
-                if (processedPaths.Add(Application.dataPath + assetPath) && TryUpdateTextureSettings(assetPath))
+                if (
+                    processedPaths.Add(Application.dataPath + assetPath)
+                    && TryUpdateTextureSettings(assetPath)
+                )
                 {
                     ++textureCount;
                 }
@@ -81,7 +87,10 @@
                         continue;
                     }
 
-                    int index = fullFilePath.LastIndexOf(directoryPath, StringComparison.OrdinalIgnoreCase);
+                    int index = fullFilePath.LastIndexOf(
+                        directoryPath,
+                        StringComparison.OrdinalIgnoreCase
+                    );
                     if (index < 0)
                     {
                         continue;
@@ -96,7 +105,10 @@
 
                 foreach (string subDirectory in Directory.EnumerateDirectories(directoryPath))
                 {
-                    int index = subDirectory.LastIndexOf(directoryPath, StringComparison.OrdinalIgnoreCase);
+                    int index = subDirectory.LastIndexOf(
+                        directoryPath,
+                        StringComparison.OrdinalIgnoreCase
+                    );
                     if (index < 0)
                     {
                         continue;
@@ -129,7 +141,8 @@
                     format = textureFormat,
                     textureCompression = compression,
                     crunchedCompression = useCrunchCompression,
-                });
+                }
+            );
             if (applyReadOnly)
             {
                 textureImporter.isReadable = !isReadOnly;
@@ -155,4 +168,4 @@
         }
     }
 #endif
-}
+}

package/Editor/Utils/EditorUtilities.cs

@@ -11,10 +11,12 @@
         {
             Type projectWindowUtilType = typeof(ProjectWindowUtil);
             MethodInfo getActiveFolderPath = projectWindowUtilType.GetMethod(
-                "GetActiveFolderPath", BindingFlags.Static | BindingFlags.NonPublic);
+                "GetActiveFolderPath",
+                BindingFlags.Static | BindingFlags.NonPublic
+            );
             object obj = getActiveFolderPath?.Invoke(null, Array.Empty<object>());
             return obj?.ToString() ?? string.Empty;
         }
     }
 #endif
-}
+}

package/Editor/Utils/ReadOnlyPropertyDrawer.cs

@@ -9,9 +9,7 @@
     [CustomPropertyDrawer(typeof(ReadOnlyAttribute))]
     public sealed class ReadOnlyPropertyDrawer : PropertyDrawer
     {
-        public override float GetPropertyHeight(
-            SerializedProperty property,
-            GUIContent label)
+        public override float GetPropertyHeight(SerializedProperty property, GUIContent label)
         {
             return EditorGUI.GetPropertyHeight(property, label, true);
         }
@@ -25,4 +23,4 @@
         }
     }
 #endif
-}
+}

package/Runtime/Core/Attributes/AnimationEventAttribute.cs

@@ -19,7 +19,8 @@
         static AnimationEventHelpers()
         {
             List<(Type, string)> ignoreDerived = new();
-            Dictionary<Type, List<MethodInfo>> typesToMethods = AppDomain.CurrentDomain.GetAssemblies()
+            Dictionary<Type, List<MethodInfo>> typesToMethods = AppDomain
+                .CurrentDomain.GetAssemblies()
                 .SelectMany(assembly => assembly.GetTypes())
                 .Where(type => type.IsClass)
                 .Where(type => typeof(MonoBehaviour).IsAssignableFrom(type))
@@ -28,24 +29,39 @@
                     type =>
                     {
                         List<MethodInfo> definedMethods = GetPossibleAnimatorEventsForType(type)
-                            .Where(method => Attribute.IsDefined(method, typeof(AnimationEventAttribute), true)).ToList();
+                            .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))
+                            if (
+                                !Attribute.IsDefined(
+                                    definedMethod,
+                                    typeof(AnimationEventAttribute),
+                                    false
+                                )
+                            )
                             {
                                 continue;
                             }
 
-                            if (definedMethod.GetCustomAttributes(typeof(AnimationEventAttribute), false)[0] is
-                                AnimationEventAttribute { ignoreDerived: true })
+                            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())
             {
@@ -76,27 +92,40 @@
                 }
             }
 
-            TypesToMethods = typesToMethods.ToDictionary(kvp => kvp.Key, kvp => (IReadOnlyList<MethodInfo>)kvp.Value);
+            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();
+            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/KSerializableAttribute.cs

@@ -8,16 +8,12 @@
     ///     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
-    {
-    }
+    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
-    {
-    }
+    public sealed class KNonSerializableAttribute : Attribute { }
 }

package/Runtime/Core/Attributes/NotNullAttribute.cs

@@ -6,16 +6,15 @@
     using System.Reflection;
 
     [AttributeUsage(AttributeTargets.Field)]
-    public sealed class NotNullAttribute : Attribute
-    {
-    }
+    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)
+            IEnumerable<FieldInfo> properties = o.GetType()
+                .GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
                 .Where(prop => Attribute.IsDefined(prop, typeof(NotNullAttribute)));
 
             foreach (FieldInfo field in properties)

package/Runtime/Core/Attributes/ReadOnlyAttribute.cs

@@ -2,7 +2,5 @@
 
 namespace UnityHelpers.Core.Attributes
 {
-    public sealed class ReadOnlyAttribute : PropertyAttribute
-    {
-    }
+    public sealed class ReadOnlyAttribute : PropertyAttribute { }
 }

package/Runtime/Core/Attributes/ValidateAssignmentAttribute.cs

@@ -21,10 +21,16 @@
         private static FieldInfo[] GetOrAdd(Type objectType)
         {
             return FieldsByType.GetOrAdd(
-                objectType, type => type
-                    .GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
-                    .Where(prop => Attribute.IsDefined(prop, typeof(ValidateAssignmentAttribute)))
-                    .ToArray());
+                objectType,
+                type =>
+                    type.GetFields(
+                            BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic
+                        )
+                        .Where(prop =>
+                            Attribute.IsDefined(prop, typeof(ValidateAssignmentAttribute))
+                        )
+                        .ToArray()
+            );
         }
 
         public static void ValidateAssignments(this Object o)
@@ -88,8 +94,8 @@
                 IList list => list.Count <= 0,
                 ICollection collection => collection.Count <= 0,
                 IEnumerable enumerable => IsInvalid(enumerable),
-                _ => fieldValue == null
+                _ => fieldValue == null,
             };
         }
     }
-}
+}

package/Runtime/Core/DataStructure/Adapters/FastVector2Int.cs

@@ -12,6 +12,7 @@
     {
         [ProtoMember(1)]
         public int x;
+
         [ProtoMember(2)]
         public int y;
 

package/Runtime/Core/DataStructure/Adapters/FastVector3Int.cs

@@ -8,14 +8,19 @@
 
     [Serializable]
     [ProtoContract]
-    public struct FastVector3Int : IEquatable<FastVector3Int>, IComparable<FastVector3Int>, IComparable
+    public struct FastVector3Int
+        : IEquatable<FastVector3Int>,
+            IComparable<FastVector3Int>,
+            IComparable
     {
         public static readonly FastVector3Int zero = new(0, 0, 0);
 
         [ProtoMember(1)]
         public int x;
+
         [ProtoMember(2)]
         public int y;
+
         [ProtoMember(3)]
         public int z;
 
@@ -30,13 +35,10 @@
         }
 
         public FastVector3Int(Vector3Int vector)
-            : this(vector.x, vector.y, vector.z)
-        {
-        }
+            : this(vector.x, vector.y, vector.z) { }
 
-        public FastVector3Int(int x, int y) : this(x, y, 0)
-        {
-        }
+        public FastVector3Int(int x, int y)
+            : this(x, y, 0) { }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static bool operator ==(FastVector3Int lhs, FastVector3Int rhs)
@@ -124,7 +126,10 @@
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public bool Equals(FastVector3Int other)
         {
-            return GetHashCode() == other.GetHashCode() && x == other.x && y == other.y && z == other.z;
+            return GetHashCode() == other.GetHashCode()
+                && x == other.x
+                && y == other.y
+                && z == other.z;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]