com.wallstop-studios.unity-helpers 2.0.0-rc26 → 2.0.0-rc30

package/Runtime/Core/Random/SystemRandom.cs

@@ -1,162 +1,162 @@
-namespace UnityHelpers.Core.Random
-{
-    using System;
-    using System.Runtime.Serialization;
-    using System.Text.Json.Serialization;
-    using Helper;
-
-    /// <summary>
-    ///     Implementation dependent upon .Net's Random class.
-    /// </summary>
-    [Serializable]
-    [DataContract]
-    public sealed class SystemRandom : AbstractRandom
-    {
-        private const int HalfwayInt = int.MaxValue / 2;
-        private const int SeedArraySize = 56;
-        private const int LastSeedIndex = SeedArraySize - 1;
-
-        public static IRandom Instance => ThreadLocalRandom<SystemRandom>.Instance;
-
-        public override RandomState InternalState =>
-            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, a fact which defeats the purpose of these serializable
-            randoms.
-         */
-        private int _inext;
-        private int _inextp;
-        private readonly int[] _seedArray = new int[SeedArraySize];
-
-        public SystemRandom()
-            : this(Guid.NewGuid().GetHashCode()) { }
-
-        public SystemRandom(int seed)
-        {
-            int num1 = 161803398 - (seed == int.MinValue ? int.MaxValue : Math.Abs(seed));
-            _seedArray[LastSeedIndex] = num1;
-            int num2 = 1;
-            for (int index1 = 1; index1 < LastSeedIndex; ++index1)
-            {
-                int index2 = 21 * index1 % LastSeedIndex;
-                _seedArray[index2] = num2;
-                num2 = num1 - num2;
-                if (num2 < 0)
-                {
-                    num2 += int.MaxValue;
-                }
-
-                num1 = _seedArray[index2];
-            }
-            for (int index3 = 1; index3 < 5; ++index3)
-            {
-                for (int index4 = 1; index4 < SeedArraySize; ++index4)
-                {
-                    int value = _seedArray[index4] -= _seedArray[1 + (index4 + 30) % LastSeedIndex];
-                    if (value < 0)
-                    {
-                        _seedArray[index4] += int.MaxValue;
-                    }
-                }
-            }
-
-            _inext = 0;
-            _inextp = 21;
-        }
-
-        [JsonConstructor]
-        public SystemRandom(RandomState internalState)
-        {
-            unchecked
-            {
-                _inext = (int)internalState.State1;
-                _inextp = (int)internalState.State2;
-            }
-            _cachedGaussian = internalState.Gaussian;
-            _seedArray = ArrayConverter.ByteArrayToIntArrayBlockCopy(internalState.Payload);
-        }
-
-        public override int Next()
-        {
-            int localINext = _inext;
-            int localINextP = _inextp;
-            int index1;
-            if ((index1 = localINext + 1) >= SeedArraySize)
-            {
-                index1 = 1;
-            }
-
-            int index2;
-            if ((index2 = localINextP + 1) >= SeedArraySize)
-            {
-                index2 = 1;
-            }
-
-            int num = _seedArray[index1] - _seedArray[index2];
-            if (num == int.MaxValue)
-            {
-                --num;
-            }
-
-            if (num < 0)
-            {
-                num += int.MaxValue;
-            }
-
-            _seedArray[index1] = num;
-            _inext = index1;
-            _inextp = index2;
-            return num;
-        }
-
-        public override uint NextUint()
-        {
-            if (NextBool())
-            {
-                return unchecked((uint)(Next() ^ 0x80000000));
-            }
-            return unchecked((uint)Next());
-        }
-
-        public override bool NextBool()
-        {
-            return Next() < HalfwayInt;
-        }
-
-        public override double NextDouble()
-        {
-            double random;
-            do
-            {
-                random = Next() / (1.0 * int.MaxValue);
-            } while (1.0 <= random);
-
-            return random;
-        }
-
-        public override float NextFloat()
-        {
-            float random;
-            do
-            {
-                random = Next() * (1f / int.MaxValue);
-            } while (1f <= random);
-
-            return random;
-        }
-
-        public override IRandom Copy()
-        {
-            SystemRandom copy = new(InternalState);
-            Array.Copy(_seedArray, copy._seedArray, _seedArray.Length);
-            return copy;
-        }
-    }
-}
+namespace UnityHelpers.Core.Random
+{
+    using System;
+    using System.Runtime.Serialization;
+    using System.Text.Json.Serialization;
+    using Helper;
+
+    /// <summary>
+    ///     Implementation dependent upon .Net's Random class.
+    /// </summary>
+    [Serializable]
+    [DataContract]
+    public sealed class SystemRandom : AbstractRandom
+    {
+        private const int HalfwayInt = int.MaxValue / 2;
+        private const int SeedArraySize = 56;
+        private const int LastSeedIndex = SeedArraySize - 1;
+
+        public static IRandom Instance => ThreadLocalRandom<SystemRandom>.Instance;
+
+        public override RandomState InternalState =>
+            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, a fact which defeats the purpose of these serializable
+            randoms.
+         */
+        private int _inext;
+        private int _inextp;
+        private readonly int[] _seedArray = new int[SeedArraySize];
+
+        public SystemRandom()
+            : this(Guid.NewGuid().GetHashCode()) { }
+
+        public SystemRandom(int seed)
+        {
+            int num1 = 161803398 - (seed == int.MinValue ? int.MaxValue : Math.Abs(seed));
+            _seedArray[LastSeedIndex] = num1;
+            int num2 = 1;
+            for (int index1 = 1; index1 < LastSeedIndex; ++index1)
+            {
+                int index2 = 21 * index1 % LastSeedIndex;
+                _seedArray[index2] = num2;
+                num2 = num1 - num2;
+                if (num2 < 0)
+                {
+                    num2 += int.MaxValue;
+                }
+
+                num1 = _seedArray[index2];
+            }
+            for (int index3 = 1; index3 < 5; ++index3)
+            {
+                for (int index4 = 1; index4 < SeedArraySize; ++index4)
+                {
+                    int value = _seedArray[index4] -= _seedArray[1 + (index4 + 30) % LastSeedIndex];
+                    if (value < 0)
+                    {
+                        _seedArray[index4] += int.MaxValue;
+                    }
+                }
+            }
+
+            _inext = 0;
+            _inextp = 21;
+        }
+
+        [JsonConstructor]
+        public SystemRandom(RandomState internalState)
+        {
+            unchecked
+            {
+                _inext = (int)internalState.State1;
+                _inextp = (int)internalState.State2;
+            }
+            _cachedGaussian = internalState.Gaussian;
+            _seedArray = ArrayConverter.ByteArrayToIntArrayBlockCopy(internalState.Payload);
+        }
+
+        public override int Next()
+        {
+            int localINext = _inext;
+            int localINextP = _inextp;
+            int index1;
+            if ((index1 = localINext + 1) >= SeedArraySize)
+            {
+                index1 = 1;
+            }
+
+            int index2;
+            if ((index2 = localINextP + 1) >= SeedArraySize)
+            {
+                index2 = 1;
+            }
+
+            int num = _seedArray[index1] - _seedArray[index2];
+            if (num == int.MaxValue)
+            {
+                --num;
+            }
+
+            if (num < 0)
+            {
+                num += int.MaxValue;
+            }
+
+            _seedArray[index1] = num;
+            _inext = index1;
+            _inextp = index2;
+            return num;
+        }
+
+        public override uint NextUint()
+        {
+            if (NextBool())
+            {
+                return unchecked((uint)(Next() ^ 0x80000000));
+            }
+            return unchecked((uint)Next());
+        }
+
+        public override bool NextBool()
+        {
+            return Next() < HalfwayInt;
+        }
+
+        public override double NextDouble()
+        {
+            double random;
+            do
+            {
+                random = Next() / (1.0 * int.MaxValue);
+            } while (1.0 <= random);
+
+            return random;
+        }
+
+        public override float NextFloat()
+        {
+            float random;
+            do
+            {
+                random = Next() * (1f / int.MaxValue);
+            } while (1f <= random);
+
+            return random;
+        }
+
+        public override IRandom Copy()
+        {
+            SystemRandom copy = new(InternalState);
+            Array.Copy(_seedArray, copy._seedArray, _seedArray.Length);
+            return copy;
+        }
+    }
+}

