com.wallstop-studios.unity-helpers 2.0.0-rc56 → 2.0.0-rc58

package/Runtime/Core/Extension/DirectionExtensions.cs

@@ -1,213 +1,213 @@
-namespace UnityHelpers.Core.Extension
-{
-    using System;
-    using System.Collections.Generic;
-    using System.Linq;
-    using Helper;
-    using Model;
-    using UnityEngine;
-
-    public static class DirectionExtensions
-    {
-        private static readonly Direction[] Directions = Enum.GetValues(typeof(Direction))
-            .OfType<Direction>()
-            .Except(Enumerables.Of(Direction.None))
-            .ToArray();
-
-        public static Direction Opposite(this Direction direction)
-        {
-            switch (direction)
-            {
-                case Direction.North:
-                    return Direction.South;
-                case Direction.NorthEast:
-                    return Direction.SouthWest;
-                case Direction.East:
-                    return Direction.West;
-                case Direction.SouthEast:
-                    return Direction.NorthWest;
-                case Direction.South:
-                    return Direction.North;
-                case Direction.SouthWest:
-                    return Direction.NorthEast;
-                case Direction.West:
-                    return Direction.East;
-                case Direction.NorthWest:
-                    return Direction.SouthEast;
-                case Direction.None:
-                    return Direction.None;
-                default:
-                    throw new ArgumentException($"Unknown direction {direction}.");
-            }
-        }
-
-        public static Vector2Int AsVector2Int(this Direction direction)
-        {
-            switch (direction)
-            {
-                case Direction.None:
-                    return Vector2Int.zero;
-                case Direction.North:
-                    return Vector2Int.up;
-                case Direction.NorthEast:
-                    return new Vector2Int(1, 1);
-                case Direction.East:
-                    return Vector2Int.right;
-                case Direction.SouthEast:
-                    return new Vector2Int(1, -1);
-                case Direction.South:
-                    return Vector2Int.down;
-                case Direction.SouthWest:
-                    return new Vector2Int(-1, -1);
-                case Direction.West:
-                    return Vector2Int.left;
-                case Direction.NorthWest:
-                    return new Vector2Int(-1, 1);
-                default:
-                    throw new ArgumentException($"Unknown direction {direction}.");
-            }
-        }
-
-        public static Vector2 AsVector2(this Direction direction)
-        {
-            return direction.AsVector2Int();
-        }
-
-        public static Direction AsDirection(this Vector3 vector3)
-        {
-            return AsDirection((Vector2)vector3);
-        }
-
-        public static IEnumerable<Direction> Split(this Direction direction)
-        {
-            bool foundAny = false;
-            foreach (Direction singleDirection in Directions)
-            {
-                if (direction.HasFlag(singleDirection))
-                {
-                    foundAny = true;
-                    yield return singleDirection;
-                }
-            }
-
-            if (!foundAny)
-            {
-                yield return Direction.None;
-            }
-        }
-
-        public static Direction Combine(this IEnumerable<Direction> directions)
-        {
-            Direction combined = Direction.None;
-            foreach (Direction direction in directions)
-            {
-                combined |= direction;
-            }
-
-            return combined;
-        }
-
-        public static Direction AsDirection(this Vector2 vector, bool preferAngles = false)
-        {
-            if (vector == Vector2.zero)
-            {
-                return Direction.None;
-            }
-
-            float angle;
-            if (vector.x < 0)
-            {
-                angle = 360 - Mathf.Atan2(vector.x, vector.y) * Mathf.Rad2Deg * -1;
-            }
-            else
-            {
-                angle = Mathf.Atan2(vector.x, vector.y) * Mathf.Rad2Deg;
-            }
-
-            if (preferAngles)
-            {
-                if (345 <= angle || angle < 15)
-                {
-                    return Direction.North;
-                }
-
-                if (15 <= angle && angle < 75)
-                {
-                    return Direction.NorthEast;
-                }
-
-                if (75 <= angle && angle < 105)
-                {
-                    return Direction.East;
-                }
-
-                if (105 <= angle && angle < 165)
-                {
-                    return Direction.SouthEast;
-                }
-
-                if (165 <= angle && angle < 195)
-                {
-                    return Direction.South;
-                }
-
-                if (195 <= angle && angle < 255)
-                {
-                    return Direction.SouthWest;
-                }
-
-                if (255 <= angle && angle < 285)
-                {
-                    return Direction.West;
-                }
-
-                if (285 <= angle && angle < 345)
-                {
-                    return Direction.NorthWest;
-                }
-            }
-
-            if (337.5 <= angle || angle < 22.5)
-            {
-                return Direction.North;
-            }
-
-            if (22.5 <= angle && angle < 67.5)
-            {
-                return Direction.NorthEast;
-            }
-
-            if (67.5 <= angle && angle < 112.5)
-            {
-                return Direction.East;
-            }
-
-            if (112.5 <= angle && angle < 157.5)
-            {
-                return Direction.SouthEast;
-            }
-
-            if (157.5 <= angle && angle < 202.5)
-            {
-                return Direction.South;
-            }
-
-            if (202.5 <= angle && angle < 247.5)
-            {
-                return Direction.SouthWest;
-            }
-
-            if (247.5 <= angle && angle < 292.5)
-            {
-                return Direction.West;
-            }
-
-            if (292.5 <= angle && angle < 337.5)
-            {
-                return Direction.NorthWest;
-            }
-
-            return Direction.None;
-        }
-    }
-}
+namespace UnityHelpers.Core.Extension
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using Helper;
+    using Model;
+    using UnityEngine;
+
+    public static class DirectionExtensions
+    {
+        private static readonly Direction[] Directions = Enum.GetValues(typeof(Direction))
+            .OfType<Direction>()
+            .Except(Enumerables.Of(Direction.None))
+            .ToArray();
+
+        public static Direction Opposite(this Direction direction)
+        {
+            switch (direction)
+            {
+                case Direction.North:
+                    return Direction.South;
+                case Direction.NorthEast:
+                    return Direction.SouthWest;
+                case Direction.East:
+                    return Direction.West;
+                case Direction.SouthEast:
+                    return Direction.NorthWest;
+                case Direction.South:
+                    return Direction.North;
+                case Direction.SouthWest:
+                    return Direction.NorthEast;
+                case Direction.West:
+                    return Direction.East;
+                case Direction.NorthWest:
+                    return Direction.SouthEast;
+                case Direction.None:
+                    return Direction.None;
+                default:
+                    throw new ArgumentException($"Unknown direction {direction}.");
+            }
+        }
+
+        public static Vector2Int AsVector2Int(this Direction direction)
+        {
+            switch (direction)
+            {
+                case Direction.None:
+                    return Vector2Int.zero;
+                case Direction.North:
+                    return Vector2Int.up;
+                case Direction.NorthEast:
+                    return new Vector2Int(1, 1);
+                case Direction.East:
+                    return Vector2Int.right;
+                case Direction.SouthEast:
+                    return new Vector2Int(1, -1);
+                case Direction.South:
+                    return Vector2Int.down;
+                case Direction.SouthWest:
+                    return new Vector2Int(-1, -1);
+                case Direction.West:
+                    return Vector2Int.left;
+                case Direction.NorthWest:
+                    return new Vector2Int(-1, 1);
+                default:
+                    throw new ArgumentException($"Unknown direction {direction}.");
+            }
+        }
+
+        public static Vector2 AsVector2(this Direction direction)
+        {
+            return direction.AsVector2Int();
+        }
+
+        public static Direction AsDirection(this Vector3 vector3)
+        {
+            return AsDirection((Vector2)vector3);
+        }
+
+        public static IEnumerable<Direction> Split(this Direction direction)
+        {
+            bool foundAny = false;
+            foreach (Direction singleDirection in Directions)
+            {
+                if (direction.HasFlag(singleDirection))
+                {
+                    foundAny = true;
+                    yield return singleDirection;
+                }
+            }
+
+            if (!foundAny)
+            {
+                yield return Direction.None;
+            }
+        }
+
+        public static Direction Combine(this IEnumerable<Direction> directions)
+        {
+            Direction combined = Direction.None;
+            foreach (Direction direction in directions)
+            {
+                combined |= direction;
+            }
+
+            return combined;
+        }
+
+        public static Direction AsDirection(this Vector2 vector, bool preferAngles = false)
+        {
+            if (vector == Vector2.zero)
+            {
+                return Direction.None;
+            }
+
+            float angle;
+            if (vector.x < 0)
+            {
+                angle = 360 - Mathf.Atan2(vector.x, vector.y) * Mathf.Rad2Deg * -1;
+            }
+            else
+            {
+                angle = Mathf.Atan2(vector.x, vector.y) * Mathf.Rad2Deg;
+            }
+
+            if (preferAngles)
+            {
+                if (345 <= angle || angle < 15)
+                {
+                    return Direction.North;
+                }
+
+                if (15 <= angle && angle < 75)
+                {
+                    return Direction.NorthEast;
+                }
+
+                if (75 <= angle && angle < 105)
+                {
+                    return Direction.East;
+                }
+
+                if (105 <= angle && angle < 165)
+                {
+                    return Direction.SouthEast;
+                }
+
+                if (165 <= angle && angle < 195)
+                {
+                    return Direction.South;
+                }
+
+                if (195 <= angle && angle < 255)
+                {
+                    return Direction.SouthWest;
+                }
+
+                if (255 <= angle && angle < 285)
+                {
+                    return Direction.West;
+                }
+
+                if (285 <= angle && angle < 345)
+                {
+                    return Direction.NorthWest;
+                }
+            }
+
+            if (337.5 <= angle || angle < 22.5)
+            {
+                return Direction.North;
+            }
+
+            if (22.5 <= angle && angle < 67.5)
+            {
+                return Direction.NorthEast;
+            }
+
+            if (67.5 <= angle && angle < 112.5)
+            {
+                return Direction.East;
+            }
+
+            if (112.5 <= angle && angle < 157.5)
+            {
+                return Direction.SouthEast;
+            }
+
+            if (157.5 <= angle && angle < 202.5)
+            {
+                return Direction.South;
+            }
+
+            if (202.5 <= angle && angle < 247.5)
+            {
+                return Direction.SouthWest;
+            }
+
+            if (247.5 <= angle && angle < 292.5)
+            {
+                return Direction.West;
+            }
+
+            if (292.5 <= angle && angle < 337.5)
+            {
+                return Direction.NorthWest;
+            }
+
+            return Direction.None;
+        }
+    }
+}

package/Runtime/Core/Extension/EnumExtensions.cs

@@ -1,37 +1,37 @@
-namespace UnityHelpers.Core.Extension
-{
-    using System;
-    using System.Runtime.CompilerServices;
-
-    public static class EnumExtensions
-    {
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static bool HasFlagNoAlloc<T>(this T value, T flag)
-            where T : unmanaged, Enum
-        {
-            ulong valueUnderlying = GetUInt64(value);
-            ulong flagUnderlying = GetUInt64(flag);
-            return (valueUnderlying & flagUnderlying) == flagUnderlying;
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static unsafe ulong GetUInt64<T>(T value)
-            where T : unmanaged
-        {
-            /*
-                Works because T is constrained to unmanaged, so it's safe to reinterpret
-                All enums are value types and have a fixed size
-             */
-            return sizeof(T) switch
-            {
-                1 => *(byte*)&value,
-                2 => *(ushort*)&value,
-                4 => *(uint*)&value,
-                8 => *(ulong*)&value,
-                _ => throw new ArgumentException(
-                    $"Unsupported enum size: {sizeof(T)} for type {typeof(T)}"
-                ),
-            };
-        }
-    }
-}
+namespace UnityHelpers.Core.Extension
+{
+    using System;
+    using System.Runtime.CompilerServices;
+
+    public static class EnumExtensions
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool HasFlagNoAlloc<T>(this T value, T flag)
+            where T : unmanaged, Enum
+        {
+            ulong valueUnderlying = GetUInt64(value);
+            ulong flagUnderlying = GetUInt64(flag);
+            return (valueUnderlying & flagUnderlying) == flagUnderlying;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static unsafe ulong GetUInt64<T>(T value)
+            where T : unmanaged
+        {
+            /*
+                Works because T is constrained to unmanaged, so it's safe to reinterpret
+                All enums are value types and have a fixed size
+             */
+            return sizeof(T) switch
+            {
+                1 => *(byte*)&value,
+                2 => *(ushort*)&value,
+                4 => *(uint*)&value,
+                8 => *(ulong*)&value,
+                _ => throw new ArgumentException(
+                    $"Unsupported enum size: {sizeof(T)} for type {typeof(T)}"
+                ),
+            };
+        }
+    }
+}

package/Runtime/Core/Extension/EnumExtensions.cs.meta

@@ -1,3 +1,3 @@
-fileFormatVersion: 2
-guid: cb447d880798449cb844f63991aac81b
+fileFormatVersion: 2
+guid: cb447d880798449cb844f63991aac81b
 timeCreated: 1742771382

package/Runtime/Core/Extension/HashSetExtensions.cs

@@ -1,12 +1,12 @@
-namespace UnityHelpers.Core.Extension
-{
-    using System.Collections.Generic;
-
-    public static class HashSetExtensions
-    {
-        public static void AddRange<T>(this HashSet<T> set, IEnumerable<T> elements)
-        {
-            set.UnionWith(elements);
-        }
-    }
-}
+namespace UnityHelpers.Core.Extension
+{
+    using System.Collections.Generic;
+
+    public static class HashSetExtensions
+    {
+        public static void AddRange<T>(this HashSet<T> set, IEnumerable<T> elements)
+        {
+            set.UnionWith(elements);
+        }
+    }
+}