com.wallstop-studios.unity-helpers 2.0.0-rc27 → 2.0.0-rc31

package/Runtime/Core/Helper/Helpers.cs

@@ -1,722 +1,722 @@
-namespace UnityHelpers.Core.Helper
-{
-    using System;
-    using System.Collections;
-    using System.Collections.Generic;
-    using System.Linq;
-    using System.Reflection;
-    using DataStructure.Adapters;
-    using Extension;
-    using Random;
-    using UnityEngine;
-    using UnityEngine.SceneManagement;
-    using Utils;
-    using Object = UnityEngine.Object;
-#if UNITY_EDITOR
-    using UnityEditor;
-    using UnityEditor.SceneManagement;
-#endif
-
-    public static partial class Helpers
-    {
-        private static readonly WaitForEndOfFrame WaitForEndOfFrame = new();
-        private static readonly Dictionary<Type, MethodInfo> AwakeMethodsByType = new();
-        private static readonly Object LogObject = new();
-        private static readonly Dictionary<string, Object> ObjectsByTag = new();
-
-        // 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
-        )
-        {
-            Vector2 target = currentTarget.transform.position;
-
-            if (!predictiveFiring)
-            {
-                return target;
-            }
-
-            if (projectileSpeed <= 0)
-            {
-                return target;
-            }
-
-            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)
-                );
-
-            float c =
-                ((target.x - launchLocation.x) * (target.x - launchLocation.x))
-                + ((target.y - launchLocation.y) * (target.y - launchLocation.y));
-
-            float disc = b * b - (4 * a * c);
-            if (disc < 0)
-            {
-                return target;
-            }
-
-            float t1 = (-1 * b + Mathf.Sqrt(disc)) / (2 * a);
-            float t2 = (-1 * b - Mathf.Sqrt(disc)) / (2 * a);
-            float t = Mathf.Max(t1, t2); // let us take the larger time value
-
-            float aimX = target.x + (targetVelocity.x * t);
-            float aimY = target.y + (targetVelocity.y * t);
-
-            if (float.IsNaN(aimX) || float.IsNaN(aimY))
-            {
-                return target;
-            }
-
-            if (float.IsInfinity(aimX) || float.IsInfinity(aimY))
-            {
-                return target;
-            }
-
-            return new Vector2(aimX, aimY);
-        }
-
-        public static T GetComponent<T>(this Object target)
-        {
-            return target switch
-            {
-                GameObject go => go.GetComponent<T>(),
-                Component c => c.GetComponent<T>(),
-                _ => default,
-            };
-        }
-
-        public static T[] GetComponents<T>(this Object target)
-        {
-            return target switch
-            {
-                GameObject go => go.GetComponents<T>(),
-                Component c => c.GetComponents<T>(),
-                _ => default,
-            };
-        }
-
-        public static GameObject GetGameObject(this object target)
-        {
-            return target switch
-            {
-                GameObject go => go,
-                Component c => c.gameObject,
-                _ => null,
-            };
-        }
-
-        public static bool TryGetComponent<T>(this Object target, out T component)
-        {
-            component = default;
-            return target switch
-            {
-                GameObject go => go.TryGetComponent(out component),
-                Component c => c.TryGetComponent(out component),
-                _ => false,
-            };
-        }
-
-        public static GameObject FindChildGameObjectWithTag(this GameObject gameObject, string tag)
-        {
-            return gameObject
-                .IterateOverChildGameObjectsRecursivelyIncludingSelf()
-                .FirstOrDefault(child => child.CompareTag(tag));
-        }
-
-        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)
-            {
-                RaycastHit2D hit = Buffers.RaycastHits[i];
-                if (hit.transform != transform)
-                {
-                    continue;
-                }
-
-                float distanceToEdge = totalDistance - hit.distance;
-                if (delta <= distanceToEdge)
-                {
-                    return false;
-                }
-            }
-
-            return true;
-        }
-
-        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)
-            );
-        }
-
-        private static IEnumerator FunctionAsCoroutine(
-            Action action,
-            float updateRate,
-            bool useJitter,
-            bool waitBefore
-        )
-        {
-            bool usedJitter = false;
-            while (true)
-            {
-                float startTime;
-                if (waitBefore)
-                {
-                    if (useJitter && !usedJitter)
-                    {
-                        float delay = PRNG.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)
-                {
-                    if (useJitter && !usedJitter)
-                    {
-                        float delay = PRNG.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;
-                    }
-                }
-            }
-        }
-
-        public static Coroutine ExecuteFunctionAfterDelay(
-            this MonoBehaviour monoBehaviour,
-            Action action,
-            float delay
-        )
-        {
-            return monoBehaviour.StartCoroutine(FunctionDelayAsCoroutine(action, delay));
-        }
-
-        public static Coroutine ExecuteFunctionNextFrame(
-            this MonoBehaviour monoBehaviour,
-            Action action
-        )
-        {
-            return monoBehaviour.ExecuteFunctionAfterDelay(action, 0f);
-        }
-
-        public static Coroutine ExecuteFunctionAfterFrame(
-            this MonoBehaviour monoBehaviour,
-            Action action
-        )
-        {
-            return monoBehaviour.StartCoroutine(FunctionAfterFrame(action));
-        }
-
-        public static IEnumerator ExecuteOverTime(
-            Action action,
-            int totalCount,
-            float duration,
-            bool delay = true
-        )
-        {
-            if (action == null)
-            {
-                yield break;
-            }
-
-            if (totalCount <= 0)
-            {
-                yield break;
-            }
-
-            int totalExecuted = 0;
-            float startTime = Time.time;
-            while (!HasEnoughTimePassed(startTime, duration))
-            {
-                float percent = (Time.time - startTime) / duration;
-                // optional delay execution from happening on 0, 1, 2, ... n-1 to 1, 2, ... n
-                if (
-                    totalExecuted < totalCount
-                    && ((totalExecuted + (delay ? 1f : 0f)) / totalCount) <= percent
-                )
-                {
-                    action();
-                    ++totalExecuted;
-                }
-
-                yield return null;
-            }
-
-            for (; totalExecuted < totalCount; )
-            {
-                action();
-                ++totalExecuted;
-                yield return null;
-            }
-        }
-
-        private static IEnumerator FunctionDelayAsCoroutine(Action action, float delay)
-        {
-            float startTime = Time.time;
-            while (!HasEnoughTimePassed(startTime, delay))
-            {
-                yield return null;
-            }
-
-            action();
-        }
-
-        private static IEnumerator FunctionAfterFrame(Action action)
-        {
-            yield return WaitForEndOfFrame;
-            action();
-        }
-
-        public static bool HasEnoughTimePassed(float timestamp, float desiredDuration) =>
-            timestamp + desiredDuration < Time.time;
-
-        public static Vector2 Opposite(this Vector2 vector)
-        {
-            return vector * -1;
-        }
-
-        public static Vector3 Opposite(this Vector3 vector)
-        {
-            return vector * -1;
-        }
-
-        public static IEnumerable<Vector3Int> IterateArea(this BoundsInt bounds)
-        {
-            foreach (Vector3Int position in bounds.allPositionsWithin)
-            {
-                yield return position;
-            }
-        }
-
-        public static IEnumerable<Vector3Int> IterateBounds(this BoundsInt bounds, int padding = 1)
-        {
-            for (int x = bounds.xMin - padding; x <= bounds.xMax + padding; ++x)
-            {
-                for (int y = bounds.yMin; y <= bounds.yMax + padding; ++y)
-                {
-                    yield return new Vector3Int(x, y, 0);
-                }
-            }
-        }
-
-        public static Vector3Int AsVector3Int(this (int x, int y, int z) vector)
-        {
-            return new Vector3Int(vector.x, vector.y, vector.z);
-        }
-
-        public static Vector3Int AsVector3Int(this (uint x, uint y, uint z) vector)
-        {
-            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)
-            );
-        }
-
-        public static Vector3 AsVector3(this (uint x, uint y, uint z) vector)
-        {
-            return new Vector3(vector.x, vector.y, vector.z);
-        }
-
-        public static Vector3 AsVector3(this Vector3Int vector)
-        {
-            return new Vector3(vector.x, vector.y, vector.z);
-        }
-
-        public static Vector2 AsVector2(this Vector3Int vector)
-        {
-            return new Vector2(vector.x, vector.y);
-        }
-
-        public static Vector2Int AsVector2Int(this Vector3Int vector)
-        {
-            return new Vector2Int(vector.x, vector.y);
-        }
-
-        public static Vector3Int AsVector3Int(this Vector2Int vector)
-        {
-            return new Vector3Int(vector.x, vector.y);
-        }
-
-        public static T CopyTo<T>(this T original, GameObject destination)
-            where T : Component
-        {
-            Type type = original.GetType();
-            T copied = destination.GetComponent(type) as T;
-            if (copied == null)
-            {
-                copied = destination.AddComponent(type) as T;
-            }
-
-            foreach (FieldInfo field in type.GetFields(BindingFlags.Instance | BindingFlags.Public))
-            {
-                try
-                {
-                    field.SetValue(copied, field.GetValue(original));
-                }
-                catch
-                {
-                    original.LogWarn("Failed to copy public field {0}.", field.Name);
-                }
-            }
-
-            foreach (
-                FieldInfo field in type.GetFields(BindingFlags.Instance | BindingFlags.NonPublic)
-                    .Where(field => Attribute.IsDefined(field, typeof(SerializeField)))
-            )
-            {
-                try
-                {
-                    field.SetValue(copied, field.GetValue(original));
-                }
-                catch
-                {
-                    original.LogWarn("Failed to copy non-public field {0}.", field.Name);
-                }
-            }
-
-            foreach (PropertyInfo property in type.GetProperties())
-            {
-                if (!property.CanWrite || property.Name == nameof(Object.name))
-                {
-                    continue;
-                }
-
-                try
-                {
-                    property.SetValue(copied, property.GetValue(original));
-                }
-                catch
-                {
-                    original.LogWarn("Failed to copy property {0}.", property.Name);
-                }
-            }
-
-            return copied;
-        }
-
-        public static Rect AsRect(this BoundsInt bounds)
-        {
-            return new Rect(bounds.x, bounds.y, bounds.size.x, bounds.size.y);
-        }
-
-        public static Vector2 GetRandomPointInCircle(
-            Vector2 center,
-            float radius,
-            IRandom random = null
-        )
-        {
-            random ??= PRNG.Instance;
-            double r = radius * Math.Sqrt(random.NextDouble());
-            double theta = random.NextDouble() * 2 * Math.PI;
-            return new Vector2(
-                center.x + (float)(r * Math.Cos(theta)),
-                center.y + (float)(r * Math.Sin(theta))
-            );
-        }
-
-        public static GameObject GetPlayerObjectInChildHierarchy(
-            this GameObject gameObject,
-            string playerTag = "Player"
-        )
-        {
-            return gameObject.GetTagObjectInChildHierarchy(playerTag);
-        }
-
-        public static GameObject GetTagObjectInChildHierarchy(
-            this GameObject gameObject,
-            string 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)
-            )
-            {
-                return;
-            }
-
-            UpdateShapeToSprite(spriteRenderer.sprite, collider);
-        }
-
-        public static void UpdateShapeToSprite(Sprite sprite, PolygonCollider2D collider)
-        {
-            if (sprite == null || collider == null)
-            {
-                return;
-            }
-
-            int pathCount = collider.pathCount = sprite.GetPhysicsShapeCount();
-
-            List<Vector2> path = new();
-            for (int i = 0; i < pathCount; ++i)
-            {
-                path.Clear();
-                _ = sprite.GetPhysicsShape(i, path);
-                collider.SetPath(i, path);
-            }
-        }
-
-        public static Vector3Int Cross(this Vector3Int vector, Vector3Int other)
-        {
-            int x = vector.y * other.z - other.y * vector.z;
-            int y = (vector.x * other.z - other.x * vector.z) * -1;
-            int z = vector.x * other.y - other.x * vector.y;
-
-            return new Vector3Int(x, y, z);
-        }
-
-        public static GameObject TryGetClosestParentWithComponentIncludingSelf<T>(
-            this GameObject current
-        )
-            where T : Component
-        {
-            while (current != null)
-            {
-                if (current.HasComponent<T>())
-                {
-                    return current;
-                }
-
-                Transform parent = current.transform.parent;
-                current = parent != null ? parent.gameObject : null;
-            }
-
-            return null;
-        }
-
-#if UNITY_EDITOR
-        public static IEnumerable<GameObject> EnumeratePrefabs(
-            IEnumerable<string> assetPaths = null
-        )
-        {
-            assetPaths ??= new[] { "Assets/Prefabs", "Assets/Resources" };
-
-            foreach (string assetGuid in AssetDatabase.FindAssets("t:prefab", assetPaths.ToArray()))
-            {
-                string path = AssetDatabase.GUIDToAssetPath(assetGuid);
-                GameObject go = AssetDatabase.LoadAssetAtPath<GameObject>(path);
-                if (go != null)
-                {
-                    yield return go;
-                }
-            }
-        }
-
-        public static IEnumerable<T> EnumerateScriptableObjects<T>(string[] assetPaths = null)
-            where T : ScriptableObject
-        {
-            assetPaths ??= new[] { "Assets/Prefabs", "Assets/Resources", "Assets/TileMaps" };
-
-            foreach (
-                string assetGuid in AssetDatabase.FindAssets("t:" + typeof(T).Name, assetPaths)
-            )
-            {
-                string path = AssetDatabase.GUIDToAssetPath(assetGuid);
-                T so = AssetDatabase.LoadAssetAtPath<T>(path);
-                if (so != null)
-                {
-                    yield return so;
-                }
-            }
-        }
-#endif
-
-        public static bool NameEquals(Object lhs, Object rhs)
-        {
-            if (lhs == rhs)
-            {
-                return true;
-            }
-
-            if (lhs == null || rhs == null)
-            {
-                return false;
-            }
-
-            if (string.Equals(lhs.name, rhs.name))
-            {
-                return true;
-            }
-
-            if (lhs.name == null || rhs.name == null)
-            {
-                return false;
-            }
-
-            const string clone = "(Clone)";
-            string lhsName = lhs.name;
-            while (lhsName.EndsWith(clone))
-            {
-                lhsName = lhsName.Substring(lhsName.Length - clone.Length - 1);
-                lhsName = lhsName.Trim();
-            }
-
-            string rhsName = rhs.name;
-            while (rhsName.EndsWith(clone))
-            {
-                rhsName = rhsName.Substring(rhsName.Length - clone.Length - 1);
-                rhsName = rhsName.Trim();
-            }
-
-            return string.Equals(lhsName, rhsName);
-        }
-
-        public static Color ChangeColorBrightness(this Color color, float correctionFactor)
-        {
-            correctionFactor = Math.Clamp(correctionFactor, -1f, 1f);
-
-            float red = color.r;
-            float green = color.g;
-            float blue = color.b;
-            if (correctionFactor < 0)
-            {
-                correctionFactor += 1;
-                red *= correctionFactor;
-                green *= correctionFactor;
-                blue *= correctionFactor;
-            }
-            else
-            {
-                red = (1f - red) * correctionFactor + red;
-                green = (1f - green) * correctionFactor + green;
-                blue = (1f - blue) * correctionFactor + blue;
-            }
-
-            return new Color(red, green, blue, color.a);
-        }
-
-        public static void AwakeObject(this GameObject gameObject)
-        {
-            foreach (MonoBehaviour script in gameObject.GetComponentsInChildren<MonoBehaviour>())
-            {
-                MethodInfo awakeInfo = AwakeMethodsByType.GetOrAdd(
-                    script.GetType(),
-                    type =>
-                        type.GetMethod(
-                            "Awake",
-                            BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic
-                        )
-                );
-                if (awakeInfo != null)
-                {
-                    _ = awakeInfo.Invoke(script, null);
-                }
-            }
-        }
-
-        public static Vector2 GetAngleWithSpeed(
-            Vector2 targetDirection,
-            Vector2 currentDirection,
-            float rotationSpeed
-        )
-        {
-            if (targetDirection == Vector2.zero)
-            {
-                return currentDirection;
-            }
-
-            float turnRatePerFrame = rotationSpeed * Time.deltaTime;
-            float angleDiscrepancy = Vector2.SignedAngle(currentDirection, targetDirection);
-            float turnRateThisFrame;
-            if (Math.Sign(angleDiscrepancy) < 0)
-            {
-                turnRateThisFrame = -1 * Math.Min(turnRatePerFrame, -angleDiscrepancy);
-            }
-            else
-            {
-                turnRateThisFrame = Math.Min(turnRatePerFrame, angleDiscrepancy);
-            }
-
-            float currentAngle = Vector2.SignedAngle(Vector2.right, currentDirection);
-            currentAngle += turnRateThisFrame;
-            return (Quaternion.AngleAxis(currentAngle, Vector3.forward) * Vector3.right).normalized;
-        }
-
-        public static void Extend2D(ref BoundsInt bounds, FastVector3Int position)
-        {
-            if (position.x < bounds.xMin)
-            {
-                bounds.xMin = position.x;
-            }
-
-            if (bounds.xMax < position.x)
-            {
-                bounds.xMax = position.x;
-            }
-
-            if (position.y < bounds.yMin)
-            {
-                bounds.yMin = position.y;
-            }
-
-            if (bounds.yMax < position.y)
-            {
-                bounds.yMax = position.y;
-            }
-        }
-    }
-}
+namespace UnityHelpers.Core.Helper
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Linq;
+    using System.Reflection;
+    using DataStructure.Adapters;
+    using Extension;
+    using Random;
+    using UnityEngine;
+    using UnityEngine.SceneManagement;
+    using Utils;
+    using Object = UnityEngine.Object;
+#if UNITY_EDITOR
+    using UnityEditor;
+    using UnityEditor.SceneManagement;
+#endif
+
+    public static partial class Helpers
+    {
+        private static readonly WaitForEndOfFrame WaitForEndOfFrame = new();
+        private static readonly Dictionary<Type, MethodInfo> AwakeMethodsByType = new();
+        private static readonly Object LogObject = new();
+        private static readonly Dictionary<string, Object> ObjectsByTag = new();
+
+        // 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
+        )
+        {
+            Vector2 target = currentTarget.transform.position;
+
+            if (!predictiveFiring)
+            {
+                return target;
+            }
+
+            if (projectileSpeed <= 0)
+            {
+                return target;
+            }
+
+            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)
+                );
+
+            float c =
+                ((target.x - launchLocation.x) * (target.x - launchLocation.x))
+                + ((target.y - launchLocation.y) * (target.y - launchLocation.y));
+
+            float disc = b * b - (4 * a * c);
+            if (disc < 0)
+            {
+                return target;
+            }
+
+            float t1 = (-1 * b + Mathf.Sqrt(disc)) / (2 * a);
+            float t2 = (-1 * b - Mathf.Sqrt(disc)) / (2 * a);
+            float t = Mathf.Max(t1, t2); // let us take the larger time value
+
+            float aimX = target.x + (targetVelocity.x * t);
+            float aimY = target.y + (targetVelocity.y * t);
+
+            if (float.IsNaN(aimX) || float.IsNaN(aimY))
+            {
+                return target;
+            }
+
+            if (float.IsInfinity(aimX) || float.IsInfinity(aimY))
+            {
+                return target;
+            }
+
+            return new Vector2(aimX, aimY);
+        }
+
+        public static T GetComponent<T>(this Object target)
+        {
+            return target switch
+            {
+                GameObject go => go.GetComponent<T>(),
+                Component c => c.GetComponent<T>(),
+                _ => default,
+            };
+        }
+
+        public static T[] GetComponents<T>(this Object target)
+        {
+            return target switch
+            {
+                GameObject go => go.GetComponents<T>(),
+                Component c => c.GetComponents<T>(),
+                _ => default,
+            };
+        }
+
+        public static GameObject GetGameObject(this object target)
+        {
+            return target switch
+            {
+                GameObject go => go,
+                Component c => c.gameObject,
+                _ => null,
+            };
+        }
+
+        public static bool TryGetComponent<T>(this Object target, out T component)
+        {
+            component = default;
+            return target switch
+            {
+                GameObject go => go.TryGetComponent(out component),
+                Component c => c.TryGetComponent(out component),
+                _ => false,
+            };
+        }
+
+        public static GameObject FindChildGameObjectWithTag(this GameObject gameObject, string tag)
+        {
+            return gameObject
+                .IterateOverChildGameObjectsRecursivelyIncludingSelf()
+                .FirstOrDefault(child => child.CompareTag(tag));
+        }
+
+        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)
+            {
+                RaycastHit2D hit = Buffers.RaycastHits[i];
+                if (hit.transform != transform)
+                {
+                    continue;
+                }
+
+                float distanceToEdge = totalDistance - hit.distance;
+                if (delta <= distanceToEdge)
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        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)
+            );
+        }
+
+        private static IEnumerator FunctionAsCoroutine(
+            Action action,
+            float updateRate,
+            bool useJitter,
+            bool waitBefore
+        )
+        {
+            bool usedJitter = false;
+            while (true)
+            {
+                float startTime;
+                if (waitBefore)
+                {
+                    if (useJitter && !usedJitter)
+                    {
+                        float delay = PRNG.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)
+                {
+                    if (useJitter && !usedJitter)
+                    {
+                        float delay = PRNG.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;
+                    }
+                }
+            }
+        }
+
+        public static Coroutine ExecuteFunctionAfterDelay(
+            this MonoBehaviour monoBehaviour,
+            Action action,
+            float delay
+        )
+        {
+            return monoBehaviour.StartCoroutine(FunctionDelayAsCoroutine(action, delay));
+        }
+
+        public static Coroutine ExecuteFunctionNextFrame(
+            this MonoBehaviour monoBehaviour,
+            Action action
+        )
+        {
+            return monoBehaviour.ExecuteFunctionAfterDelay(action, 0f);
+        }
+
+        public static Coroutine ExecuteFunctionAfterFrame(
+            this MonoBehaviour monoBehaviour,
+            Action action
+        )
+        {
+            return monoBehaviour.StartCoroutine(FunctionAfterFrame(action));
+        }
+
+        public static IEnumerator ExecuteOverTime(
+            Action action,
+            int totalCount,
+            float duration,
+            bool delay = true
+        )
+        {
+            if (action == null)
+            {
+                yield break;
+            }
+
+            if (totalCount <= 0)
+            {
+                yield break;
+            }
+
+            int totalExecuted = 0;
+            float startTime = Time.time;
+            while (!HasEnoughTimePassed(startTime, duration))
+            {
+                float percent = (Time.time - startTime) / duration;
+                // optional delay execution from happening on 0, 1, 2, ... n-1 to 1, 2, ... n
+                if (
+                    totalExecuted < totalCount
+                    && ((totalExecuted + (delay ? 1f : 0f)) / totalCount) <= percent
+                )
+                {
+                    action();
+                    ++totalExecuted;
+                }
+
+                yield return null;
+            }
+
+            for (; totalExecuted < totalCount; )
+            {
+                action();
+                ++totalExecuted;
+                yield return null;
+            }
+        }
+
+        private static IEnumerator FunctionDelayAsCoroutine(Action action, float delay)
+        {
+            float startTime = Time.time;
+            while (!HasEnoughTimePassed(startTime, delay))
+            {
+                yield return null;
+            }
+
+            action();
+        }
+
+        private static IEnumerator FunctionAfterFrame(Action action)
+        {
+            yield return WaitForEndOfFrame;
+            action();
+        }
+
+        public static bool HasEnoughTimePassed(float timestamp, float desiredDuration) =>
+            timestamp + desiredDuration < Time.time;
+
+        public static Vector2 Opposite(this Vector2 vector)
+        {
+            return vector * -1;
+        }
+
+        public static Vector3 Opposite(this Vector3 vector)
+        {
+            return vector * -1;
+        }
+
+        public static IEnumerable<Vector3Int> IterateArea(this BoundsInt bounds)
+        {
+            foreach (Vector3Int position in bounds.allPositionsWithin)
+            {
+                yield return position;
+            }
+        }
+
+        public static IEnumerable<Vector3Int> IterateBounds(this BoundsInt bounds, int padding = 1)
+        {
+            for (int x = bounds.xMin - padding; x <= bounds.xMax + padding; ++x)
+            {
+                for (int y = bounds.yMin; y <= bounds.yMax + padding; ++y)
+                {
+                    yield return new Vector3Int(x, y, 0);
+                }
+            }
+        }
+
+        public static Vector3Int AsVector3Int(this (int x, int y, int z) vector)
+        {
+            return new Vector3Int(vector.x, vector.y, vector.z);
+        }
+
+        public static Vector3Int AsVector3Int(this (uint x, uint y, uint z) vector)
+        {
+            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)
+            );
+        }
+
+        public static Vector3 AsVector3(this (uint x, uint y, uint z) vector)
+        {
+            return new Vector3(vector.x, vector.y, vector.z);
+        }
+
+        public static Vector3 AsVector3(this Vector3Int vector)
+        {
+            return new Vector3(vector.x, vector.y, vector.z);
+        }
+
+        public static Vector2 AsVector2(this Vector3Int vector)
+        {
+            return new Vector2(vector.x, vector.y);
+        }
+
+        public static Vector2Int AsVector2Int(this Vector3Int vector)
+        {
+            return new Vector2Int(vector.x, vector.y);
+        }
+
+        public static Vector3Int AsVector3Int(this Vector2Int vector)
+        {
+            return new Vector3Int(vector.x, vector.y);
+        }
+
+        public static T CopyTo<T>(this T original, GameObject destination)
+            where T : Component
+        {
+            Type type = original.GetType();
+            T copied = destination.GetComponent(type) as T;
+            if (copied == null)
+            {
+                copied = destination.AddComponent(type) as T;
+            }
+
+            foreach (FieldInfo field in type.GetFields(BindingFlags.Instance | BindingFlags.Public))
+            {
+                try
+                {
+                    field.SetValue(copied, field.GetValue(original));
+                }
+                catch
+                {
+                    original.LogWarn("Failed to copy public field {0}.", field.Name);
+                }
+            }
+
+            foreach (
+                FieldInfo field in type.GetFields(BindingFlags.Instance | BindingFlags.NonPublic)
+                    .Where(field => Attribute.IsDefined(field, typeof(SerializeField)))
+            )
+            {
+                try
+                {
+                    field.SetValue(copied, field.GetValue(original));
+                }
+                catch
+                {
+                    original.LogWarn("Failed to copy non-public field {0}.", field.Name);
+                }
+            }
+
+            foreach (PropertyInfo property in type.GetProperties())
+            {
+                if (!property.CanWrite || property.Name == nameof(Object.name))
+                {
+                    continue;
+                }
+
+                try
+                {
+                    property.SetValue(copied, property.GetValue(original));
+                }
+                catch
+                {
+                    original.LogWarn("Failed to copy property {0}.", property.Name);
+                }
+            }
+
+            return copied;
+        }
+
+        public static Rect AsRect(this BoundsInt bounds)
+        {
+            return new Rect(bounds.x, bounds.y, bounds.size.x, bounds.size.y);
+        }
+
+        public static Vector2 GetRandomPointInCircle(
+            Vector2 center,
+            float radius,
+            IRandom random = null
+        )
+        {
+            random ??= PRNG.Instance;
+            double r = radius * Math.Sqrt(random.NextDouble());
+            double theta = random.NextDouble() * 2 * Math.PI;
+            return new Vector2(
+                center.x + (float)(r * Math.Cos(theta)),
+                center.y + (float)(r * Math.Sin(theta))
+            );
+        }
+
+        public static GameObject GetPlayerObjectInChildHierarchy(
+            this GameObject gameObject,
+            string playerTag = "Player"
+        )
+        {
+            return gameObject.GetTagObjectInChildHierarchy(playerTag);
+        }
+
+        public static GameObject GetTagObjectInChildHierarchy(
+            this GameObject gameObject,
+            string 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)
+            )
+            {
+                return;
+            }
+
+            UpdateShapeToSprite(spriteRenderer.sprite, collider);
+        }
+
+        public static void UpdateShapeToSprite(Sprite sprite, PolygonCollider2D collider)
+        {
+            if (sprite == null || collider == null)
+            {
+                return;
+            }
+
+            int pathCount = collider.pathCount = sprite.GetPhysicsShapeCount();
+
+            List<Vector2> path = new();
+            for (int i = 0; i < pathCount; ++i)
+            {
+                path.Clear();
+                _ = sprite.GetPhysicsShape(i, path);
+                collider.SetPath(i, path);
+            }
+        }
+
+        public static Vector3Int Cross(this Vector3Int vector, Vector3Int other)
+        {
+            int x = vector.y * other.z - other.y * vector.z;
+            int y = (vector.x * other.z - other.x * vector.z) * -1;
+            int z = vector.x * other.y - other.x * vector.y;
+
+            return new Vector3Int(x, y, z);
+        }
+
+        public static GameObject TryGetClosestParentWithComponentIncludingSelf<T>(
+            this GameObject current
+        )
+            where T : Component
+        {
+            while (current != null)
+            {
+                if (current.HasComponent<T>())
+                {
+                    return current;
+                }
+
+                Transform parent = current.transform.parent;
+                current = parent != null ? parent.gameObject : null;
+            }
+
+            return null;
+        }
+
+#if UNITY_EDITOR
+        public static IEnumerable<GameObject> EnumeratePrefabs(
+            IEnumerable<string> assetPaths = null
+        )
+        {
+            assetPaths ??= new[] { "Assets/Prefabs", "Assets/Resources" };
+
+            foreach (string assetGuid in AssetDatabase.FindAssets("t:prefab", assetPaths.ToArray()))
+            {
+                string path = AssetDatabase.GUIDToAssetPath(assetGuid);
+                GameObject go = AssetDatabase.LoadAssetAtPath<GameObject>(path);
+                if (go != null)
+                {
+                    yield return go;
+                }
+            }
+        }
+
+        public static IEnumerable<T> EnumerateScriptableObjects<T>(string[] assetPaths = null)
+            where T : ScriptableObject
+        {
+            assetPaths ??= new[] { "Assets/Prefabs", "Assets/Resources", "Assets/TileMaps" };
+
+            foreach (
+                string assetGuid in AssetDatabase.FindAssets("t:" + typeof(T).Name, assetPaths)
+            )
+            {
+                string path = AssetDatabase.GUIDToAssetPath(assetGuid);
+                T so = AssetDatabase.LoadAssetAtPath<T>(path);
+                if (so != null)
+                {
+                    yield return so;
+                }
+            }
+        }
+#endif
+
+        public static bool NameEquals(Object lhs, Object rhs)
+        {
+            if (lhs == rhs)
+            {
+                return true;
+            }
+
+            if (lhs == null || rhs == null)
+            {
+                return false;
+            }
+
+            if (string.Equals(lhs.name, rhs.name))
+            {
+                return true;
+            }
+
+            if (lhs.name == null || rhs.name == null)
+            {
+                return false;
+            }
+
+            const string clone = "(Clone)";
+            string lhsName = lhs.name;
+            while (lhsName.EndsWith(clone))
+            {
+                lhsName = lhsName.Substring(lhsName.Length - clone.Length - 1);
+                lhsName = lhsName.Trim();
+            }
+
+            string rhsName = rhs.name;
+            while (rhsName.EndsWith(clone))
+            {
+                rhsName = rhsName.Substring(rhsName.Length - clone.Length - 1);
+                rhsName = rhsName.Trim();
+            }
+
+            return string.Equals(lhsName, rhsName);
+        }
+
+        public static Color ChangeColorBrightness(this Color color, float correctionFactor)
+        {
+            correctionFactor = Math.Clamp(correctionFactor, -1f, 1f);
+
+            float red = color.r;
+            float green = color.g;
+            float blue = color.b;
+            if (correctionFactor < 0)
+            {
+                correctionFactor += 1;
+                red *= correctionFactor;
+                green *= correctionFactor;
+                blue *= correctionFactor;
+            }
+            else
+            {
+                red = (1f - red) * correctionFactor + red;
+                green = (1f - green) * correctionFactor + green;
+                blue = (1f - blue) * correctionFactor + blue;
+            }
+
+            return new Color(red, green, blue, color.a);
+        }
+
+        public static void AwakeObject(this GameObject gameObject)
+        {
+            foreach (MonoBehaviour script in gameObject.GetComponentsInChildren<MonoBehaviour>())
+            {
+                MethodInfo awakeInfo = AwakeMethodsByType.GetOrAdd(
+                    script.GetType(),
+                    type =>
+                        type.GetMethod(
+                            "Awake",
+                            BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic
+                        )
+                );
+                if (awakeInfo != null)
+                {
+                    _ = awakeInfo.Invoke(script, null);
+                }
+            }
+        }
+
+        public static Vector2 GetAngleWithSpeed(
+            Vector2 targetDirection,
+            Vector2 currentDirection,
+            float rotationSpeed
+        )
+        {
+            if (targetDirection == Vector2.zero)
+            {
+                return currentDirection;
+            }
+
+            float turnRatePerFrame = rotationSpeed * Time.deltaTime;
+            float angleDiscrepancy = Vector2.SignedAngle(currentDirection, targetDirection);
+            float turnRateThisFrame;
+            if (Math.Sign(angleDiscrepancy) < 0)
+            {
+                turnRateThisFrame = -1 * Math.Min(turnRatePerFrame, -angleDiscrepancy);
+            }
+            else
+            {
+                turnRateThisFrame = Math.Min(turnRatePerFrame, angleDiscrepancy);
+            }
+
+            float currentAngle = Vector2.SignedAngle(Vector2.right, currentDirection);
+            currentAngle += turnRateThisFrame;
+            return (Quaternion.AngleAxis(currentAngle, Vector3.forward) * Vector3.right).normalized;
+        }
+
+        public static void Extend2D(ref BoundsInt bounds, FastVector3Int position)
+        {
+            if (position.x < bounds.xMin)
+            {
+                bounds.xMin = position.x;
+            }
+
+            if (bounds.xMax < position.x)
+            {
+                bounds.xMax = position.x;
+            }
+
+            if (position.y < bounds.yMin)
+            {
+                bounds.yMin = position.y;
+            }
+
+            if (bounds.yMax < position.y)
+            {
+                bounds.yMax = position.y;
+            }
+        }
+    }
+}