com.wallstop-studios.unity-helpers 2.0.0-rc05 → 2.0.0-rc07

package/Runtime/Core/Helper/Helpers.cs

@@ -1,543 +1,37 @@
 namespace UnityHelpers.Core.Helper
 {
-    using Extension;
     using System;
     using System.Collections;
     using System.Collections.Generic;
     using System.Linq;
     using System.Reflection;
     using DataStructure.Adapters;
+    using Extension;
     using Random;
-#if UNITY_EDITOR
-    using UnityEditor;
-    using UnityEditor.SceneManagement;
-#endif
     using UnityEngine;
     using UnityEngine.SceneManagement;
     using Utils;
     using Object = UnityEngine.Object;
+#if UNITY_EDITOR
+    using UnityEditor;
+    using UnityEditor.SceneManagement;
+#endif
 
-    public static class Helpers
+    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();
 
-        public static T Find<T>(this Object component, string tag, bool log = true) where T : Object
-        {
-            if (ObjectsByTag.TryGetValue(tag, out Object value))
-            {
-                if (value != null && value is T typed)
-                {
-                    return typed;
-                }
-
-                _ = ObjectsByTag.Remove(tag);
-            }
-
-            GameObject gameObject = GameObject.FindGameObjectWithTag(tag);
-            if (gameObject == null)
-            {
-                if (log)
-                {
-                    component.LogWarn("Could not find {0}.", tag);
-                }
-
-                return default;
-            }
-
-            if (gameObject.TryGetComponent(out T instance))
-            {
-                ObjectsByTag[tag] = instance;
-                return instance;
-            }
-
-            if (log)
-            {
-                component.LogWarn(
-                    "Failed to find {0} on {1} (name: {2}), id [{3}].", typeof(T).Name, tag, gameObject.name,
-                    gameObject.GetInstanceID());
-            }
-
-            return default;
-        }
-
-        public static T Find<T>(string tag, bool log = true) where T : MonoBehaviour
-        {
-            if (ObjectsByTag.TryGetValue(tag, out Object value))
-            {
-                if (value != null && value is T typed)
-                {
-                    return typed;
-                }
-
-                _ = ObjectsByTag.Remove(tag);
-            }
-
-            GameObject gameObject = GameObject.FindGameObjectWithTag(tag);
-            if (gameObject == null)
-            {
-                if (log)
-                {
-                    LogObject.Log($"Could not find {tag}.");
-                }
-
-                return default;
-            }
-
-            if (gameObject.TryGetComponent(out T instance))
-            {
-                ObjectsByTag[tag] = instance;
-                return instance;
-            }
-
-            if (log)
-            {
-                LogObject.Log($"Failed to find {typeof(T).Name} on {tag}");
-            }
-
-            return default;
-        }
-
-        public static void SetInstance<T>(string tag, T instance) where T : MonoBehaviour
-        {
-            ObjectsByTag[tag] = instance;
-        }
-
-        public static void ClearInstance<T>(string tag, T instance) where T : MonoBehaviour
-        {
-            if (ObjectsByTag.TryGetValue(tag, out Object existing) && existing == instance)
-            {
-                _ = ObjectsByTag.Remove(tag);
-            }
-        }
-
-        public static bool HasComponent<T>(this Object unityObject) where T : Object
-        {
-            return unityObject switch
-            {
-                GameObject go => go.HasComponent<T>(),
-                Component component => component.HasComponent<T>(),
-                _ => false
-            };
-        }
-
-        public static bool HasComponent<T>(this Component component) where T : Object
-        {
-            return component.TryGetComponent<T>(out _);
-        }
-
-        public static bool HasComponent<T>(this GameObject gameObject) where T : Object
-        {
-            return gameObject.TryGetComponent<T>(out _);
-        }
-
-        public static bool HasComponent(this GameObject gameObject, Type type)
-        {
-            return gameObject.TryGetComponent(type, out _);
-        }
-
-        public static void LogNotAssigned(this Object component, string name)
-        {
-            component.LogWarn("{0} not found.", name);
-        }
-
-        public static IEnumerable<GameObject> IterateOverChildGameObjects(this GameObject gameObject)
-        {
-            for (int i = 0; i < gameObject.transform.childCount; i++)
-            {
-                yield return gameObject.transform.GetChild(i).gameObject;
-            }
-        }
-
-        public static IEnumerable<GameObject> IterateOverChildGameObjectsRecursively(this GameObject gameObject)
-        {
-            for (int i = 0; i < gameObject.transform.childCount; i++)
-            {
-                GameObject child = gameObject.transform.GetChild(i).gameObject;
-                yield return child;
-                foreach (GameObject go in child.IterateOverChildGameObjectsRecursively())
-                {
-                    yield return go;
-                }
-            }
-        }
-
-        public static IEnumerable<GameObject> IterateOverChildGameObjectsRecursivelyIncludingSelf(
-            this GameObject gameObject)
-        {
-            yield return gameObject;
-
-            for (int i = 0; i < gameObject.transform.childCount; ++i)
-            {
-                GameObject child = gameObject.transform.GetChild(i).gameObject;
-                foreach (GameObject c in child.IterateOverChildGameObjectsRecursivelyIncludingSelf())
-                {
-                    yield return c;
-                }
-            }
-        }
-
-        public static IEnumerable<GameObject> IterateOverParentGameObjects(this GameObject gameObject)
-        {
-            Transform currentTransform = gameObject.transform.parent;
-            while (currentTransform != null)
-            {
-                yield return currentTransform.gameObject;
-                currentTransform = currentTransform.parent;
-            }
-        }
-
-        public static IEnumerable<GameObject> IterateOverParentGameObjectsRecursivelyIncludingSelf(
-            this GameObject gameObject)
-        {
-            yield return gameObject;
-
-            foreach (GameObject parent in IterateOverParentGameObjects(gameObject))
-            {
-                yield return parent;
-            }
-        }
-
-        public static void EnableRecursively<T>(this Component component, bool enabled, Func<T, bool> exclude = null)
-            where T : Behaviour
-        {
-            if (component == null)
-            {
-                return;
-            }
-
-            foreach (T behaviour in component.GetComponents<T>())
-            {
-                if (behaviour != null && (exclude?.Invoke(behaviour) ?? true))
-                {
-                    behaviour.enabled = enabled;
-                }
-            }
-
-            Transform transform = (component as Transform) ?? component.transform;
-            if (transform == null)
-            {
-                return;
-            }
-
-            for (int i = 0; i < transform.childCount; ++i)
-            {
-                Transform child = transform.GetChild(i);
-                EnableRecursively<T>(child, enabled);
-            }
-        }
-
-        public static void EnableRendererRecursively<T>(
-            this Component component, bool enabled,
-            Func<T, bool> exclude = null) where T : Renderer
-        {
-            if (component == null)
-            {
-                return;
-            }
-
-            T behavior = component as T ?? component.GetComponent<T>();
-            if (behavior != null && (exclude?.Invoke(behavior) ?? true))
-            {
-                behavior.enabled = enabled;
-            }
-
-            Transform transform = (component as Transform) ?? component.transform;
-            if (transform == null)
-            {
-                return;
-            }
-
-            for (int i = 0; i < transform.childCount; ++i)
-            {
-                Transform child = transform.GetChild(i);
-                EnableRendererRecursively<T>(child, enabled);
-            }
-        }
-
-        public static IEnumerable<T> IterateOverAllChildComponentsRecursively<T>(this Component component)
-        {
-            if (component == null)
-            {
-                yield break;
-            }
-
-            foreach (T c in component.gameObject.GetComponents<T>())
-            {
-                yield return c;
-            }
-
-            for (int i = 0; i < component.transform.childCount; ++i)
-            {
-                Transform child = component.transform.GetChild(i);
-
-                foreach (T c in child.IterateOverAllChildComponentsRecursively<T>())
-                {
-                    yield return c;
-                }
-            }
-        }
-
-        public static IEnumerable<Transform> IterateOverAllChildren(this Component component)
-        {
-            if (component == null)
-            {
-                yield break;
-            }
-
-            for (int i = 0; i < component.transform.childCount; ++i)
-            {
-                yield return component.transform.GetChild(i);
-            }
-        }
-
-        public static IEnumerable<Transform> IterateOverAllParents(this Component component)
-        {
-            if (component == null)
-            {
-                yield break;
-            }
-
-            Transform transform = component.transform;
-            while (transform.parent != null)
-            {
-                yield return transform.parent;
-                transform = transform.parent;
-            }
-        }
-
-        public static IEnumerable<Transform> IterateOverAllParentsIncludingSelf(this Component component)
-        {
-            if (component == null)
-            {
-                yield break;
-            }
-
-            Transform transform = component.transform;
-            while (transform != null)
-            {
-                yield return transform;
-                transform = transform.parent;
-            }
-        }
-
-        public static IEnumerable<Transform> IterateOverAllChildrenRecursively(this Component component)
-        {
-            if (component == null)
-            {
-                yield break;
-            }
-
-            for (int i = 0; i < component.transform.childCount; ++i)
-            {
-                Transform childTransform = component.transform.GetChild(i);
-                yield return childTransform;
-                foreach (Transform childChildTransform in childTransform.IterateOverAllChildrenRecursively())
-                {
-                    yield return childChildTransform;
-                }
-            }
-        }
-
-        public static bool IsLeft(Vector2 a, Vector2 b, Vector2 point)
-        {
-            // http://alienryderflex.com/point_left_of_ray/
-
-            //check which side of line AB the point P is on
-            if ((b.x - a.x) * (point.y - a.y) - (point.x - a.x) * (b.y - a.y) > 0)
-            {
-                return false;
-            }
-
-            return true;
-        }
-
-        public static void DestroyAllChildrenGameObjects(this GameObject gameObject)
-        {
-            if (Application.isEditor)
-            {
-                EditorDestroyAllChildrenGameObjects(gameObject);
-            }
-            else
-            {
-                PlayDestroyAllChildrenGameObjects(gameObject);
-            }
-        }
-
-        public static void DestroyAllComponentsOfType<T>(this GameObject gameObject) where T : Component
-        {
-            foreach (T component in gameObject.GetComponents<T>())
-            {
-                SmartDestroy(component);
-            }
-        }
-
-        public static void SmartDestroy(this Object obj, float? afterTime = null)
-        {
-            if (Application.isEditor && !Application.isPlaying)
-            {
-                Object.DestroyImmediate(obj);
-            }
-            else
-            {
-                if (afterTime.HasValue)
-                {
-                    Object.Destroy(obj, afterTime.Value);
-                }
-                else
-                {
-                    Object.Destroy(obj);
-                }
-            }
-        }
-
-        public static void DestroyAllChildrenGameObjectsImmediatelyConditionally(
-            this GameObject gameObject,
-            Func<GameObject, bool> acceptancePredicate)
-        {
-            InternalDestroyAllChildrenGameObjects(
-                gameObject, toDestroy =>
-                {
-                    if (!acceptancePredicate(toDestroy))
-                    {
-                        return;
-                    }
-
-                    Object.DestroyImmediate(toDestroy);
-                });
-        }
-
-        public static void DestroyAllChildGameObjectsConditionally(
-            this GameObject gameObject,
-            Func<GameObject, bool> acceptancePredicate)
-        {
-            InternalDestroyAllChildrenGameObjects(
-                gameObject, toDestroy =>
-                {
-                    if (!acceptancePredicate(toDestroy))
-                    {
-                        return;
-                    }
-
-                    toDestroy.Destroy();
-                });
-        }
-
-        public static void DestroyAllChildrenGameObjectsImmediately(this GameObject gameObject) =>
-            InternalDestroyAllChildrenGameObjects(gameObject, Object.DestroyImmediate);
-
-        public static void PlayDestroyAllChildrenGameObjects(this GameObject gameObject) =>
-            InternalDestroyAllChildrenGameObjects(gameObject, go => go.Destroy());
-
-        public static void EditorDestroyAllChildrenGameObjects(this GameObject gameObject) =>
-            InternalDestroyAllChildrenGameObjects(gameObject, go => go.Destroy());
-
-        private static void InternalDestroyAllChildrenGameObjects(
-            this GameObject gameObject,
-            Action<GameObject> destroyFunction)
-        {
-            for (int i = gameObject.transform.childCount - 1; 0 <= i; --i)
-            {
-                destroyFunction(gameObject.transform.GetChild(i).gameObject);
-            }
-        }
-
-        public static bool IsPrefab(this GameObject gameObject)
-        {
-            Scene scene = gameObject.scene;
-#if UNITY_EDITOR
-            if (scene.rootCount == 1 && string.Equals(scene.name, gameObject.name))
-            {
-                return true;
-            }
-
-            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)
-        {
-            return IsPrefab(component.gameObject);
-        }
-
-        public static Vector2 RadianToVector2(float radian)
-        {
-            return new Vector2(Mathf.Cos(radian), Mathf.Sin(radian));
-        }
-
-        public static Vector2 DegreeToVector2(float degree)
-        {
-            return RadianToVector2(degree * Mathf.Deg2Rad);
-        }
-
-        public static T GetOrAddComponent<T>(this GameObject unityObject) where T : Component
-        {
-            if (!unityObject.TryGetComponent(out T instance))
-            {
-                instance = unityObject.AddComponent<T>();
-            }
-
-            return instance;
-        }
-
-        public static Component GetOrAddComponent(this GameObject unityObject, Type componentType)
-        {
-            if (!unityObject.TryGetComponent(componentType, out Component instance))
-            {
-                instance = unityObject.AddComponent(componentType);
-            }
-
-            return instance;
-        }
-
-        public static void ModifyAndSavePrefab(GameObject prefab, Action<GameObject> modifyAction)
-        {
-            if (prefab == null)
-            {
-                return;
-            }
-
-#if UNITY_EDITOR
-            if (PrefabUtility.IsPartOfPrefabAsset(prefab))
-            {
-                string assetPath = AssetDatabase.GetAssetPath(prefab);
-                GameObject content = PrefabUtility.LoadPrefabContents(assetPath);
-
-                if (content == null)
-                {
-                    Debug.LogError($"Unable to load {prefab} as a prefab");
-                    return;
-                }
-
-                modifyAction(content);
-                _ = PrefabUtility.SaveAsPrefabAsset(content, assetPath);
-                PrefabUtility.UnloadPrefabContents(content);
-            }
-            else
-            {
-                modifyAction(prefab);
-                PrefabStage stage = PrefabStageUtility.GetPrefabStage(prefab);
-                if (stage)
-                {
-                    _ = EditorSceneManager.MarkSceneDirty(stage.scene);
-                }
-            }
-#endif
-        }
-
         // 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)
+            this GameObject currentTarget,
+            Vector2 launchLocation,
+            float projectileSpeed,
+            bool predictiveFiring,
+            Vector2 targetVelocity
+        )
         {
             Vector2 target = currentTarget.transform.position;
 
@@ -551,17 +45,21 @@
                 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));
