com.wallstop-studios.unity-helpers 2.0.0-rc06 → 2.0.0-rc08

package/Runtime/Core/Extension/DirectionExtensions.cs

@@ -9,7 +9,10 @@
 
     public static class DirectionExtensions
     {
-        private static readonly List<Direction> Directions = Enum.GetValues(typeof(Direction)).OfType<Direction>().Except(Enumerables.Of(Direction.None)).ToList();
+        private static readonly Direction[] Directions = Enum.GetValues(typeof(Direction))
+            .OfType<Direction>()
+            .Except(Enumerables.Of(Direction.None))
+            .ToArray();
 
         public static Direction Opposite(this Direction direction)
         {
@@ -106,7 +109,7 @@
 
         public static Direction AsDirection(this Vector2 vector, bool preferAngles = false)
         {
-            if (vector.x == 0 && vector.y == 0)
+            if (vector == Vector2.zero)
             {
                 return Direction.None;
             }

package/Runtime/Core/Extension/IEnumerableExtensions.cs

@@ -1,15 +1,20 @@
 namespace UnityHelpers.Core.Extension
 {
-    using Random;
     using System;
     using System.Collections.Concurrent;
     using System.Collections.Generic;
     using System.Linq;
+    using Random;
 
     public static class IEnumerableExtensions
     {
         private static readonly ConcurrentDictionary<object, object> ComparerCache = new();
 
+        public static LinkedList<T> ToLinkedList<T>(this IEnumerable<T> source)
+        {
+            return new LinkedList<T>(source);
+        }
+
         public static IList<T> AsList<T>(this IEnumerable<T> enumeration)
         {
             if (enumeration is IList<T> list)
@@ -20,18 +25,27 @@
             return enumeration.ToList();
         }
 
-        public static IEnumerable<T> OrderBy<T>(this IEnumerable<T> enumeration, Func<T, T, int> comparer)
+        public static IEnumerable<T> OrderBy<T>(
+            this IEnumerable<T> enumeration,
+            Func<T, T, int> comparer
+        )
         {
-            FuncBasedComparer<T> comparerObject = (FuncBasedComparer<T>) ComparerCache.GetOrAdd(comparer, () => new FuncBasedComparer<T>(comparer));
+            FuncBasedComparer<T> comparerObject =
+                (FuncBasedComparer<T>)
+                    ComparerCache.GetOrAdd(comparer, () => new FuncBasedComparer<T>(comparer));
             return enumeration.OrderBy(_ => _, comparerObject);
         }
 
-        public static IEnumerable<T> Ordered<T>(this IEnumerable<T> enumerable) where T : IComparable
+        public static IEnumerable<T> Ordered<T>(this IEnumerable<T> enumerable)
+            where T : IComparable
         {
             return enumerable.OrderBy(_ => _);
         }
 
-        public static IEnumerable<T> Shuffled<T>(this IEnumerable<T> enumerable, IRandom random = null)
+        public static IEnumerable<T> Shuffled<T>(
+            this IEnumerable<T> enumerable,
+            IRandom random = null
+        )
         {
             random = random ?? ThreadLocalRandom<PcgRandom>.Instance;
             return enumerable.OrderBy(_ => random.Next());
@@ -90,7 +104,6 @@
             return list;
         }
 
-
         private class FuncBasedComparer<T> : IComparer<T>
         {
             private readonly Func<T, T, int> _comparer;

package/Runtime/Core/Extension/RandomExtensions.cs

@@ -1,8 +1,5 @@
 namespace UnityHelpers.Core.Extension
 {
-    using System;
-    using System.Collections.Generic;
-    using System.Linq;
     using Helper;
     using Random;
     using UnityEngine;
@@ -14,15 +11,6 @@
             return random.NextVector2(-amplitude, amplitude);
         }
 
-        public static Vector2 NextVector2InRange(
-            this IRandom random,
-            float range,
-            Vector2? origin = null
-        )
-        {
-            return Helpers.GetRandomPointInCircle(origin ?? Vector2.zero, range, random);
-        }
-
         public static Vector2 NextVector2(
             this IRandom random,
             float minAmplitude,
@@ -34,6 +22,15 @@
             return new Vector2(x, y);
         }
 
+        public static Vector2 NextVector2InRange(
+            this IRandom random,
+            float range,
+            Vector2? origin = null
+        )
+        {
+            return Helpers.GetRandomPointInCircle(origin ?? Vector2.zero, range, random);
+        }
+
         public static Vector3 NextVector3(this IRandom random, float amplitude)
         {
             return random.NextVector3(-amplitude, amplitude);
@@ -50,80 +47,5 @@
             result.z = z;
             return result;
         }
-
-        public static T NextEnum<T>(this IRandom random)
-            where T : struct
-        {
-            T[] enumValues = (T[])Enum.GetValues(typeof(T));
-            if (enumValues.Length == 0)
-            {
-                return default(T);
-            }
-
-            if (enumValues.Length == 1)
-            {
-                return enumValues[0];
-            }
-
-            if (enumValues.Length == 2)
-            {
-                return random.NextBool() ? enumValues[0] : enumValues[1];
-            }
-
-            int nextIndex = random.Next(0, enumValues.Length);
-            return enumValues[nextIndex];
-        }
-
-        public static T Next<T>(this IRandom random, IList<T> elements)
-        {
-            if (ReferenceEquals(elements, null) || elements.Count == 0)
-            {
-                return default(T);
-            }
-
-            switch (elements.Count)
-            {
-                case 1:
-                    return elements[0];
-                case 2:
-                    return random.NextBool() ? elements[0] : elements[1];
-                default:
-                    int index = random.Next(0, elements.Count);
-                    return elements[index];
-            }
-        }
-
-        public static T Next<T>(this IRandom random, IEnumerable<T> elements)
-        {
-            if (ReferenceEquals(elements, null))
-            {
-                return default(T);
-            }
-
-            IList<T> elementsList = elements as IList<T>;
-            if (!ReferenceEquals(elementsList, null))
-            {
-                return Next(random, elementsList);
-            }
-
-            ICollection<T> maybeCollection = elements as ICollection<T>;
-            if (!ReferenceEquals(maybeCollection, null))
-            {
-                int count = maybeCollection.Count;
-                int randomIndex = random.Next(0, count);
-
-                int i = 0;
-                foreach (T element in maybeCollection)
-                {
-                    if (i++ == randomIndex)
-                    {
-                        return element;
-                    }
-                }
-            }
-
-            elementsList = elements.ToArray();
-            return Next(random, elementsList);
-        }
     }
 }

package/Runtime/Core/Extension/UnityExtensions.cs

@@ -266,7 +266,7 @@
                     return convexHull;
                 }
 
-                Vector3Int nextPoint = random.Next(points);
+                Vector3Int nextPoint = random.NextOf(points);
                 Vector2 currentPointWorldPosition = CellToWorld(currentPoint);
                 Vector2 nextPointWorldPosition = CellToWorld(nextPoint);
                 foreach (Vector3Int point in points)
@@ -389,7 +389,7 @@
                     return convexHull;
                 }
 
-                FastVector3Int nextPoint = random.Next(points);
+                FastVector3Int nextPoint = random.NextOf(points);
                 Vector2 currentPointWorldPosition = CellToWorld(currentPoint);
                 Vector2 nextPointWorldPosition = CellToWorld(nextPoint);
                 foreach (FastVector3Int point in points)