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

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

@@ -5,6 +5,7 @@
     using System.Collections.Generic;
     using System.Linq;
     using System.Runtime.Serialization;
+    using System.Text.Json.Serialization;
     using DataStructure.Adapters;
     using UnityEngine;
 
@@ -30,8 +31,7 @@
             do
             {
                 result = unchecked((int)NextUint());
-            }
-            while (result < 0);
+            } while (result < 0);
 
             return result;
         }
@@ -50,7 +50,9 @@
         {
             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 = unchecked((uint)(max - min));
@@ -83,7 +85,9 @@
         {
             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);
@@ -147,8 +151,7 @@
             do
             {
                 withinRange = NextLong();
-            }
-            while (withinRange < 0 || max <= withinRange);
+            } while (withinRange < 0 || max <= withinRange);
             return withinRange;
         }
 
@@ -156,7 +159,9 @@
         {
             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);
@@ -176,7 +181,9 @@
         {
             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)));
@@ -227,8 +234,7 @@
             do
             {
                 value = NextUint() * MagicDouble;
-            }
-            while (value < 0 || 1 <= value);
+            } while (value < 0 || 1 <= value);
 
             return value;
         }
@@ -247,7 +253,9 @@
         {
             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;
@@ -277,8 +285,7 @@
                 x = 2 * NextDouble() - 1;
                 y = 2 * NextDouble() - 1;
                 square = x * x + y * y;
-            }
-            while (square > 1 || square == 0);
+            } while (square > 1 || square == 0);
 
             double fac = Math.Sqrt(-2 * Math.Log(square) / square);
             _cachedGaussian = x * fac;
@@ -292,8 +299,7 @@
             {
                 uint floatAsInt = NextUint();
                 value = (floatAsInt >> 8) * MagicFloat;
-            }
-            while (value < 0 || 1 <= value);
+            } while (value < 0 || 1 <= value);
 
             return value;
         }
@@ -312,7 +318,9 @@
         {
             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 + NextFloat(max - min);
@@ -397,7 +405,8 @@
             }
         }
 
-        public T Next<T>() where T : struct, Enum
+        public T Next<T>()
+            where T : struct, Enum
         {
             Type enumType = typeof(T);
             T[] enumValues;
@@ -413,7 +422,8 @@
             return RandomOf(enumValues);
         }
 
-        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);
@@ -511,7 +521,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 +548,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;
+    }
+}

package/Runtime/Core/Random/PRNG.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 5041bafe46dc450bb37153e394011636
+timeCreated: 1732564259

package/Runtime/Core/Random/PcgRandom.cs

@@ -15,8 +15,6 @@
             IComparable,
             IComparable<PcgRandom>
     {
-        [DataMember(Name = "State")]
-        [JsonPropertyName("State")]
         public static IRandom Instance => ThreadLocalRandom<PcgRandom>.Instance;
 
         internal readonly ulong _increment;
@@ -34,11 +32,11 @@
         }
 
         [JsonConstructor]
-        public PcgRandom(RandomState state)
+        public PcgRandom(RandomState internalState)
         {
-            _state = state.State1;
-            _increment = state.State2;
-            _cachedGaussian = state.Gaussian;
+            _state = internalState.State1;
+            _increment = internalState.State2;
+            _cachedGaussian = internalState.Gaussian;
         }
 
         public PcgRandom(ulong increment, ulong state)

package/Runtime/Core/Random/RandomState.cs

@@ -1,16 +1,20 @@
 namespace UnityHelpers.Core.Random
 {
     using System;
+    using System.Linq;
+    using System.Runtime.Serialization;
     using System.Text.Json.Serialization;
     using Extension;
     using Helper;
     using ProtoBuf;
 
     [Serializable]
+    [DataContract]
     [ProtoContract]
     public struct RandomState : IEquatable<RandomState>
     {
         public ulong State1 => _state1;
+
         public ulong State2 => _state2;
 
         public double? Gaussian
@@ -26,6 +30,8 @@
             }
         }
 
+        public byte[] Payload => _payload;
+
         [ProtoMember(1)]
         private ulong _state1;
 
@@ -38,16 +44,31 @@
         [ProtoMember(4)]
         private double _gaussian;
 
+        [ProtoMember(5)]
+        private byte[] _payload;
+
         private int _hashCode;
 
         [JsonConstructor]
-        public RandomState(ulong state1, ulong state2 = 0, double? gaussian = null)
+        public RandomState(
+            ulong state1,
+            ulong state2 = 0,
+            double? gaussian = null,
+            byte[] payload = null
+        )
         {
             _state1 = state1;
             _state2 = state2;
             _hasGaussian = gaussian.HasValue;
             _gaussian = gaussian ?? 0;
-            _hashCode = Objects.ValueTypeHashCode(state1, state2, _hasGaussian, _gaussian);
+            _payload = payload?.ToArray();
+            _hashCode = Objects.ValueTypeHashCode(
+                state1,
+                state2,
+                _hasGaussian,
+                _gaussian,
+                _payload != null
+            );
         }
 
         public RandomState(Guid guid)
@@ -57,7 +78,14 @@
             _state2 = BitConverter.ToUInt64(guidBytes, sizeof(ulong));
             _hasGaussian = false;
             _gaussian = 0;
-            _hashCode = Objects.ValueTypeHashCode(_state1, _state2, _hasGaussian, _gaussian);
+            _payload = null;
+            _hashCode = Objects.ValueTypeHashCode(
+                _state1,
+                _state2,
+                _hasGaussian,
+                _gaussian,
+                _payload != null
+            );
         }
 
         [ProtoAfterDeserialization]

