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

package/Runtime/Core/Helper/WallMath.cs

@@ -14,7 +14,9 @@
 
         public static double BoundedDouble(double max, double value)
         {
-            return value < max ? value : BitConverter.Int64BitsToDouble(BitConverter.DoubleToInt64Bits(value) - 1);
+            return value < max
+                ? value
+                : BitConverter.Int64BitsToDouble(BitConverter.DoubleToInt64Bits(value) - 1);
         }
 
         public static float BoundedFloat(float max, float value)
@@ -22,52 +24,113 @@
             return value < max
                 ? value
                 : BitConverter.ToSingle(
-                    BitConverter.GetBytes(BitConverter.ToInt32(BitConverter.GetBytes(value), 0) - 1), 0);
+                    BitConverter.GetBytes(
+                        BitConverter.ToInt32(BitConverter.GetBytes(value), 0) - 1
+                    ),
+                    0
+                );
         }
 
-        public static int WrappedAdd(int value, int increment, int max)
+        public static int WrappedAdd(this int value, int increment, int max)
         {
             WrappedAdd(ref value, increment, max);
             return value;
         }
 
-        public static void WrappedAdd(ref int value, int increment, int max)
+        public static int WrappedAdd(ref int value, int increment, int max)
         {
-            value = value + increment;
+            value += increment;
             if (value < max)
             {
-                return;
+                return value;
             }
-            value %= max;
+            return value %= max;
         }
 
-        public static int WrappedIncrement(int value, int max)
+        public static int WrappedIncrement(this int value, int max)
         {
             return WrappedAdd(value, 1, max);
         }
 
-        public static void WrappedIncrement(ref int value, int max)
+        public static int WrappedIncrement(ref int value, int max)
+        {
+            return WrappedAdd(ref value, 1, max);
+        }
+
+        public static T Clamp<T>(this T value, T min, T max)
+            where T : IComparable<T>
+        {
+            if (value.CompareTo(min) < 0)
+            {
+                return min;
+            }
+
+            return max.CompareTo(value) < 0 ? max : value;
+        }
+
+        public static Vector2 Clamp(this Rect bounds, Vector2 point)
         {
-            WrappedAdd(ref value, 1, max);
+            return Clamp(bounds, ref point);
         }
 
-        public static void Clamp(this Rect bounds, ref Vector2 point)
+        public static Vector2 Clamp(this Rect bounds, ref Vector2 point)
         {
-            if (!bounds.Contains(point))
+            if (bounds.Contains(point))
+            {
+                return point;
+            }
+
+            Vector2 center = bounds.center;
+            Vector2 direction = point - center;
+
+            if (direction == Vector2.zero)
+            {
+                return center;
+            }
+
+            float tMax = float.MaxValue;
+            Vector2 min = bounds.min;
+            Vector2 max = bounds.max;
+
+            if (direction.x != 0)
+            {
+                if (0 < direction.x)
+                {
+                    float t2 = (max.x - center.x) / direction.x;
+                    tMax = Math.Min(tMax, t2);
+                }
+                else
+                {
+                    float t1 = (min.x - center.x) / direction.x;
+                    tMax = Math.Min(tMax, t1);
+                }
+            }
+
+            if (direction.y != 0)
             {
-                Vector2 xClamp = bounds.width < 0 ?
-                    new Vector2(bounds.x + bounds.width, bounds.x) :
-                    new Vector2(bounds.x, bounds.x + bounds.width);
-                Vector2 yClamp = bounds.height < 0 ?
-                    new Vector2(bounds.y + bounds.height, bounds.y) :
-                    new Vector2(bounds.y, bounds.y + bounds.height);
-
-                point.x = Mathf.Clamp(point.x, xClamp.x, xClamp.y);
-                point.y = Mathf.Clamp(point.y, yClamp.x, yClamp.y);
+                if (direction.y > 0)
+                {
+                    float t2 = (max.y - center.y) / direction.y;
+                    tMax = Math.Min(tMax, t2);
+                }
+                else
+                {
+                    float t1 = (min.y - center.y) / direction.y;
+                    tMax = Math.Min(tMax, t1);
+                }
             }
+
+            tMax = Mathf.Clamp01(tMax);
+
+            point = center + direction * tMax;
+            point = new Vector2(
+                Mathf.Clamp(point.x, min.x, max.x),
+                Mathf.Clamp(point.y, min.y, max.y)
+            );
+            return point;
         }
 
