com.wallstop-studios.unity-helpers 1.0.0-rc7 → 1.0.0-rc9

package/Editor/AnimationCreator.cs

@@ -1,5 +1,6 @@
 namespace UnityHelpers.Editor
 {
+#if UNITY_EDITOR
     using System;
     using System.Collections.Generic;
     using System.Linq;
@@ -14,14 +15,9 @@
         public const int DefaultFramesPerSecond = 12;
 
         public List<Texture2D> frames;
-        public int framesPerSecond;
+        public int framesPerSecond = DefaultFramesPerSecond;
         public string animationName;
         public string assetPath;
-
-        public AnimationData()
-        {
-            framesPerSecond = DefaultFramesPerSecond;
-        }
     }
 
     public sealed class AnimationCreator : ScriptableWizard
@@ -215,4 +211,5 @@
             }
         }
     }
+#endif
 }

package/Editor/AnimationEventEditor.cs

@@ -1,5 +1,6 @@
 namespace UnityHelpers.Editor
 {
+#if UNITY_EDITOR
     using System;
     using System.Linq;
     using System.Collections.Generic;
@@ -138,11 +139,14 @@
             }
 
             frameRate = _currentClip.frameRate = EditorGUILayout.FloatField("FrameRate", frameRate);
+            DrawGuiLine(height: 5, color: new Color(0f, 0.5f, 1f, 1f));
             _scrollPosition = EditorGUILayout.BeginScrollView(_scrollPosition);
 
             // Need a copy because we might be mutating it
-            foreach (AnimationEventItem item in _state.ToList())
+            List<AnimationEventItem> stateCopy = _state.ToList();
+            for (int i = 0; i < stateCopy.Count; ++i)
             {
+                AnimationEventItem item = stateCopy[i];
                 AnimationEvent animEvent = item.animationEvent;
 
                 int frame = Mathf.RoundToInt(animEvent.time * oldFrameRate);
@@ -151,11 +155,15 @@
                 DrawSpritePreview(item);
 
                 EditorGUI.indentLevel++;
-
                 RenderAnimationEventItem(item, frame, frameRate);
-
+                
+                if (i != stateCopy.Count - 1)
+                {
+                    DrawGuiLine(height: 3, color: new Color(0f, 1f, 0.3f, 1f));
+                    EditorGUILayout.Space();
+                }
+                
                 EditorGUI.indentLevel--;
-                EditorGUILayout.Space();
             }
 
             EditorGUILayout.EndScrollView();
@@ -640,7 +648,7 @@
         private bool TryFindSpriteForEvent(AnimationEventItem item, out Sprite sprite)
         {
             sprite = null;
-            foreach (ObjectReferenceKeyframe keyFrame in _referenceCurve)
+            foreach (ObjectReferenceKeyframe keyFrame in _referenceCurve ?? Enumerable.Empty<ObjectReferenceKeyframe>())
             {
                 if (keyFrame.time <= item.animationEvent.time)
                 {
@@ -738,5 +746,15 @@
                 }
             }
         }
+
+        private void DrawGuiLine(int height = 1, Color? color = null)
+        {
+            Rect rect = EditorGUILayout.GetControlRect(false, height);
+            rect.height = height;
+            int minusWidth = EditorGUI.indentLevel * 16;
+            rect.xMin += minusWidth;
+            EditorGUI.DrawRect(rect, color ?? new Color(0.5f, 0.5f, 0.5f, 1f));
+        }
     }
+#endif
 }

package/Editor/PrefabCheckWizard.cs

@@ -1,5 +1,6 @@
 namespace UnityHelpers.Editor
 {
+#if UNITY_EDITOR
     using System;
     using System.Collections;
     using System.Collections.Generic;
@@ -137,4 +138,5 @@
             }
         }
     }
+#endif
 }

package/Runtime/Core/Attributes/ChildComponentAttribute.cs