+            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));
+                ((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)
@@ -615,7 +113,7 @@
             {
                 GameObject go => go,
                 Component c => c.gameObject,
-                _ => null
+                _ => null,
             };
         }
 
@@ -632,12 +130,18 @@
 
         public static GameObject FindChildGameObjectWithTag(this GameObject gameObject, string tag)
         {
-            return gameObject.IterateOverChildGameObjectsRecursivelyIncludingSelf()
+            return gameObject
+                .IterateOverChildGameObjectsRecursivelyIncludingSelf()
                 .FirstOrDefault(child => child.CompareTag(tag));
         }
 
         public static bool HasLineOfSight(
-            Vector2 initialLocation, Vector2 direction, Transform transform, float totalDistance, float delta)
+            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)
@@ -659,13 +163,24 @@
         }
 
         public static Coroutine StartFunctionAsCoroutine(
-            this MonoBehaviour monoBehaviour, Action action, float updateRate, bool useJitter = false,
-            bool waitBefore = false)
+            this MonoBehaviour monoBehaviour,
+            Action action,
+            float updateRate,
+            bool useJitter = false,
+            bool waitBefore = false
+        )
         {
-            return monoBehaviour.StartCoroutine(FunctionAsCoroutine(action, updateRate, useJitter, waitBefore));
+            return monoBehaviour.StartCoroutine(
+                FunctionAsCoroutine(action, updateRate, useJitter, waitBefore)
+            );
         }
 