-        public static bool Approximately(float lhs, float rhs, float tolerance = 0.045f)
+        public static bool Approximately(this float lhs, float rhs, float tolerance = 0.045f)
         {
             return Math.Abs(lhs - rhs) <= tolerance;
         }

package/Runtime/Core/Random/AbstractRandom.cs

@@ -15,25 +15,16 @@
         private static readonly ConcurrentDictionary<Type, Array> EnumTypeCache = new();
 
         protected const uint HalfwayUint = uint.MaxValue / 2;
-        protected const double MagicDouble = 4.6566128752458E-10;
         protected const float MagicFloat = 5.960465E-008F;
 
         protected double? _cachedGaussian;
 
-        protected AbstractRandom() { }
-
         public abstract RandomState InternalState { get; }
 
-        public int Next()
+        public virtual int Next()
         {
-            int result;
-            do
-            {
-                result = unchecked((int)NextUint());
-            }
-            while (result < 0);
-
-            return result;
+            // Mask out the MSB to ensure the value is within [0, int.MaxValue]
+            return unchecked((int)NextUint() & 0x7FFFFFFF);
         }
 
         public int Next(int max)
@@ -50,40 +41,136 @@
         {
             if (max <= min)
             {
-                throw new ArgumentException($"Min {min} cannot be larger-than or equal-to max {max}");
+                throw new ArgumentException(
+                    $"Min {min} cannot be larger-than or equal-to max {max}"
+                );
+            }
+
+            uint range = (uint)(max - min);
+            if (range == 0)
+            {
+                return unchecked((int)NextUint());
             }
 
-            uint range = unchecked((uint)(max - min));
-            return unchecked((int)NextUint(range)) + min;
+            return unchecked((int)(min + NextUint(range)));
         }
 