@@ -18,18 +18,20 @@
 
     public static class ChildComponentExtensions
     {
-        private static readonly Dictionary<Type, List<FieldInfo>> FieldsByType = new();
+        private static readonly Dictionary<Type, 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();
-            });
+            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)))
+                        .ToArray();
+                });
 
             foreach (FieldInfo field in fields)
             {
@@ -42,7 +44,7 @@
                 {
                     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);
@@ -51,7 +53,7 @@
                 {
                     childComponentType = fieldType.GenericTypeArguments[0];
                     Type constructedListType = typeof(List<>).MakeGenericType(childComponentType);
-                    IList instance = (IList) Activator.CreateInstance(constructedListType);
+                    IList instance = (IList)Activator.CreateInstance(constructedListType);
 
                     foundChild = false;
                     foreach (Component childComponent in component.GetComponentsInChildren(childComponentType, true))
@@ -74,7 +76,10 @@
 
                 if (!foundChild)
                 {
-                    if (field.GetCustomAttributes(typeof(ChildComponentAttribute), false)[0] is ChildComponentAttribute { optional: false } _)
+                    if (field.GetCustomAttributes(typeof(ChildComponentAttribute), false)[0] is ChildComponentAttribute
+                        {
+                            optional: false
+                        } _)
                     {
                         component.LogError($"Unable to find child component of type {fieldType}");
                     }
@@ -82,4 +87,4 @@
             }
         }
     }
-}
+}

package/Runtime/Core/Attributes/ParentComponent.cs

@@ -18,18 +18,20 @@
 
     public static class ParentComponentExtensions
     {
-        private static readonly Dictionary<Type, List<FieldInfo>> FieldsByType = new();
+        private static readonly Dictionary<Type, FieldInfo[]> FieldsByType = new();
 
         public static void AssignParentComponents(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(ParentComponentAttribute)))
-                    .ToList();
-            });
+            FieldInfo[] fields = FieldsByType.GetOrAdd(
+                componentType, type =>
+                {
+                    FieldInfo[] fields = type.GetFields(
+                        BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
+                    return fields
+                        .Where(prop => Attribute.IsDefined(prop, typeof(ParentComponentAttribute)))
+                        .ToArray();
+                });
 
             foreach (FieldInfo field in fields)
             {
@@ -42,7 +44,7 @@
                 {
                     Component[] parentComponents = component.GetComponentsInParent(parentComponentType, true);
                     foundParent = 0 < parentComponents.Length;
- 
+
                     Array correctTypedArray = Array.CreateInstance(parentComponentType, parentComponents.Length);
                     Array.Copy(parentComponents, correctTypedArray, parentComponents.Length);
                     field.SetValue(component, correctTypedArray);
@@ -51,7 +53,7 @@
                 {
                     parentComponentType = fieldType.GenericTypeArguments[0];
                     Type constructedListType = typeof(List<>).MakeGenericType(parentComponentType);
-                    IList instance = (IList) Activator.CreateInstance(constructedListType);
+                    IList instance = (IList)Activator.CreateInstance(constructedListType);
 
                     foundParent = false;
                     foreach (Component parentComponent in component.GetComponentsInParent(parentComponentType, true))
@@ -74,7 +76,8 @@
 
                 if (!foundParent)
                 {
-                    if (field.GetCustomAttributes(typeof(ParentComponentAttribute), false)[0] is ParentComponentAttribute { optional: false } _)
+                    if (field.GetCustomAttributes(typeof(ParentComponentAttribute), false)[0] is
+                        ParentComponentAttribute { optional: false } _)
                     {
                         component.LogError($"Unable to find parent component of type {fieldType}");
                     }
@@ -82,4 +85,4 @@
             }
         }
     }
-}
+}

package/Runtime/Core/Attributes/SiblingComponentAttribute.cs