-        private static IEnumerator FunctionAsCoroutine(Action action, float updateRate, bool useJitter, bool waitBefore)
+        private static IEnumerator FunctionAsCoroutine(
+            Action action,
+            float updateRate,
+            bool useJitter,
+            bool waitBefore
+        )
         {
             bool usedJitter = false;
             while (true)
@@ -675,7 +190,7 @@
                 {
                     if (useJitter && !usedJitter)
                     {
-                        float delay = PcgRandom.Instance.NextFloat(updateRate);
+                        float delay = PRNG.Instance.NextFloat(updateRate);
                         startTime = Time.time;
                         while (!HasEnoughTimePassed(startTime, delay))
                         {
@@ -698,7 +213,7 @@
                 {
                     if (useJitter && !usedJitter)
                     {
-                        float delay = PcgRandom.Instance.NextFloat(updateRate);
+                        float delay = PRNG.Instance.NextFloat(updateRate);
                         startTime = Time.time;
                         while (!HasEnoughTimePassed(startTime, delay))
                         {
@@ -717,22 +232,37 @@
             }
         }
 
-        public static Coroutine ExecuteFunctionAfterDelay(this MonoBehaviour monoBehaviour, Action action, float delay)
+        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)
+        public static Coroutine ExecuteFunctionNextFrame(
+            this MonoBehaviour monoBehaviour,
+            Action action
+        )
         {
             return monoBehaviour.ExecuteFunctionAfterDelay(action, 0f);
         }
 
-        public static Coroutine ExecuteFunctionAfterFrame(this MonoBehaviour monoBehaviour, Action action)
+        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)
+        public static IEnumerator ExecuteOverTime(
+            Action action,
+            int totalCount,
+            float duration,
+            bool delay = true
+        )
         {
             if (action == null)
             {
@@ -750,7 +280,10 @@
             {
                 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)
+                if (
+                    totalExecuted < totalCount
+                    && ((totalExecuted + (delay ? 1f : 0f)) / totalCount) <= percent
+                )
                 {
                     action();
                     ++totalExecuted;
@@ -759,7 +292,7 @@
                 yield return null;
             }
 
-            for (; totalExecuted < totalCount;)
+            for (; totalExecuted < totalCount; )
             {
                 action();
                 ++totalExecuted;
@@ -828,7 +361,11 @@
 
         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)
@@ -856,7 +393,8 @@
             return new Vector3Int(vector.x, vector.y);
         }
 
-        public static T CopyTo<T>(this T original, GameObject destination) where T : Component
+        public static T CopyTo<T>(this T original, GameObject destination)
+            where T : Component
         {
             Type type = original.GetType();
             T copied = destination.GetComponent(type) as T;
@@ -877,8 +415,10 @@
                 }
             }
 
-            foreach (FieldInfo field in type.GetFields(BindingFlags.Instance | BindingFlags.NonPublic)
-                         .Where(field => Attribute.IsDefined(field, typeof(SerializeField))))
+            foreach (
+                FieldInfo field in type.GetFields(BindingFlags.Instance | BindingFlags.NonPublic)
+                    .Where(field => Attribute.IsDefined(field, typeof(SerializeField)))
+            )
             {
                 try
                 {
@@ -915,30 +455,46 @@
             return new Rect(bounds.x, bounds.y, bounds.size.x, bounds.size.y);
         }
 
-        public static Vector3 GetRandomPointInCircle(Vector2 center, float radius, IRandom random = null)
+        public static Vector2 GetRandomPointInCircle(
+            Vector2 center,
+            float radius,
+            IRandom random = null
+        )
         {
-            random ??= PcgRandom.Instance;
-            float r = radius * Mathf.Sqrt(random.NextFloat());
-            float theta = random.NextFloat() * 2 * Mathf.PI;
-            return new Vector3(center.x + r * Mathf.Cos(theta), center.y + r * Mathf.Sin(theta), 0.0f);
+            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)
+        public static GameObject GetPlayerObjectInChildHierarchy(
+            this GameObject gameObject,
+            string playerTag = "Player"
+        )
         {
-            return gameObject.GetTagObjectInChildHierarchy("Player");
+            return gameObject.GetTagObjectInChildHierarchy(playerTag);
         }
 
-        public static GameObject GetTagObjectInChildHierarchy(this GameObject gameObject, string tag)
+        public static GameObject GetTagObjectInChildHierarchy(
+            this GameObject gameObject,
+            string tag
+        )
         {
-            return gameObject.IterateOverChildGameObjectsRecursivelyIncludingSelf()
+            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;
             }
@@ -973,7 +529,9 @@
             return new Vector3Int(x, y, z);
         }
 
-        public static GameObject TryGetClosestParentWithComponentIncludingSelf<T>(this GameObject current)
+        public static GameObject TryGetClosestParentWithComponentIncludingSelf<T>(
+            this GameObject current
+        )
             where T : Component
         {
             while (current != null)
@@ -991,7 +549,9 @@
         }
 
 #if UNITY_EDITOR
-        public static IEnumerable<GameObject> EnumeratePrefabs(IEnumerable<string> assetPaths = null)
+        public static IEnumerable<GameObject> EnumeratePrefabs(
+            IEnumerable<string> assetPaths = null
+        )
         {
             assetPaths ??= new[] { "Assets/Prefabs", "Assets/Resources" };
 
@@ -1011,7 +571,9 @@
         {
             assetPaths ??= new[] { "Assets/Prefabs", "Assets/Resources", "Assets/TileMaps" };
 
-            foreach (string assetGuid in AssetDatabase.FindAssets("t:" + typeof(T).Name, assetPaths))
+            foreach (
+                string assetGuid in AssetDatabase.FindAssets("t:" + typeof(T).Name, assetPaths)
+            )
             {
                 string path = AssetDatabase.GUIDToAssetPath(assetGuid);
                 T so = AssetDatabase.LoadAssetAtPath<T>(path);
@@ -1093,8 +655,12 @@
             {
                 MethodInfo awakeInfo = AwakeMethodsByType.GetOrAdd(
                     script.GetType(),
-                    type => type.GetMethod(
-                        "Awake", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic));
+                    type =>
+                        type.GetMethod(
+                            "Awake",
+                            BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic
+                        )
+                );
                 if (awakeInfo != null)
                 {
                     _ = awakeInfo.Invoke(script, null);
@@ -1102,7 +668,11 @@
             }
         }
 
-        public static Vector2 GetAngleWithSpeed(Vector2 targetDirection, Vector2 currentDirection, float rotationSpeed)
+        public static Vector2 GetAngleWithSpeed(
+            Vector2 targetDirection,
+            Vector2 currentDirection,
+            float rotationSpeed
+        )
         {
             if (targetDirection == Vector2.zero)
             {
@@ -1149,4 +719,4 @@
             }
         }
     }
-}
+}