package/Runtime/Core/Random/SquirrelRandom.cs

@@ -16,8 +16,6 @@
 
         public static readonly SquirrelRandom Instance = ThreadLocalRandom<SquirrelRandom>.Instance;
 
-        [JsonPropertyName("State")]
-        [DataMember(Name = "State")]
         public override RandomState InternalState => new(_position, gaussian: _cachedGaussian);
 
         private uint _position;
@@ -31,10 +29,10 @@
         }
 
         [JsonConstructor]
-        public SquirrelRandom(RandomState randomState)
+        public SquirrelRandom(RandomState internalState)
         {
-            _position = unchecked((uint)randomState.State1);
-            _cachedGaussian = randomState.Gaussian;
+            _position = unchecked((uint)internalState.State1);
+            _cachedGaussian = internalState.Gaussian;
         }
 
         public override uint NextUint()

package/Runtime/Core/Random/SystemRandom.cs

@@ -3,6 +3,7 @@
     using System;
     using System.Runtime.Serialization;
     using System.Text.Json.Serialization;
+    using Helper;
 
     /// <summary>
     ///     Implementation dependent upon .Net's Random class.
@@ -11,23 +12,27 @@
     [DataContract]
     public sealed class SystemRandom : AbstractRandom
     {
-        [JsonPropertyName("State")]
-        [DataMember(Name = "State")]
+        public static IRandom Instance => ThreadLocalRandom<SystemRandom>.Instance;
+
         public override RandomState InternalState =>
-            new(unchecked((ulong)inext), unchecked((ulong)inextp), _cachedGaussian);
+            new(
+                unchecked((ulong)inext),
+                unchecked((ulong)inextp),
+                _cachedGaussian,
+                ArrayConverter.IntArrayToByteArrayBlockCopy(SeedArray)
+            );
 
         /*
             Copied from Random.cs source. Apparently it isn't guaranteed to be the
-            same across platforms and we depend on that.
+            same across platforms, a fact which defeats the purpose of these serializable
+            randoms.
          */
         private int inext;
         private int inextp;
         private readonly int[] SeedArray = new int[56];
 
-        public static IRandom Instance => ThreadLocalRandom<SystemRandom>.Instance;
-
         public SystemRandom()
-            : this(Environment.TickCount) { }
+            : this(Guid.NewGuid().GetHashCode()) { }
 
         public SystemRandom(int seed)
         {
@@ -57,11 +62,15 @@
         }
 
         [JsonConstructor]
-        public SystemRandom(RandomState randomState)
+        public SystemRandom(RandomState internalState)
         {
-            inext = unchecked((int)randomState.State1);
-            inextp = unchecked((int)randomState.State2);
-            _cachedGaussian = randomState.Gaussian;
+            unchecked
+            {
+                inext = (int)internalState.State1;
+                inextp = (int)internalState.State2;
+            }
+            _cachedGaussian = internalState.Gaussian;
+            SeedArray = ArrayConverter.ByteArrayToIntArrayBlockCopy(internalState.Payload);
         }
 
         public override uint NextUint()

package/Runtime/Core/Random/ThreadLocalRandom.cs

@@ -2,7 +2,8 @@
 {
     using System.Threading;
 
-    public static class ThreadLocalRandom<T> where T : IRandom, new()
+    public static class ThreadLocalRandom<T>
+        where T : IRandom, new()
     {
         private static readonly ThreadLocal<T> RandomCache = new ThreadLocal<T>(() => new T());
 

package/Runtime/Core/Random/UnityRandom.cs

@@ -10,8 +10,6 @@
     {
         public static readonly UnityRandom Instance = new();
 
-        [JsonPropertyName("State")]
-        [DataMember(Name = "State")]
         public override RandomState InternalState
         {
             get
@@ -38,11 +36,11 @@
         }
 
         [JsonConstructor]
-        public UnityRandom(RandomState state)
+        public UnityRandom(RandomState internalState)
         {
             unchecked
             {
-                _seed = state.Gaussian != null ? (int)state.State1 : null;
+                _seed = internalState.Gaussian != null ? (int)internalState.State1 : null;
             }
         }
 

package/Runtime/Core/Random/WyRandom.cs

@@ -16,8 +16,6 @@
 
         public static IRandom Instance => ThreadLocalRandom<WyRandom>.Instance;
 
-        [JsonPropertyName("State")]
-        [DataMember(Name = "State")]
         public override RandomState InternalState => new RandomState(_state);
 
         private ulong _state;
@@ -32,9 +30,9 @@
         }
 
         [JsonConstructor]
-        public WyRandom(RandomState randomState)
+        public WyRandom(RandomState internalState)
         {
-            _state = randomState.State1;
+            _state = internalState.State1;
         }
 
         public WyRandom(ulong state)

package/Runtime/Core/Random/XorShiftRandom.cs

@@ -10,8 +10,6 @@
     {
         public static IRandom Instance => ThreadLocalRandom<XorShiftRandom>.Instance;
 
-        [JsonPropertyName("State")]
-        [DataMember(Name = "State")]
         public override RandomState InternalState => new(_state, 0, _cachedGaussian);
 
         private uint _state;
@@ -25,10 +23,10 @@
         }
 
         [JsonConstructor]
-        public XorShiftRandom(RandomState state)
+        public XorShiftRandom(RandomState internalState)
         {
-            _state = unchecked((uint)state.State1);
-            _cachedGaussian = state.Gaussian;
+            _state = unchecked((uint)internalState.State1);
+            _cachedGaussian = internalState.Gaussian;
         }
 
         public override uint NextUint()