@@ -18,18 +18,20 @@
 
     public static class SiblingComponentExtensions
     {
-        private static readonly Dictionary<Type, List<FieldInfo>> FieldsByType = new();
+        private static readonly Dictionary<Type, FieldInfo[]> FieldsByType = new();
 
         public static void AssignSiblingComponents(this Component component)
         {
             Type componentType = component.GetType();
-            List<FieldInfo> fields = FieldsByType.GetOrAdd(componentType,
+            FieldInfo[] fields = FieldsByType.GetOrAdd(
+                componentType,
                 type =>
                 {
-                    FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
+                    FieldInfo[] fields = type.GetFields(
+                        BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
                     return fields
                         .Where(prop => Attribute.IsDefined(prop, typeof(SiblingComponentAttribute)))
-                        .ToList();
+                        .ToArray();
                 });
 
             foreach (FieldInfo field in fields)
@@ -52,7 +54,7 @@
                 {
                     siblingComponentType = fieldType.GenericTypeArguments[0];
                     Type constructedListType = typeof(List<>).MakeGenericType(siblingComponentType);
-                    IList instance = (IList) Activator.CreateInstance(constructedListType);
+                    IList instance = (IList)Activator.CreateInstance(constructedListType);
 
                     foundSibling = false;
                     foreach (Component siblingComponent in component.GetComponents(siblingComponentType))
@@ -78,7 +80,8 @@
 
                 if (!foundSibling)
                 {
-                    if (field.GetCustomAttributes(typeof(SiblingComponentAttribute), false)[0] is SiblingComponentAttribute {optional: false} _)
+                    if (field.GetCustomAttributes(typeof(SiblingComponentAttribute), false)[0] is
+                        SiblingComponentAttribute { optional: false } _)
                     {
                         component.LogError($"Unable to find sibling component of type {fieldType}");
                     }
@@ -86,4 +89,4 @@
             }
         }
     }
-}
+}

package/Runtime/Core/Attributes/ValidateAssignmentAttribute.cs

@@ -12,21 +12,26 @@
 
     [AttributeUsage(AttributeTargets.Field)]
     [MeansImplicitUse]
-    public sealed class ValidateAssignmentAttribute : Attribute
-    {
-    }
+    public sealed class ValidateAssignmentAttribute : Attribute { }
 
     public static class ValidateAssignmentExtensions
     {
-        private static readonly Dictionary<Type, List<FieldInfo>> FieldsByType = new();
+        private static readonly Dictionary<Type, FieldInfo[]> FieldsByType = new();
+
+        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());
+        }
 
         public static void ValidateAssignments(this Object o)
         {
 #if UNITY_EDITOR
             Type objectType = o.GetType();
-            List<FieldInfo> fields = FieldsByType.GetOrAdd(objectType, type => type
-                .GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
-                .Where(prop => Attribute.IsDefined(prop, typeof(ValidateAssignmentAttribute))).ToList());
+            FieldInfo[] fields = GetOrAdd(objectType);
 
             foreach (FieldInfo field in fields)
             {
@@ -43,24 +48,48 @@
         public static bool AreAnyAssignmentsInvalid(this Object o)
         {
             Type objectType = o.GetType();
-            List<FieldInfo> fields = FieldsByType.GetOrAdd(objectType, type => type
-                .GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
-                .Where(prop => Attribute.IsDefined(prop, typeof(ValidateAssignmentAttribute))).ToList());
+            FieldInfo[] fields = GetOrAdd(objectType);
 
-            return fields.Any(field => IsFieldInvalid(field, o));
+            foreach (FieldInfo field in fields)
+            {
+                if (IsFieldInvalid(field, o))
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        private static bool IsInvalid(IEnumerable enumerable)
+        {
+            IEnumerator enumerator = enumerable.GetEnumerator();
+            try
+            {
+                return !enumerator.MoveNext();
+            }
+            finally
+            {
+                if (enumerator is IDisposable disposable)
+                {
+                    disposable.Dispose();
+                }
+            }
         }
 
         private static bool IsFieldInvalid(FieldInfo field, Object o)
         {
             object fieldValue = field.GetValue(o);
+
             return fieldValue switch
             {
-                IList list => list.Count <= 0,
-                ICollection collection => collection.Count <= 0,
                 Object unityObject => !unityObject,
                 string stringValue => string.IsNullOrWhiteSpace(stringValue),
+                IList list => list.Count <= 0,
+                ICollection collection => collection.Count <= 0,
+                IEnumerable enumerable => IsInvalid(enumerable),
                 _ => fieldValue == null
             };
         }
     }
-}
+}

package/Runtime/Core/Extension/StringExtensions.cs

@@ -1,10 +1,14 @@
 namespace UnityHelpers.Core.Extension
 {
+    using System.Collections.Generic;
     using System.Text;
     using Serialization;
 
     public static class StringExtensions
     {
+        private static readonly HashSet<char> PascalCaseSeparators =
+            new() { '_', ' ', '\r', '\n', '\t', '.', '\'', '"' };
+
         public static string Center(this string input, int length)
         {
             if (input == null || length <= input.Length)
@@ -17,12 +21,12 @@
 
         public static byte[] GetBytes(this string input)
         {
-            return System.Text.Encoding.Default.GetBytes(input);
+            return Encoding.Default.GetBytes(input);
         }
 
         public static string GetString(this byte[] bytes)
         {
-            return System.Text.Encoding.Default.GetString(bytes);
+            return Encoding.Default.GetString(bytes);
         }
 
         public static string ToJson<T>(this T value)
@@ -34,29 +38,66 @@
         {
             int startIndex = 0;
             StringBuilder stringBuilder = new();
+            bool appendedAnySeparator = false;
             for (int i = 0; i < value.Length; ++i)
             {
-                if (startIndex < i && char.IsLower(value[i - 1]) && char.IsUpper(value[i]))
+                while (startIndex < value.Length && PascalCaseSeparators.Contains(value[startIndex]))
+                {
+                    ++startIndex;
+                }
+
+                if (startIndex < i && char.IsLower(value[i - 1]) &&
+                    (char.IsUpper(value[i]) || PascalCaseSeparators.Contains(value[i])))
                 {
                     _ = stringBuilder.Append(char.ToUpper(value[startIndex]));
                     if (1 < i - startIndex)
                     {
-                        _ = stringBuilder.Append(value.Substring(startIndex + 1, i - 1 - startIndex).ToLower());
+                        for (int j = startIndex + 1; j < i; ++j)
+                        {
+                            char current = value[j];
+                            if (PascalCaseSeparators.Contains(current))
+                            {
+                                continue;
+                            }
+
+                            _ = stringBuilder.Append(char.ToLower(current));
+                        }
+                    }
+
+                    if (!string.IsNullOrEmpty(separator))
+                    {
+                        appendedAnySeparator = true;
+                        _ = stringBuilder.Append(separator);
                     }
 
-                    _ = stringBuilder.Append(separator);
                     startIndex = i;
                     continue;
                 }
 
-                if (startIndex + 1 < i && char.IsLower(value[i]) && char.IsUpper(value[i - 1]))
+                if (startIndex + 1 < i && char.IsLower(value[i]) &&
+                    (char.IsUpper(value[i - 1]) || PascalCaseSeparators.Contains(value[i - 1])))
                 {
                     _ = stringBuilder.Append(char.ToUpper(value[startIndex]));
                     if (1 < i - 1 - startIndex)
                     {
-                        _ = stringBuilder.Append(value.Substring(startIndex + 1, i - 1 - startIndex).ToLower());
+                        for (int j = startIndex + 1; j < i; ++j)
+                        {
+                            char current = value[j];
+                            if (PascalCaseSeparators.Contains(current))
+                            {
+                                continue;
+                            }
+
+                            _ = stringBuilder.Append(char.ToLower(current));
+                        }
+                    }
+
+                    if (!string.IsNullOrEmpty(separator))
+                    {
+                        appendedAnySeparator = true;
+                        _ = stringBuilder.Append(separator);
                     }
-                    _ = stringBuilder.Append(separator);
+
                     startIndex = i - 1;
                 }
             }
@@ -66,11 +107,25 @@
                 _ = stringBuilder.Append(char.ToUpper(value[startIndex]));
                 if (startIndex + 1 < value.Length)
                 {
-                    _ = stringBuilder.Append(value.Substring(startIndex + 1, value.Length - 1 - startIndex).ToLower());
+                    for (int j = startIndex + 1; j < value.Length; ++j)
+                    {
+                        char current = value[j];
+                        if (PascalCaseSeparators.Contains(current))
+                        {
+                            continue;
+                        }
+
+                        _ = stringBuilder.Append(char.ToLower(current));
+                    }
                 }
             }
+            else if (appendedAnySeparator && !string.IsNullOrEmpty(separator) &&
+                     separator.Length <= stringBuilder.Length)
+            {
+                stringBuilder.Remove(stringBuilder.Length - separator.Length, separator.Length);
+            }
 
             return stringBuilder.ToString();
         }
     }
-}
+}