-        // Internal sampler
-        public abstract uint NextUint();
+        public T Next<T>(IEnumerable<T> enumerable)
+        {
+            if (enumerable is ICollection<T> collection)
+            {
+                return Next(collection);
+            }
 
-        public uint NextUint(uint max)
+            return Next((IReadOnlyList<T>)enumerable.ToList());
+        }
+
+        public T Next<T>(ICollection<T> collection)
         {
-            /*
-                https://github.com/libevent/libevent/blob/3807a30b03ab42f2f503f2db62b1ef5876e2be80/arc4random.c#L531
+            int count = collection.Count;
+            if (count <= 0)
+            {
+                throw new ArgumentException("Collection size cannot be less-than or equal-to 0");
+            }
 
-                http://cs.stackexchange.com/questions/570/generating-uniformly-distributed-random-numbers-using-a-coin
-                Generates a uniform random number within the bound, avoiding modulo bias
-            */
-            uint threshold = unchecked((uint)((0x100000000UL - max) % max));
-            while (true)
+            switch (collection)
             {
-                uint randomValue = NextUint();
-                if (threshold <= randomValue)
+                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 randomValue % max;
+                    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();
+
+        public uint NextUint(uint max)
+        {
+            if (max == 0)
+            {
+                throw new ArgumentException("Max cannot be zero");
+            }
+
+            return (uint)(NextDouble() * max);
         }
 
         public uint NextUint(uint min, uint max)
         {
             if (max <= min)
             {
-                throw new ArgumentException($"Min {min} cannot be larger-than or equal-to max {max}");
+                throw new ArgumentException(
+                    $"Min {min} cannot be larger-than or equal-to max {max}"
+                );
             }
 
             return min + NextUint(max - min);
@@ -123,12 +210,10 @@
         {
             uint upper = NextUint();
             uint lower = NextUint();
-            // Mix things up a little
-            if (NextBool())
+            unchecked
             {
-                return unchecked((long)((ulong)upper << 32) | lower);
+                return (long)((((ulong)upper << 32) | lower) & (0x1UL << 63));
             }
-            return unchecked((long)((ulong)lower << 32) | upper);
         }
 
         public long NextLong(long max)
@@ -138,51 +223,52 @@
                 throw new ArgumentException($"Max {max} cannot be less-than or equal-to 0");
             }
 
-            if (max < int.MaxValue)
-            {
-                return Next(unchecked((int)max));
-            }
-
-            long withinRange;
-            do
-            {
-                withinRange = NextLong();
-            }
-            while (withinRange < 0 || max <= withinRange);
-            return withinRange;
+            return (long)(NextDouble() * max);
         }
 
         public long NextLong(long min, long max)
         {
             if (max <= min)
             {
-                throw new ArgumentException($"Min {min} cannot be larger-than or equal-to Max {max}");
+                throw new ArgumentException(
+                    $"Min {min} cannot be larger-than or equal-to Max {max}"
+                );
             }
 
-            return min + NextLong(max - min);
+            ulong range = (ulong)(max - min);
+            if (range == 0)
+            {
+                return unchecked((long)NextUlong());
+            }
+
+            return unchecked((long)(NextDouble() * range + min));
         }
 
         public ulong NextUlong()
         {
-            return unchecked((ulong)NextLong());
+            uint upper = NextUint();
+            uint lower = NextUint();
+            return ((ulong)upper << 32) | lower;
         }
 
         public ulong NextUlong(ulong max)
         {
-            return unchecked((ulong)NextLong(unchecked((long)max)));
+            return (ulong)(NextDouble() * max);
         }
 
         public ulong NextUlong(ulong min, ulong max)
         {
             if (max <= min)
             {
-                throw new ArgumentException($"Min {min} cannot be larger-than or equal-to max {max}");
+                throw new ArgumentException(
+                    $"Min {min} cannot be larger-than or equal-to max {max}"
+                );
             }
 
-            return unchecked((ulong)NextLong(unchecked((long)min), unchecked((long)max)));
+            return NextUlong(max - min) + min;
         }
 
-        public bool NextBool()
+        public virtual bool NextBool()
         {
             return NextUint() < HalfwayUint;
         }
@@ -194,7 +280,7 @@
                 throw new ArgumentException(nameof(buffer));
             }
 
-            const byte sizeOfInt = 4; // May differ on some platforms
+            const byte sizeOfInt = sizeof(int); // May differ on some platforms
 
             // See how many ints we can slap into it.
             int chunks = buffer.Length / sizeOfInt;
@@ -226,9 +312,8 @@
             double value;
             do
             {
-                value = NextUint() * MagicDouble;
-            }
-            while (value < 0 || 1 <= value);
+                value = NextUint() * (1.0 / uint.MaxValue);
+            } while (1.0 <= value);
 
             return value;
         }
@@ -247,11 +332,57 @@
         {
             if (max <= min)
             {
-                throw new ArgumentException($"Min {min} cannot be larger-than or equal-to max {max}");
+                throw new ArgumentException(
+                    $"Min {min} cannot be larger-than or equal-to max {max}"
+                );
             }
 
             double range = max - min;
-            return min + NextDouble(range);
+            if (double.IsInfinity(range))
+            {
+                return NextDoubleWithInfiniteRange(min, max);
+            }
+
+            return min + (NextDouble() * range);
+        }
+
+        protected double NextDoubleWithInfiniteRange(double min, double max)
+        {
+            double random;
+            do
+            {
+                random = NextDoubleFullRange();
+            } while (random < min || max <= random);
+
+            return random;
+        }
+
+        protected double NextDoubleFullRange()
+        {
+            double value = double.NaN;
+            do
+            {
+                ulong randomBits = NextUlong();
+
+                // Extract exponent (bits 52-62)
+                const ulong exponentMask = 0x7FF0000000000000;
+
+                ulong exponent = (randomBits & exponentMask) >> 52;
+
+                // Ensure exponent is not all 1's to avoid Inf and NaN
+                if (exponent == 0x7FF)
+                {
+                    continue; // Regenerate
+                }
+
+                /*
+                    For uniform distribution over all finite doubles, no further masking is necessary,
+                    reassemble the bits
+                 */
+                value = BitConverter.Int64BitsToDouble(unchecked((long)randomBits));
+            } while (double.IsInfinity(value) || double.IsNaN(value));
+
+            return value;
         }
 
         public double NextGaussian(double mean = 0, double stdDev = 1)
