com.wallstop-studios.unity-helpers 2.0.0-rc07 → 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)

package/Runtime/Core/Random/AbstractRandom.cs

@@ -55,102 +55,6 @@
             return unchecked((int)(min + NextUint(range)));
         }
 
-        public T Next<T>(IEnumerable<T> enumerable)
-        {
-            if (enumerable is ICollection<T> collection)
-            {
-                return Next(collection);
-            }
-
-            return Next((IReadOnlyList<T>)enumerable.ToList());
-        }
-
-        public T Next<T>(ICollection<T> collection)
-        {
-            int count = collection.Count;
-            if (count <= 0)
-            {
-                throw new ArgumentException("Collection size cannot be less-than or equal-to 0");
-            }
-
-            switch (collection)
-            {
-                case IList<T> list:
-                    return Next(list);
-                case IReadOnlyList<T> readOnlyList:
-                    return Next(readOnlyList);
-            }
-
-            int index = Next(count);
-            int i = 0;
-            foreach (T element in collection)
-            {
-                if (i++ == index)
-                {
-                    return element;
-                }
-            }
-
-            // Should never happen
-            return default;
-        }
-
-        public T Next<T>(IList<T> list)
-        {
-            if (ReferenceEquals(list, null))
-            {
-                throw new ArgumentNullException(nameof(list));
-            }
-
-            /*
-                For small lists, it's much more efficient to simply return one of their elements
-                instead of trying to generate a random number within bounds (which is implemented as a while(true) loop)
-             */
-            switch (list.Count)
-            {
-                case 1:
-                    return list[0];
-                case 2:
-                    return NextBool() ? list[0] : list[1];
-                default:
-                    return list[Next(list.Count)];
-            }
-        }
-
-        private T Next<T>(IReadOnlyList<T> list)
-        {
-            /*
-                For small lists, it's much more efficient to simply return one of their elements
-                instead of trying to generate a random number within bounds (which is implemented as a while(true) loop)
-             */
-            switch (list.Count)
-            {
-                case 1:
-                    return list[0];
-                case 2:
-                    return NextBool() ? list[0] : list[1];
-                default:
-                    return list[Next(list.Count)];
-            }
-        }
-
-        public T Next<T>()
-            where T : struct, Enum
-        {
-            Type enumType = typeof(T);
-            T[] enumValues;
-            if (EnumTypeCache.TryGetValue(enumType, out Array enumArray))
-            {
-                enumValues = (T[])enumArray;
-            }
-            else
-            {
-                enumValues = (T[])Enum.GetValues(enumType);
-            }
-
-            return RandomOf(enumValues);
-        }
-
         // Internal sampler
         public abstract uint NextUint();
 
@@ -212,7 +116,7 @@
             uint lower = NextUint();
             unchecked
             {
-                return (long)((((ulong)upper << 32) | lower) & (0x1UL << 63));
+                return (long)((((ulong)upper << 32) | lower) & 0x7FFFFFFFFFFFFFFF);
             }
         }
 
@@ -275,34 +179,36 @@
 
         public void NextBytes(byte[] buffer)
         {
-            if (ReferenceEquals(buffer, null))
+            if (buffer == null)
             {
                 throw new ArgumentException(nameof(buffer));
             }
 
-            const byte sizeOfInt = sizeof(int); // May differ on some platforms
+            const int sizeOfInt = 4; // May differ on some platforms
 
             // See how many ints we can slap into it.
             int chunks = buffer.Length / sizeOfInt;
-            byte spare = unchecked((byte)(buffer.Length - (chunks * sizeOfInt)));
+            int spare = buffer.Length - chunks * sizeOfInt;
             for (int i = 0; i < chunks; ++i)
             {
-                int offset = i * chunks;
-                int random = Next();
-                buffer[offset] = unchecked((byte)(random & 0xFF000000));
-                buffer[offset + 1] = unchecked((byte)(random & 0x00FF0000));
-                buffer[offset + 2] = unchecked((byte)(random & 0x0000FF00));
-                buffer[offset + 3] = unchecked((byte)(random & 0x000000FF));
+                int offset = i * sizeOfInt;
+                uint random = NextUint();
+                for (int j = 0; j < sizeOfInt; ++j)
+                {
+                    buffer[offset + j] = unchecked(
+                        (byte)((random >> (j * sizeOfInt)) & 0x000000FF)
+                    );
+                }
             }
 
+            if (0 < spare)
             {
-                /*
-                    This could be implemented more optimally by generating a single int and
-                    bit shifting along the position, but that is too much for me right now.
-                 */
-                for (byte i = 0; i < spare; ++i)
+                uint spareRandom = NextUint();
+                for (int i = 0; i < spare; ++i)
                 {
-                    buffer[buffer.Length - 1 - i] = unchecked((byte)Next());
+                    buffer[buffer.Length - 1 - i] = unchecked(
+                        (byte)((spareRandom >> (i * sizeOfInt)) & 0x000000FF)
+                    );
                 }
             }
         }