package/Runtime/Core/Helper/Helpers.cs

@@ -55,7 +55,9 @@
 
             if (log)
             {
-                component.LogWarn("Failed to find {0} on {1} (name: {2}), id [{3}].", typeof(T).Name, tag, gameObject.name, gameObject.GetInstanceID());
+                component.LogWarn(
+                    "Failed to find {0} on {1} (name: {2}), id [{3}].", typeof(T).Name, tag, gameObject.name,
+                    gameObject.GetInstanceID());
             }
 
             return default;
@@ -111,9 +113,9 @@
             }
         }
 
-        public static bool HasComponent<T>(this Object unityObject)
+        public static bool HasComponent<T>(this Object unityObject) where T : Object
         {
-            return (unityObject) switch
+            return unityObject switch
             {
                 GameObject go => go.HasComponent<T>(),
                 Component component => component.HasComponent<T>(),
@@ -121,12 +123,12 @@
             };
         }
 
-        public static bool HasComponent<T>(this Component component)
+        public static bool HasComponent<T>(this Component component) where T : Object
         {
             return component.TryGetComponent<T>(out _);
         }
 
-        public static bool HasComponent<T>(this GameObject gameObject)
+        public static bool HasComponent<T>(this GameObject gameObject) where T : Object
         {
             return gameObject.TryGetComponent<T>(out _);
         }