@@ -277,8 +408,7 @@
                 x = 2 * NextDouble() - 1;
                 y = 2 * NextDouble() - 1;
                 square = x * x + y * y;
-            }
-            while (square > 1 || square == 0);
+            } while (square == 0 || 1 < square);
 
             double fac = Math.Sqrt(-2 * Math.Log(square) / square);
             _cachedGaussian = x * fac;
@@ -290,10 +420,8 @@
             float value;
             do
             {
-                uint floatAsInt = NextUint();
-                value = (floatAsInt >> 8) * MagicFloat;
-            }
-            while (value < 0 || 1 <= value);
+                value = NextUint() / (1f * uint.MaxValue);
+            } while (1f <= value);
 
             return value;
         }
@@ -312,108 +440,22 @@
         {
             if (max <= min)
             {
-                throw new ArgumentException($"Min {min} cannot be larger-than or equal-to max {max}");
-            }
-
-            return min + NextFloat(max - min);
-        }
-
-        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));
+                throw new ArgumentException(
+                    $"Min {min} cannot be larger-than or equal-to max {max}"
+                );
             }
 
-            /*
-                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)
+            float range = max - min;
+            if (float.IsInfinity(range))
             {
-                case 1:
-                    return list[0];
-                case 2:
-                    return NextBool() ? list[0] : list[1];
-                default:
-                    return list[Next(list.Count)];
+                return (float)NextDouble(min, max);
             }
-        }
 
-        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);
+            return min + NextFloat(range);
         }
 
-        public T NextCachedEnum<T>() where T : struct, Enum
+        public T NextCachedEnum<T>()
+            where T : struct, Enum
         {
             Type enumType = typeof(T);
             T[] enumValues = (T[])EnumTypeCache.GetOrAdd(enumType, Enum.GetValues);
@@ -437,7 +479,7 @@
 
         // Advances the RNG
         // https://code2d.wordpress.com/2020/07/21/perlin-noise/
-        public float[,] NextNoiseMap(int width, int height, float scale, int octaves)
+        public float[,] NextNoiseMap(int width, int height, float scale = 2.5f, int octaves = 8)
         {
             if (width <= 0)
             {
@@ -511,7 +553,11 @@
                 {
                     // Returns a value between 0f and 1f based on noiseMap value
                     // minNoiseHeight being 0f, and maxNoiseHeight being 1f
-                    noiseMap[x, y] = Mathf.InverseLerp(minNoiseHeight, maxNoiseHeight, noiseMap[x, y]);
+                    noiseMap[x, y] = Mathf.InverseLerp(
+                        minNoiseHeight,
+                        maxNoiseHeight,
+                        noiseMap[x, y]
+                    );
                 }
             }
             return noiseMap;
@@ -534,4 +580,4 @@
 
         public abstract IRandom Copy();
     }
-}
+}

package/Runtime/Core/Random/DotNetRandom.cs

@@ -8,8 +8,6 @@
     [DataContract]
     public sealed class DotNetRandom : AbstractRandom
     {
-        [JsonPropertyName("State")]
-        [DataMember(Name = "State")]
         public override RandomState InternalState =>
             new RandomState(unchecked((ulong)_seed), state2: _numberGenerated);
 
@@ -27,12 +25,12 @@
         }
 
         [JsonConstructor]
-        public DotNetRandom(RandomState state)
+        public DotNetRandom(RandomState internalState)
         {
-            _seed = unchecked((int)state.State1);
+            _seed = unchecked((int)internalState.State1);
             _random = new Random(_seed);
             _numberGenerated = 0;
-            ulong generationCount = state.State2;
+            ulong generationCount = internalState.State2;
 
             while (_numberGenerated < generationCount)
             {

package/Runtime/Core/Random/PRNG.cs

@@ -0,0 +1,7 @@
+namespace UnityHelpers.Core.Random
+{
+    public static class PRNG
+    {
+        public static IRandom Instance => PcgRandom.Instance;
+    }
+}