@@ -343,7 +249,7 @@
                 return NextDoubleWithInfiniteRange(min, max);
             }
 
-            return min + (NextDouble() * range);
+            return min + NextDouble() * range;
         }
 
         protected double NextDoubleWithInfiniteRange(double min, double max)
@@ -408,7 +314,7 @@
                 x = 2 * NextDouble() - 1;
                 y = 2 * NextDouble() - 1;
                 square = x * x + y * y;
-            } while (square == 0 || 1 < square);
+            } while (square is 0 or > 1);
 
             double fac = Math.Sqrt(-2 * Math.Log(square) / square);
             _cachedGaussian = x * fac;
@@ -454,7 +360,53 @@
             return min + NextFloat(range);
         }
 
-        public T NextCachedEnum<T>()
+        public T NextOf<T>(IEnumerable<T> enumerable)
+        {
+            return enumerable switch
+            {
+                IReadOnlyList<T> list => NextOf(list),
+                IReadOnlyCollection<T> collection => NextOf(collection),
+                null => throw new ArgumentNullException(nameof(enumerable)),
+                _ => NextOf(enumerable.ToArray()),
+            };
+        }
+
+        public T NextOf<T>(IReadOnlyCollection<T> collection)
+        {
+            if (collection is not { Count: > 0 })
+            {
+                throw new ArgumentException("Collection cannot be empty");
+            }
+
+            if (collection is IReadOnlyList<T> list)
+            {
+                return NextOf(list);
+            }
+
+            int index = Next(collection.Count);
+            return collection.ElementAt(index);
+        }
+
+        public T NextOf<T>(IReadOnlyList<T> list)
+        {
+            if (list is not { Count: > 0 })
+            {
+                throw new ArgumentNullException(nameof(list));
+            }
+
+            /*
+                For small lists, it's much more efficient to simply return one of their elements
+                instead of trying to generate a random number within bounds (which is implemented as a while(true) loop)
+             */
+            return list.Count switch
+            {
+                1 => list[0],
+                2 => NextBool() ? list[0] : list[1],
+                _ => list[Next(list.Count)],
+            };
+        }
+
+        public T NextEnum<T>()
             where T : struct, Enum
         {
             Type enumType = typeof(T);
@@ -479,7 +431,13 @@
 
         // Advances the RNG
         // https://code2d.wordpress.com/2020/07/21/perlin-noise/
-        public float[,] NextNoiseMap(int width, int height, float scale = 2.5f, int octaves = 8)
+        public float[,] NextNoiseMap(
+            int width,
+            int height,
+            PerlinNoise noise = null,
+            float scale = 2.5f,
+            int octaves = 8
+        )
         {
             if (width <= 0)
             {
@@ -501,6 +459,7 @@
                 throw new ArgumentException(nameof(octaves));
             }
 
+            noise ??= PerlinNoise.Instance;
             float[,] noiseMap = new float[width, height];
 
             Vector2[] octaveOffsets = new Vector2[octaves];
@@ -529,8 +488,7 @@
                         float sampleX = (x - halfWidth) / scale * frequency + octaveOffsets[i].x;
                         float sampleY = (y - halfHeight) / scale * frequency + octaveOffsets[i].y;
 
-                        // Use unity's implementation of perlin noise
-                        float perlinValue = Mathf.PerlinNoise(sampleX, sampleY) * 2 - 1;
+                        float perlinValue = noise.Noise(sampleX, sampleY) * 2 - 1;
                         noiseHeight += perlinValue * amplitude;
                     }
 
@@ -565,17 +523,13 @@
 
         protected T RandomOf<T>(T[] values)
         {
-            switch (values.Length)
+            return values.Length switch
             {
-                case 0:
-                    return default;
-                case 1:
-                    return values[0];
-                case 2:
-                    return NextBool() ? values[0] : values[1];
-                default:
-                    return values[Next(values.Length)];
-            }
+                0 => default,
+                1 => values[0],
+                2 => NextBool() ? values[0] : values[1],
+                _ => values[Next(values.Length)],
+            };
         }
 
         public abstract IRandom Copy();