@@ -162,7 +164,8 @@
             }
         }
 
-        public static IEnumerable<GameObject> IterateOverChildGameObjectsRecursivelyIncludingSelf(this GameObject gameObject)
+        public static IEnumerable<GameObject> IterateOverChildGameObjectsRecursivelyIncludingSelf(
+            this GameObject gameObject)
         {
             yield return gameObject;
 
@@ -186,7 +189,8 @@
             }
         }
 
-        public static IEnumerable<GameObject> IterateOverParentGameObjectsRecursivelyIncludingSelf(this GameObject gameObject)
+        public static IEnumerable<GameObject> IterateOverParentGameObjectsRecursivelyIncludingSelf(
+            this GameObject gameObject)
         {
             yield return gameObject;
 
@@ -225,7 +229,8 @@
             }
         }
 
-        public static void EnableRendererRecursively<T>(this Component component, bool enabled,
+        public static void EnableRendererRecursively<T>(
+            this Component component, bool enabled,
             Func<T, bool> exclude = null) where T : Renderer
         {
             if (component == null)
@@ -388,31 +393,36 @@
             }
         }
 
-        public static void DestroyAllChildrenGameObjectsImmediatelyConditionally(this GameObject gameObject,
+        public static void DestroyAllChildrenGameObjectsImmediatelyConditionally(
+            this GameObject gameObject,
             Func<GameObject, bool> acceptancePredicate)
         {
-            InternalDestroyAllChildrenGameObjects(gameObject, toDestroy =>
-            {
-                if (!acceptancePredicate(toDestroy))
+            InternalDestroyAllChildrenGameObjects(
+                gameObject, toDestroy =>
                 {
-                    return;
-                }
+                    if (!acceptancePredicate(toDestroy))
+                    {
+                        return;
+                    }
 
-                Object.DestroyImmediate(toDestroy);
-            });
+                    Object.DestroyImmediate(toDestroy);
+                });
         }
 
-        public static void DestroyAllChildGameObjectsConditionally(this GameObject gameObject,
+        public static void DestroyAllChildGameObjectsConditionally(
+            this GameObject gameObject,
             Func<GameObject, bool> acceptancePredicate)
         {
-            InternalDestroyAllChildrenGameObjects(gameObject, toDestroy =>
-            {
-                if (!acceptancePredicate(toDestroy))
+            InternalDestroyAllChildrenGameObjects(
+                gameObject, toDestroy =>
                 {
-                    return;
-                }
-                toDestroy.Destroy();
-            });
+                    if (!acceptancePredicate(toDestroy))
+                    {
+                        return;
+                    }
+
+                    toDestroy.Destroy();
+                });
         }
 
         public static void DestroyAllChildrenGameObjectsImmediately(this GameObject gameObject) =>
@@ -424,7 +434,8 @@
         public static void EditorDestroyAllChildrenGameObjects(this GameObject gameObject) =>
             InternalDestroyAllChildrenGameObjects(gameObject, go => go.Destroy());
 
-        private static void InternalDestroyAllChildrenGameObjects(this GameObject gameObject,
+        private static void InternalDestroyAllChildrenGameObjects(
+            this GameObject gameObject,
             Action<GameObject> destroyFunction)
         {
             for (int i = gameObject.transform.childCount - 1; 0 <= i; --i)
@@ -441,8 +452,16 @@
             {
                 return true;
             }
-#endif
+
+            return PrefabUtility.GetPrefabAssetType(gameObject) switch
+            {
+                PrefabAssetType.NotAPrefab => false,
+                PrefabAssetType.MissingAsset => scene.rootCount == 0,
+                _ => true,
+            };
+#else
             return scene.rootCount == 0;
+#endif
         }
 
         public static bool IsPrefab(this Component component)
@@ -516,7 +535,9 @@
         }
 
         // https://gamedevelopment.tutsplus.com/tutorials/unity-solution-for-hitting-moving-targets--cms-29633
-        public static Vector2 PredictCurrentTarget(this GameObject currentTarget, Vector2 launchLocation, float projectileSpeed, bool predictiveFiring, Vector2 targetVelocity)
+        public static Vector2 PredictCurrentTarget(
+            this GameObject currentTarget, Vector2 launchLocation, float projectileSpeed, bool predictiveFiring,
+            Vector2 targetVelocity)
         {
             Vector2 target = currentTarget.transform.position;
 
@@ -530,8 +551,9 @@
                 return target;
             }
 
