com.wallstop-studios.unity-helpers 2.0.0-rc56 → 2.0.0-rc58

package/Runtime/Core/Random/NativePcgRandom.cs

@@ -1,97 +1,97 @@
-namespace UnityHelpers.Core.Random
-{
-    using System;
-
-    public struct NativePcgRandom
-    {
-        private const uint HalfwayUint = uint.MaxValue / 2;
-        private const double MagicDouble = 4.6566128752458E-10;
-        private const float MagicFloat = 5.960465E-008F;
-
-        private readonly ulong _increment;
-        private ulong _state;
-
-        public NativePcgRandom(Guid seed)
-        {
-            byte[] guidArray = seed.ToByteArray();
-            _state = BitConverter.ToUInt64(guidArray, 0);
-            _increment = BitConverter.ToUInt64(guidArray, sizeof(ulong));
-        }
-
-        public NativePcgRandom(int seed)
-        {
-            _increment = 6554638469UL;
-            _state = unchecked((ulong)seed);
-            _increment = NextUlong();
-        }
-
-        public uint NextUint()
-        {
-            unchecked
-            {
-                ulong oldState = _state;
-                _state = oldState * 6364136223846793005UL + _increment;
-                uint xorShifted = (uint)(((oldState >> 18) ^ oldState) >> 27);
-                int rot = (int)(oldState >> 59);
-                return (xorShifted >> rot) | (xorShifted << (-rot & 31));
-            }
-        }
-
-        public int Next(int max)
-        {
-            if (max <= 0)
-            {
-                throw new ArgumentException($"Max {max} cannot be less-than or equal-to 0");
-            }
-
-            return unchecked((int)NextUint(unchecked((uint)max)));
-        }
-
-        public uint NextUint(uint max)
-        {
-            /*
-                https://github.com/libevent/libevent/blob/3807a30b03ab42f2f503f2db62b1ef5876e2be80/arc4random.c#L531
-
-                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)
-            {
-                uint randomValue = NextUint();
-                if (threshold <= randomValue)
-                {
-                    return randomValue % max;
-                }
-            }
-        }
-
-        public long NextLong()
-        {
-            uint upper = NextUint();
-            uint lower = NextUint();
-            // Mix things up a little
-            if (NextBool())
-            {
-                return unchecked((long)((ulong)upper << 32) | lower);
-            }
-            return unchecked((long)((ulong)lower << 32) | upper);
-        }
-
-        public ulong NextUlong()
-        {
-            return unchecked((ulong)NextLong());
-        }
-
-        public bool NextBool()
-        {
-            return NextUint() < HalfwayUint;
-        }
-
-        public float NextFloat()
-        {
-            uint floatAsInt = NextUint();
-            return (floatAsInt >> 8) * MagicFloat;
-        }
-    }
-}
+namespace UnityHelpers.Core.Random
+{
+    using System;
+
+    public struct NativePcgRandom
+    {
+        private const uint HalfwayUint = uint.MaxValue / 2;
+        private const double MagicDouble = 4.6566128752458E-10;
+        private const float MagicFloat = 5.960465E-008F;
+
+        private readonly ulong _increment;
+        private ulong _state;
+
+        public NativePcgRandom(Guid seed)
+        {
+            byte[] guidArray = seed.ToByteArray();
+            _state = BitConverter.ToUInt64(guidArray, 0);
+            _increment = BitConverter.ToUInt64(guidArray, sizeof(ulong));
+        }
+
+        public NativePcgRandom(int seed)
+        {
+            _increment = 6554638469UL;
+            _state = unchecked((ulong)seed);
+            _increment = NextUlong();
+        }
+
+        public uint NextUint()
+        {
+            unchecked
+            {
+                ulong oldState = _state;
+                _state = oldState * 6364136223846793005UL + _increment;
+                uint xorShifted = (uint)(((oldState >> 18) ^ oldState) >> 27);
+                int rot = (int)(oldState >> 59);
+                return (xorShifted >> rot) | (xorShifted << (-rot & 31));
+            }
+        }
+
+        public int Next(int max)
+        {
+            if (max <= 0)
+            {
+                throw new ArgumentException($"Max {max} cannot be less-than or equal-to 0");
+            }
+
+            return unchecked((int)NextUint(unchecked((uint)max)));
+        }
+
+        public uint NextUint(uint max)
+        {
+            /*
+                https://github.com/libevent/libevent/blob/3807a30b03ab42f2f503f2db62b1ef5876e2be80/arc4random.c#L531
+
+                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)
+            {
+                uint randomValue = NextUint();
+                if (threshold <= randomValue)
+                {
+                    return randomValue % max;
+                }
+            }
+        }
+
+        public long NextLong()
+        {
+            uint upper = NextUint();
+            uint lower = NextUint();
+            // Mix things up a little
+            if (NextBool())
+            {
+                return unchecked((long)((ulong)upper << 32) | lower);
+            }
+            return unchecked((long)((ulong)lower << 32) | upper);
+        }
+
+        public ulong NextUlong()
+        {
+            return unchecked((ulong)NextLong());
+        }
+
+        public bool NextBool()
+        {
+            return NextUint() < HalfwayUint;
+        }
+
+        public float NextFloat()
+        {
+            uint floatAsInt = NextUint();
+            return (floatAsInt >> 8) * MagicFloat;
+        }
+    }
+}

package/Runtime/Core/Random/PRNG.cs

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

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

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

package/Runtime/Core/Random/PcgRandom.cs

@@ -1,149 +1,149 @@
-namespace UnityHelpers.Core.Random
-{
-    using System;
-    using System.Runtime.Serialization;
-    using System.Text.Json.Serialization;
-
-    /// <summary>
-    ///     Implementation based off of the reference PCG Random, found here: https://www.pcg-random.org/index.html
-    /// </summary>
-    [Serializable]
-    [DataContract]
-    public sealed class PcgRandom
-        : AbstractRandom,
-            IEquatable<PcgRandom>,
-            IComparable,
-            IComparable<PcgRandom>
-    {
-        public static PcgRandom Instance => ThreadLocalRandom<PcgRandom>.Instance;
-
-        public override RandomState InternalState => new(_state, _increment, _cachedGaussian);
-
-        internal readonly ulong _increment;
-
-        internal ulong _state;
-
-        public PcgRandom()
-            : this(Guid.NewGuid()) { }
-
-        public PcgRandom(Guid guid)
-        {
-            byte[] guidArray = guid.ToByteArray();
-            _state = BitConverter.ToUInt64(guidArray, 0);
-            _increment = BitConverter.ToUInt64(guidArray, sizeof(ulong));
-        }
-
-        [JsonConstructor]
-        public PcgRandom(RandomState internalState)
-        {
-            _state = internalState.State1;
-            _increment = internalState.State2;
-            _cachedGaussian = internalState.Gaussian;
-        }
-
-        public PcgRandom(ulong increment, ulong state)
-        {
-            _increment = increment;
-            _state = state;
-        }
-
-        public PcgRandom(long seed)
-        {
-            // Start with a nice prime
-            _increment = 6554638469UL;
-            _state = unchecked((ulong)seed);
-            _increment = NextUlong();
-        }
-
-        public override uint NextUint()
-        {
-            unchecked
-            {
-                ulong oldState = _state;
-                _state = oldState * 6364136223846793005UL + _increment;
-                uint xorShifted = (uint)(((oldState >> 18) ^ oldState) >> 27);
-                int rot = (int)(oldState >> 59);
-                return (xorShifted >> rot) | (xorShifted << (-rot & 31));
-            }
-        }
-
-        public bool Equals(PcgRandom other)
-        {
-            if (ReferenceEquals(other, null))
-            {
-                return false;
-            }
-
-            // ReSharper disable once CompareOfFloatsByEqualityOperator
-            return _increment == other._increment
-                && _state == other._state
-                && _cachedGaussian == other._cachedGaussian;
-        }
-
-        public override bool Equals(object obj)
-        {
-            return Equals(obj as PcgRandom);
-        }
-
-        public int CompareTo(PcgRandom other)
-        {
-            if (ReferenceEquals(other, null))
-            {
-                return -1;
-            }
-
-            if (_increment == other._increment)
-            {
-                if (_state == other._state)
-                {
-                    return 0;
-                }
-
-                if (_state < other._state)
-                {
-                    return -1;
-                }
-
-                return 1;
-            }
-
-            if (_increment < other._increment)
-            {
-                return -1;
-            }
-
-            if (_cachedGaussian.HasValue != other._cachedGaussian.HasValue)
-            {
-                return _cachedGaussian.HasValue ? -1 : 1;
-            }
-
-            if (!_cachedGaussian.HasValue)
-            {
-                return 0;
-            }
-
-            // ReSharper disable once PossibleInvalidOperationException
-            return _cachedGaussian.Value.CompareTo(other._cachedGaussian.Value);
-        }
-
-        public int CompareTo(object obj)
-        {
-            return CompareTo(obj as PcgRandom);
-        }
-
-        public override int GetHashCode()
-        {
-            return _increment.GetHashCode();
-        }
-
-        public override string ToString()
-        {
-            return $"{{\"Increment\": {_increment}, \"State\": {_state}}}";
-        }
-
-        public override IRandom Copy()
-        {
-            return new PcgRandom(InternalState);
-        }
-    }
-}
+namespace UnityHelpers.Core.Random
+{
+    using System;
+    using System.Runtime.Serialization;
+    using System.Text.Json.Serialization;
+
+    /// <summary>
+    ///     Implementation based off of the reference PCG Random, found here: https://www.pcg-random.org/index.html
+    /// </summary>
+    [Serializable]
+    [DataContract]
+    public sealed class PcgRandom
+        : AbstractRandom,
+            IEquatable<PcgRandom>,
+            IComparable,
+            IComparable<PcgRandom>
+    {
+        public static PcgRandom Instance => ThreadLocalRandom<PcgRandom>.Instance;
+
+        public override RandomState InternalState => new(_state, _increment, _cachedGaussian);
+
+        internal readonly ulong _increment;
+
+        internal ulong _state;
+
+        public PcgRandom()
+            : this(Guid.NewGuid()) { }
+
+        public PcgRandom(Guid guid)
+        {
+            byte[] guidArray = guid.ToByteArray();
+            _state = BitConverter.ToUInt64(guidArray, 0);
+            _increment = BitConverter.ToUInt64(guidArray, sizeof(ulong));
+        }
+
+        [JsonConstructor]
+        public PcgRandom(RandomState internalState)
+        {
+            _state = internalState.State1;
+            _increment = internalState.State2;
+            _cachedGaussian = internalState.Gaussian;
+        }
+
+        public PcgRandom(ulong increment, ulong state)
+        {
+            _increment = increment;
+            _state = state;
+        }
+
+        public PcgRandom(long seed)
+        {
+            // Start with a nice prime
+            _increment = 6554638469UL;
+            _state = unchecked((ulong)seed);
+            _increment = NextUlong();
+        }
+
+        public override uint NextUint()
+        {
+            unchecked
+            {
+                ulong oldState = _state;
+                _state = oldState * 6364136223846793005UL + _increment;
+                uint xorShifted = (uint)(((oldState >> 18) ^ oldState) >> 27);
+                int rot = (int)(oldState >> 59);
+                return (xorShifted >> rot) | (xorShifted << (-rot & 31));
+            }
+        }
+
+        public bool Equals(PcgRandom other)
+        {
+            if (ReferenceEquals(other, null))
+            {
+                return false;
+            }
+
+            // ReSharper disable once CompareOfFloatsByEqualityOperator
+            return _increment == other._increment
+                && _state == other._state
+                && _cachedGaussian == other._cachedGaussian;
+        }
+
+        public override bool Equals(object obj)
+        {
+            return Equals(obj as PcgRandom);
+        }
+
+        public int CompareTo(PcgRandom other)
+        {
+            if (ReferenceEquals(other, null))
+            {
+                return -1;
+            }
+
+            if (_increment == other._increment)
+            {
+                if (_state == other._state)
+                {
+                    return 0;
+                }
+
+                if (_state < other._state)
+                {
+                    return -1;
+                }
+
+                return 1;
+            }
+
+            if (_increment < other._increment)
+            {
+                return -1;
+            }
+
+            if (_cachedGaussian.HasValue != other._cachedGaussian.HasValue)
+            {
+                return _cachedGaussian.HasValue ? -1 : 1;
+            }
+
+            if (!_cachedGaussian.HasValue)
+            {
+                return 0;
+            }
+
+            // ReSharper disable once PossibleInvalidOperationException
+            return _cachedGaussian.Value.CompareTo(other._cachedGaussian.Value);
+        }
+
+        public int CompareTo(object obj)
+        {
+            return CompareTo(obj as PcgRandom);
+        }
+
+        public override int GetHashCode()
+        {
+            return _increment.GetHashCode();
+        }
+
+        public override string ToString()
+        {
+            return $"{{\"Increment\": {_increment}, \"State\": {_state}}}";
+        }
+
+        public override IRandom Copy()
+        {
+            return new PcgRandom(InternalState);
+        }
+    }
+}