package/Runtime/Core/Random/IRandom.cs

@@ -27,10 +27,12 @@
         /// </summary>
         /// <returns>A number within the range [0, uint.MaxValue].</returns>
         uint NextUint();
+
         /// <summary>
         /// </summary>
         /// <returns>A number within the range [0, max).</returns>
         uint NextUint(uint max);
+
         /// <summary>
         /// </summary>
         /// <returns>A number within the range [min, max).</returns>
@@ -45,6 +47,7 @@
         /// </summary>
         /// <returns>A number within the range [0, max).</returns>
         short NextShort(short max);
+
         /// <summary>
         /// </summary>
         /// <returns>A number within the range [min, max).</returns>
@@ -54,10 +57,12 @@
         /// </summary>
         /// <returns>A number within the range [0, byte.MaxValue).</returns>
         byte NextByte();
+
         /// <summary>
         /// </summary>
         /// <returns>A number within the range [0, max).</returns>
         byte NextByte(byte max);
+
         /// <summary>
         /// </summary>
         /// <returns>A number within the range [min, max).</returns>
@@ -67,10 +72,12 @@
         /// </summary>
         /// <returns>A number within the range [0, long.MaxValue).</returns>
         long NextLong();
+
         /// <summary>
         /// </summary>
         /// <returns>A number within the range [0, max).</returns>
         long NextLong(long max);
+
         /// <summary>
         /// </summary>
         /// <returns>A number within the range [min, max).</returns>
@@ -80,10 +87,12 @@
         /// </summary>
         /// <returns>A number within the range [0, ulong.MaxValue).</returns>
         ulong NextUlong();
+
         /// <summary>
         /// </summary>
         /// <returns>A number within the range [0, max).</returns>
         ulong NextUlong(ulong max);
+
         /// <summary>
         /// </summary>
         /// <returns>A number within the range [min, max).</returns>
@@ -100,10 +109,12 @@
         /// </summary>
         /// <returns>A number within the range [0, 1).</returns>
         float NextFloat();
+
         /// <summary>
         /// </summary>
         /// <returns>A number within the range [0, max).</returns>
         float NextFloat(float max);
+
         /// <summary>
         /// </summary>
         /// <returns>A number within the range min, max).</returns>
@@ -113,10 +124,12 @@
         /// </summary>
         /// <returns>A number within the range [0, 1).</returns>
         double NextDouble();
+
         /// <summary>
         /// </summary>
         /// <returns>A number within the range [0, max).</returns>
         double NextDouble(double max);
+
         /// <summary>
         /// </summary>
         /// <returns>A number within the range min, max).</returns>
@@ -127,15 +140,21 @@
         Guid NextGuid();
         KGuid NextKGuid();
 
-        T Next<T>(IEnumerable<T> enumerable);
-        T Next<T>(ICollection<T> collection);
-        T Next<T>(IList<T> list);
+        T NextOf<T>(IEnumerable<T> enumerable);
+        T NextOf<T>(IReadOnlyCollection<T> collection);
+        T NextOf<T>(IReadOnlyList<T> list);
 
-        T Next<T>() where T : struct, Enum;
-        T NextCachedEnum<T>() where T : struct, Enum;
+        T NextEnum<T>()
+            where T : struct, Enum;
 
-        float[,] NextNoiseMap(int width, int height, float scale = 2.5f, int octaves = 8);
+        float[,] NextNoiseMap(
+            int width,
+            int height,
+            PerlinNoise noise = null,
+            float scale = 2.5f,
+            int octaves = 8
+        );
 
         IRandom Copy();
     }
-}
+}