-            float a = (targetVelocity.x * targetVelocity.x) + (targetVelocity.y * targetVelocity.y) - (projectileSpeed * projectileSpeed);
-            
+            float a = (targetVelocity.x * targetVelocity.x) + (targetVelocity.y * targetVelocity.y) -
+                      (projectileSpeed * projectileSpeed);
+
             float b = 2 * (targetVelocity.x * (target.x - launchLocation.x) +
                            targetVelocity.y * (target.y - launchLocation.y));
 
@@ -593,7 +615,7 @@
             {
                 GameObject go => go,
                 Component c => c.gameObject,
-                _ => default
+                _ => null
             };
         }
 
@@ -610,10 +632,12 @@
 
         public static GameObject FindChildGameObjectWithTag(this GameObject gameObject, string tag)
         {
-            return gameObject.IterateOverChildGameObjectsRecursivelyIncludingSelf().FirstOrDefault(child => child.CompareTag(tag));
+            return gameObject.IterateOverChildGameObjectsRecursivelyIncludingSelf()
+                .FirstOrDefault(child => child.CompareTag(tag));
         }
 
-        public static bool HasLineOfSight(Vector2 initialLocation, Vector2 direction, Transform transform, float totalDistance, float delta)
+        public static bool HasLineOfSight(
+            Vector2 initialLocation, Vector2 direction, Transform transform, float totalDistance, float delta)
         {
             int hits = Physics2D.RaycastNonAlloc(initialLocation, direction, Buffers.RaycastHits);
             for (int i = 0; i < hits; ++i)
@@ -634,7 +658,9 @@
             return true;
         }
 
-        public static Coroutine StartFunctionAsCoroutine(this MonoBehaviour monoBehaviour, Action action, float updateRate, bool useJitter = false, bool waitBefore = false)
+        public static Coroutine StartFunctionAsCoroutine(
+            this MonoBehaviour monoBehaviour, Action action, float updateRate, bool useJitter = false,
+            bool waitBefore = false)
         {
             return monoBehaviour.StartCoroutine(FunctionAsCoroutine(action, updateRate, useJitter, waitBefore));
         }
@@ -642,30 +668,51 @@
         private static IEnumerator FunctionAsCoroutine(Action action, float updateRate, bool useJitter, bool waitBefore)
         {
             bool usedJitter = false;
-            WaitForSeconds wait = new(updateRate);
-
             while (true)
             {
+                float startTime;
                 if (waitBefore)
                 {
-                    // Copy-pasta the code, no way to unify in a performant way without generating garbage
-                    yield return wait;
                     if (useJitter && !usedJitter)
                     {
-                        yield return new WaitForSeconds(PcgRandom.Instance.NextFloat(updateRate));
+                        float delay = PcgRandom.Instance.NextFloat(updateRate);
+                        startTime = Time.time;
+                        while (!HasEnoughTimePassed(startTime, delay))
+                        {
+                            yield return null;
+                        }
+
                         usedJitter = true;
                     }
+
+                    startTime = Time.time;
+                    while (!HasEnoughTimePassed(startTime, updateRate))
+                    {
+                        yield return null;
+                    }
                 }
 
                 action();
+
                 if (!waitBefore)
                 {
-                    yield return wait;
                     if (useJitter && !usedJitter)
                     {
-                        yield return new WaitForSeconds(PcgRandom.Instance.NextFloat(updateRate));
+                        float delay = PcgRandom.Instance.NextFloat(updateRate);
+                        startTime = Time.time;
+                        while (!HasEnoughTimePassed(startTime, delay))
+                        {
+                            yield return null;
+                        }
+
                         usedJitter = true;
                     }
+
+                    startTime = Time.time;
+                    while (!HasEnoughTimePassed(startTime, updateRate))
+                    {
+                        yield return null;
+                    }
                 }
             }
         }
@@ -727,6 +774,7 @@
             {
                 yield return null;
             }
+
             action();
         }
 
@@ -736,7 +784,8 @@
             action();
         }
 