package/Runtime/Core/Random/ThreadLocalRandom.cs

@@ -1,12 +1,12 @@
-namespace UnityHelpers.Core.Random
-{
-    using System.Threading;
-
-    public static class ThreadLocalRandom<T>
-        where T : IRandom, new()
-    {
-        private static readonly ThreadLocal<T> RandomCache = new ThreadLocal<T>(() => new T());
-
-        public static T Instance => RandomCache.Value;
-    }
-}
+namespace UnityHelpers.Core.Random
+{
+    using System.Threading;
+
+    public static class ThreadLocalRandom<T>
+        where T : IRandom, new()
+    {
+        private static readonly ThreadLocal<T> RandomCache = new ThreadLocal<T>(() => new T());
+
+        public static T Instance => RandomCache.Value;
+    }
+}

package/Runtime/Core/Random/UnityRandom.cs

@@ -1,57 +1,57 @@
-namespace UnityHelpers.Core.Random
-{
-    using System;
-    using System.Runtime.Serialization;
-    using System.Text.Json.Serialization;
-
-    [Serializable]
-    [DataContract]
-    public sealed class UnityRandom : AbstractRandom
-    {
-        public static readonly UnityRandom Instance = new();
-
-        public override RandomState InternalState
-        {
-            get
-            {
-                unchecked
-                {
-                    return new RandomState(
-                        (ulong)(_seed ?? 0),
-                        gaussian: _seed != null ? 0.0 : null
-                    );
-                }
-            }
-        }
-
-        private readonly int? _seed;
-
-        public UnityRandom(int? seed = null)
-        {
-            if (seed != null)
-            {
-                _seed = seed.Value;
-                UnityEngine.Random.InitState(seed.Value);
-            }
-        }
-
-        [JsonConstructor]
-        public UnityRandom(RandomState internalState)
-        {
-            unchecked
-            {
-                _seed = internalState.Gaussian != null ? (int)internalState.State1 : null;
-            }
-        }
-
-        public override uint NextUint()
-        {
-            return unchecked((uint)UnityEngine.Random.Range(int.MinValue, int.MaxValue));
-        }
-
-        public override IRandom Copy()
-        {
-            return new UnityRandom(_seed);
-        }
-    }
-}
+namespace UnityHelpers.Core.Random
+{
+    using System;
+    using System.Runtime.Serialization;
+    using System.Text.Json.Serialization;
+
+    [Serializable]
+    [DataContract]
+    public sealed class UnityRandom : AbstractRandom
+    {
+        public static readonly UnityRandom Instance = new();
+
+        public override RandomState InternalState
+        {
+            get
+            {
+                unchecked
+                {
+                    return new RandomState(
+                        (ulong)(_seed ?? 0),
+                        gaussian: _seed != null ? 0.0 : null
+                    );
+                }
+            }
+        }
+
+        private readonly int? _seed;
+
+        public UnityRandom(int? seed = null)
+        {
+            if (seed != null)
+            {
+                _seed = seed.Value;
+                UnityEngine.Random.InitState(seed.Value);
+            }
+        }
+
+        [JsonConstructor]
+        public UnityRandom(RandomState internalState)
+        {
+            unchecked
+            {
+                _seed = internalState.Gaussian != null ? (int)internalState.State1 : null;
+            }
+        }
+
+        public override uint NextUint()
+        {
+            return unchecked((uint)UnityEngine.Random.Range(int.MinValue, int.MaxValue));
+        }
+
+        public override IRandom Copy()
+        {
+            return new UnityRandom(_seed);
+        }
+    }
+}

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

@@ -1,11 +1,11 @@
-fileFormatVersion: 2
-guid: 8588ccb12c40bf24da31067ccfd067f9
-MonoImporter:
-  externalObjects: {}
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
+fileFormatVersion: 2
+guid: 8588ccb12c40bf24da31067ccfd067f9
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: