com.wallstop-studios.unity-helpers 2.0.0-rc26 → 2.0.0-rc30

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/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);
+        }
+    }
+}