-        public static bool HasEnoughTimePassed(float timestamp, float desiredDuration) => timestamp + desiredDuration < Time.time;
+        public static bool HasEnoughTimePassed(float timestamp, float desiredDuration) =>
+            timestamp + desiredDuration < Time.time;
 
         public static Vector2 Opposite(this Vector2 vector)
         {
@@ -774,12 +823,12 @@
 
         public static Vector3Int AsVector3Int(this (uint x, uint y, uint z) vector)
         {
-            return new Vector3Int((int) vector.x, (int) vector.y, (int) vector.z);
+            return new Vector3Int((int)vector.x, (int)vector.y, (int)vector.z);
         }
 
         public static Vector3Int AsVector3Int(this Vector3 vector)
         {
-            return new Vector3Int((int) Math.Round(vector.x), (int) Math.Round(vector.y), (int) Math.Round(vector.z));
+            return new Vector3Int((int)Math.Round(vector.x), (int)Math.Round(vector.y), (int)Math.Round(vector.z));
         }
 
         public static Vector3 AsVector3(this (uint x, uint y, uint z) vector)
@@ -829,7 +878,7 @@
             }
 
             foreach (FieldInfo field in type.GetFields(BindingFlags.Instance | BindingFlags.NonPublic)
-                .Where(field => Attribute.IsDefined(field, typeof(SerializeField))))
+                         .Where(field => Attribute.IsDefined(field, typeof(SerializeField))))
             {
                 try
                 {
@@ -881,13 +930,15 @@
 
         public static GameObject GetTagObjectInChildHierarchy(this GameObject gameObject, string tag)
         {
-            return gameObject.IterateOverChildGameObjectsRecursivelyIncludingSelf().FirstOrDefault(go => go.CompareTag(tag));
+            return gameObject.IterateOverChildGameObjectsRecursivelyIncludingSelf()
+                .FirstOrDefault(go => go.CompareTag(tag));
         }
 
         //https://answers.unity.com/questions/722748/refreshing-the-polygon-collider-2d-upon-sprite-cha.html
         public static void UpdateShapeToSprite(this Component component)
         {
-            if (!component.TryGetComponent(out SpriteRenderer spriteRenderer) || component.TryGetComponent(out PolygonCollider2D collider))
+            if (!component.TryGetComponent(out SpriteRenderer spriteRenderer) ||
+                component.TryGetComponent(out PolygonCollider2D collider))
             {
                 return;
             }
@@ -922,7 +973,8 @@
             return new Vector3Int(x, y, z);
         }
 
-        public static GameObject TryGetClosestParentWithComponentIncludingSelf<T>(this GameObject current) where T : Component
+        public static GameObject TryGetClosestParentWithComponentIncludingSelf<T>(this GameObject current)
+            where T : Component
         {
             while (current != null)
             {
@@ -941,7 +993,7 @@
 #if UNITY_EDITOR
         public static IEnumerable<GameObject> EnumeratePrefabs(IEnumerable<string> assetPaths = null)
         {
-            assetPaths ??= new[] {"Assets/Prefabs", "Assets/Resources"};
+            assetPaths ??= new[] { "Assets/Prefabs", "Assets/Resources" };
 
             foreach (string assetGuid in AssetDatabase.FindAssets("t:prefab", assetPaths.ToArray()))
             {
@@ -954,7 +1006,8 @@
             }
         }
 
-        public static IEnumerable<T> EnumerateScriptableObjects<T>(string[] assetPaths = null) where T : ScriptableObject
+        public static IEnumerable<T> EnumerateScriptableObjects<T>(string[] assetPaths = null)
+            where T : ScriptableObject
         {
             assetPaths ??= new[] { "Assets/Prefabs", "Assets/Resources", "Assets/TileMaps" };
 
@@ -1038,7 +1091,10 @@
         {
             foreach (MonoBehaviour script in gameObject.GetComponentsInChildren<MonoBehaviour>())
             {
-                MethodInfo awakeInfo = AwakeMethodsByType.GetOrAdd(script.GetType(), type => type.GetMethod("Awake", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic));
+                MethodInfo awakeInfo = AwakeMethodsByType.GetOrAdd(
+                    script.GetType(),
+                    type => type.GetMethod(
+                        "Awake", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic));
                 if (awakeInfo != null)
                 {
                     _ = awakeInfo.Invoke(script, null);
@@ -1093,4 +1149,4 @@
             }
         }
     }
-}
+}

package/Tests/Runtime/Extensions/StringExtensionTests.cs

@@ -0,0 +1,31 @@
+namespace UnityHelpers.Tests.Extensions
+{
+    using Core.Extension;
+    using NUnit.Framework;
+
+    public class StringExtensionTests
+    {
+        [Test]
+        public void ToPascalCaseNominal()
+        {
+            Assert.AreEqual("PascalCase", "PascalCase".ToPascalCase());
+            Assert.AreEqual("PascalCase", "pascalCase".ToPascalCase());
+            Assert.AreEqual("PascalCase", "_pascalCase".ToPascalCase());
+            Assert.AreEqual("PascalCase", "_PascalCase".ToPascalCase());
+            Assert.AreEqual("PascalCase", "pascal case".ToPascalCase());
+            Assert.AreEqual("PascalCase", "  __Pascal____   ___Case__ ".ToPascalCase());
+        }
+
+        [Test]
+        public void ToPascalCaseCustomSeparator()
+        {
+            const string separator = ".";
+            Assert.AreEqual("Pascal.Case", "PascalCase".ToPascalCase(separator));
+            Assert.AreEqual("Pascal.Case", "pascalCase".ToPascalCase(separator));
+            Assert.AreEqual("Pascal.Case", "_pascalCase".ToPascalCase(separator));
+            Assert.AreEqual("Pascal.Case", "_PascalCase".ToPascalCase(separator));
+            Assert.AreEqual("Pascal.Case", "pascal case".ToPascalCase(separator));
+            Assert.AreEqual("Pascal.Case", "  __Pascal____   ___Case__ ".ToPascalCase(separator));
+        }
+    }
+}

package/Tests/Runtime/Extensions/StringExtensionTests.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 522329788bc543aab266b1d91a8e2b47
+timeCreated: 1720391633

package/Tests/Runtime/Extensions.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 3b57270da98c4ce8bb8714dfb1603ee0
+timeCreated: 1720391613

package/Tests/Runtime/Random/RandomTestBase.cs

@@ -2,7 +2,6 @@
 {
     using System;
     using System.Collections.Generic;
-    using System.Diagnostics;
     using System.Linq;
     using NUnit.Framework;
     using UnityHelpers.Core.Random;
@@ -11,7 +10,7 @@
     {
         protected const int SampleCount = 10_000_000;
 
-        protected int[] _samples = new int[1_000];
+        protected readonly int[] _samples = new int[1_000];
 
         protected abstract IRandom NewRandom();
 
@@ -48,19 +47,23 @@
         [Test]
         public void Byte()
         {
-            TestAndVerify(random => random.NextByte(0, (byte)(_samples.Length < byte.MaxValue ? _samples.Length : byte.MaxValue)), byte.MaxValue);
+            TestAndVerify(
+                random => random.NextByte(0, (byte)(_samples.Length < byte.MaxValue ? _samples.Length : byte.MaxValue)),
+                byte.MaxValue);
         }
 
         [Test]
         public void Float()
         {
-            TestAndVerify(random => (int)Math.Floor(random.NextFloat(0, _samples.Length)));
+            TestAndVerify(
+                random => Math.Clamp((int)Math.Floor(random.NextFloat(0, _samples.Length)), 0, _samples.Length - 1));
         }
 
         [Test]
         public void Double()
         {
-            TestAndVerify(random => (int)Math.Floor(random.NextDouble(0, _samples.Length)));
+            TestAndVerify(
+                random => Math.Clamp((int)Math.Floor(random.NextDouble(0, _samples.Length)), 0, _samples.Length - 1));
         }
 
         [Test]
@@ -110,8 +113,13 @@
                 }
             }
 
-            Assert.AreEqual(0, zeroCountIndexes.Count, "No samples at {0} indices: [{1}]", zeroCountIndexes.Count, string.Join(",", zeroCountIndexes));
-            Assert.AreEqual(0, outsideRange.Count, "{0} indexes outside of dev {1:0.00}. Expected: {2:0.00}. Found: [{3}]", outsideRange.Count, deviationAllowed, average, string.Join(",", outsideRange.Select(index => _samples[index])));
+            Assert.AreEqual(
+                0, zeroCountIndexes.Count, "No samples at {0} indices: [{1}]", zeroCountIndexes.Count,
+                string.Join(",", zeroCountIndexes));
+            Assert.AreEqual(
+                0, outsideRange.Count, "{0} indexes outside of dev {1:0.00}. Expected: {2:0.00}. Found: [{3}]",
+                outsideRange.Count, deviationAllowed, average,
+                string.Join(",", outsideRange.Select(index => _samples[index])));
         }
     }
-}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "com.wallstop-studios.unity-helpers",
-  "version": "1.0.0-rc7",
+  "version": "1.0.0-rc9",
   "displayName": "Unity Helpers",
   "description": "Various Unity Helper Library",
   "dependencies": {

package/Runtime/Core/Attributes/AutomaticallyFindAttribute.cs

@@ -1,43 +0,0 @@
-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

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