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

package/Runtime/Core/Random/WyRandom.cs

@@ -1,121 +1,121 @@
-namespace UnityHelpers.Core.Random
-{
-    using System;
-    using System.Diagnostics.CodeAnalysis;
-    using System.Runtime.CompilerServices;
-    using System.Runtime.Serialization;
-    using System.Text.Json.Serialization;
-
-    // https://github.com/cocowalla/wyhash-dotnet/blob/master/src/WyHash/WyRng.cs
-    [Serializable]
-    [DataContract]
-    public sealed class WyRandom : AbstractRandom
-    {
-        private const ulong Prime0 = 0xa0761d6478bd642f;
-        private const ulong Prime1 = 0xe7037ed1a0b428db;
-
-        public static IRandom Instance => ThreadLocalRandom<WyRandom>.Instance;
-
-        public override RandomState InternalState => new RandomState(_state);
-
-        private ulong _state;
-
-        public WyRandom()
-            : this(Guid.NewGuid()) { }
-
-        public WyRandom(Guid guid)
-        {
-            byte[] guidArray = guid.ToByteArray();
-            _state = BitConverter.ToUInt64(guidArray, 0);
-        }
-
-        [JsonConstructor]
-        public WyRandom(RandomState internalState)
-        {
-            _state = internalState.State1;
-        }
-
-        public WyRandom(ulong state)
-        {
-            _state = state;
-        }
-
-        public override uint NextUint()
-        {
-            unchecked
-            {
-                _state += Prime0;
-                return (uint)Mum(_state ^ Prime1, _state);
-            }
-        }
-
-        /// <summary>
-        /// Perform a MUM (MUltiply and Mix) operation. Multiplies 2 unsigned 64-bit integers, then combines the
-        /// hi and lo bits of the resulting 128-bit integer using XOR
-        /// </summary>
-        /// <param name="x">First 64-bit integer</param>
-        /// <param name="y">Second 64-bit integer</param>
-        /// <returns>Result of the MUM (MUltiply and Mix) operation</returns>
-        private static ulong Mum(ulong x, ulong y)
-        {
-            (ulong hi, ulong lo) = Multiply64(x, y);
-            return hi ^ lo;
-        }
-
-        /// <summary>
-        /// Multiplies 2 unsigned 64-bit integers, returning the result in 2 ulongs representing the hi and lo bits
-        /// of the resulting 128-bit integer
-        ///
-        /// Source: https://stackoverflow.com/a/51587262/25758, but with a faster lo calculation
-        /// </summary>
-        /// <remarks>
-        /// <seealso cref="System.Numerics.BigInteger"/> can perform multiplication on large integers, but it's
-        /// comparatively slow, and an equivalent method allocates around 360B/call
-        /// </remarks>
-        /// <param name="x">First 64-bit integer</param>
-        /// <param name="y">Second 64-bit integer</param>
-        /// <returns>Product of <paramref name="x"/> and <paramref name="y"/></returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        [SuppressMessage("ReSharper", "JoinDeclarationAndInitializer")]
-        private static unsafe (ulong Hi, ulong Lo) Multiply64(ulong x, ulong y)
-        {
-            ulong hi;
-            ulong lo;
-
-            // Use BMI2 intrinsics where available
-#if NETCOREAPP3_0_OR_GREATER
-            if (System.Runtime.Intrinsics.X86.Bmi2.X64.IsSupported)
-            {
-                hi = System.Runtime.Intrinsics.X86.Bmi2.X64.MultiplyNoFlags(x, y, &lo);
-                return (hi, lo);
-            }
-#endif
-
-            lo = x * y;
-
-            ulong x0 = (uint)x;
-            ulong x1 = x >> 32;
-
-            ulong y0 = (uint)y;
-            ulong y1 = y >> 32;
-
-            ulong p11 = x1 * y1;
-            ulong p01 = x0 * y1;
-            ulong p10 = x1 * y0;
-            ulong p00 = x0 * y0;
-
-            // 64-bit product + two 32-bit values
-            ulong middle = p10 + (p00 >> 32) + (uint)p01;
-
-            // 64-bit product + two 32-bit values
-            hi = p11 + (middle >> 32) + (p01 >> 32);
-
-            return (hi, lo);
-        }
-
-        public override IRandom Copy()
-        {
-            return new WyRandom(_state);
-        }
-    }
-}
+namespace UnityHelpers.Core.Random
+{
+    using System;
+    using System.Diagnostics.CodeAnalysis;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.Serialization;
+    using System.Text.Json.Serialization;
+
+    // https://github.com/cocowalla/wyhash-dotnet/blob/master/src/WyHash/WyRng.cs
+    [Serializable]
+    [DataContract]
+    public sealed class WyRandom : AbstractRandom
+    {
+        private const ulong Prime0 = 0xa0761d6478bd642f;
+        private const ulong Prime1 = 0xe7037ed1a0b428db;
+
+        public static IRandom Instance => ThreadLocalRandom<WyRandom>.Instance;
+
+        public override RandomState InternalState => new RandomState(_state);
+
+        private ulong _state;
+
+        public WyRandom()
+            : this(Guid.NewGuid()) { }
+
+        public WyRandom(Guid guid)
+        {
+            byte[] guidArray = guid.ToByteArray();
+            _state = BitConverter.ToUInt64(guidArray, 0);
+        }
+
+        [JsonConstructor]
+        public WyRandom(RandomState internalState)
+        {
+            _state = internalState.State1;
+        }
+
+        public WyRandom(ulong state)
+        {
+            _state = state;
+        }
+
+        public override uint NextUint()
+        {
+            unchecked
+            {
+                _state += Prime0;
+                return (uint)Mum(_state ^ Prime1, _state);
+            }
+        }
+
+        /// <summary>
+        /// Perform a MUM (MUltiply and Mix) operation. Multiplies 2 unsigned 64-bit integers, then combines the
+        /// hi and lo bits of the resulting 128-bit integer using XOR
+        /// </summary>
+        /// <param name="x">First 64-bit integer</param>
+        /// <param name="y">Second 64-bit integer</param>
+        /// <returns>Result of the MUM (MUltiply and Mix) operation</returns>
+        private static ulong Mum(ulong x, ulong y)
+        {
+            (ulong hi, ulong lo) = Multiply64(x, y);
+            return hi ^ lo;
+        }
+
+        /// <summary>
+        /// Multiplies 2 unsigned 64-bit integers, returning the result in 2 ulongs representing the hi and lo bits
+        /// of the resulting 128-bit integer
+        ///
+        /// Source: https://stackoverflow.com/a/51587262/25758, but with a faster lo calculation
+        /// </summary>
+        /// <remarks>
+        /// <seealso cref="System.Numerics.BigInteger"/> can perform multiplication on large integers, but it's
+        /// comparatively slow, and an equivalent method allocates around 360B/call
+        /// </remarks>
+        /// <param name="x">First 64-bit integer</param>
+        /// <param name="y">Second 64-bit integer</param>
+        /// <returns>Product of <paramref name="x"/> and <paramref name="y"/></returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [SuppressMessage("ReSharper", "JoinDeclarationAndInitializer")]
+        private static unsafe (ulong Hi, ulong Lo) Multiply64(ulong x, ulong y)
+        {
+            ulong hi;
+            ulong lo;
+
+            // Use BMI2 intrinsics where available
+#if NETCOREAPP3_0_OR_GREATER
+            if (System.Runtime.Intrinsics.X86.Bmi2.X64.IsSupported)
+            {
+                hi = System.Runtime.Intrinsics.X86.Bmi2.X64.MultiplyNoFlags(x, y, &lo);
+                return (hi, lo);
+            }
+#endif
+
+            lo = x * y;
+
+            ulong x0 = (uint)x;
+            ulong x1 = x >> 32;
+
+            ulong y0 = (uint)y;
+            ulong y1 = y >> 32;
+
+            ulong p11 = x1 * y1;
+            ulong p01 = x0 * y1;
+            ulong p10 = x1 * y0;
+            ulong p00 = x0 * y0;
+
+            // 64-bit product + two 32-bit values
+            ulong middle = p10 + (p00 >> 32) + (uint)p01;
+
+            // 64-bit product + two 32-bit values
+            hi = p11 + (middle >> 32) + (p01 >> 32);
+
+            return (hi, lo);
+        }
+
+        public override IRandom Copy()
+        {
+            return new WyRandom(_state);
+        }
+    }
+}

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

@@ -1,3 +1,3 @@
-fileFormatVersion: 2
-guid: bdbd63a5a5794111b6f4d3e965137f3f
+fileFormatVersion: 2
+guid: bdbd63a5a5794111b6f4d3e965137f3f
 timeCreated: 1732479831

package/Runtime/Core/Random/XorShiftRandom.cs

@@ -1,47 +1,47 @@
-namespace UnityHelpers.Core.Random
-{
-    using System;
-    using System.Runtime.Serialization;
-    using System.Text.Json.Serialization;
-
-    [Serializable]
-    [DataContract]
-    public sealed class XorShiftRandom : AbstractRandom
-    {
-        public static IRandom Instance => ThreadLocalRandom<XorShiftRandom>.Instance;
-
-        public override RandomState InternalState => new(_state, 0, _cachedGaussian);
-
-        private uint _state;
-
-        public XorShiftRandom()
-            : this(Guid.NewGuid().GetHashCode()) { }
-
-        public XorShiftRandom(int state)
-        {
-            _state = unchecked((uint)state);
-        }
-
-        [JsonConstructor]
-        public XorShiftRandom(RandomState internalState)
-        {
-            _state = unchecked((uint)internalState.State1);
-            _cachedGaussian = internalState.Gaussian;
-        }
-
-        public override uint NextUint()
-        {
-            uint state = _state;
-            state ^= state << 13;
-            state ^= state >> 17;
-            state ^= state << 5;
-            _state = state;
-            return state;
-        }
-
-        public override IRandom Copy()
-        {
-            return new XorShiftRandom(InternalState);
-        }
-    }
-}
+namespace UnityHelpers.Core.Random
+{
+    using System;
+    using System.Runtime.Serialization;
+    using System.Text.Json.Serialization;
+
+    [Serializable]
+    [DataContract]
+    public sealed class XorShiftRandom : AbstractRandom
+    {
+        public static IRandom Instance => ThreadLocalRandom<XorShiftRandom>.Instance;
+
+        public override RandomState InternalState => new(_state, 0, _cachedGaussian);
+
+        private uint _state;
+
+        public XorShiftRandom()
+            : this(Guid.NewGuid().GetHashCode()) { }
+
+        public XorShiftRandom(int state)
+        {
+            _state = unchecked((uint)state);
+        }
+
+        [JsonConstructor]
+        public XorShiftRandom(RandomState internalState)
+        {
+            _state = unchecked((uint)internalState.State1);
+            _cachedGaussian = internalState.Gaussian;
+        }
+
+        public override uint NextUint()
+        {
+            uint state = _state;
+            state ^= state << 13;
+            state ^= state >> 17;
+            state ^= state << 5;
+            _state = state;
+            return state;
+        }
+
+        public override IRandom Copy()
+        {
+            return new XorShiftRandom(InternalState);
+        }
+    }
+}

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

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

package/Runtime/Core/Random/XorShiroRandom.cs

@@ -1,117 +1,117 @@
-namespace UnityHelpers.Core.Random
-{
-    using System;
-    using System.Runtime.CompilerServices;
-    using System.Text.Json.Serialization;
-    using Extension;
-    using Helper;
-
-    public sealed class XorShiroRandom
-        : AbstractRandom,
-            IEquatable<XorShiroRandom>,
-            IComparable,
-            IComparable<XorShiroRandom>
-    {
-        public override RandomState InternalState => new(_s0, _s1, _cachedGaussian);
-
-        internal ulong _s0;
-        internal ulong _s1;
-
-        public XorShiroRandom()
-            : this(Guid.NewGuid()) { }
-
-        public XorShiroRandom(Guid guid)
-        {
-            byte[] bytes = guid.ToByteArray();
-            _s0 = BitConverter.ToUInt64(bytes, 0);
-            _s1 = BitConverter.ToUInt64(bytes, 8);
-        }
-
-        public XorShiroRandom(ulong seed1, ulong seed2)
-        {
-            _s0 = seed1;
-            _s1 = seed2;
-        }
-
-        [JsonConstructor]
-        public XorShiroRandom(RandomState internalState)
-        {
-            _s0 = internalState.State1;
-            _s1 = internalState.State2;
-            _cachedGaussian = internalState.Gaussian;
-        }
-
-        public override uint NextUint()
-        {
-            unchecked
-            {
-                ulong s0 = _s0;
-                ulong s1 = _s1;
-                ulong result = s0 + s1;
-
-                s1 ^= s0;
-                _s0 = Rotl(s0, 24) ^ s1 ^ (s1 << 16);
-                _s1 = Rotl(s1, 37);
-
-                return (uint)result;
-            }
-        }
-
-        public override IRandom Copy()
-        {
-            return new XorShiroRandom(InternalState);
-        }
-
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static ulong Rotl(ulong x, int k)
-        {
-            return (x << k) | (x >> (64 - k));
-        }
-
-        public override bool Equals(object obj)
-        {
-            return Equals(obj as XorShiroRandom);
-        }
-
-        public bool Equals(XorShiroRandom other)
-        {
-            if (other == null)
-            {
-                return false;
-            }
-
-            return _s0 == other._s0 && _s1 == other._s1;
-        }
-
-        public override int GetHashCode()
-        {
-            return Objects.ValueTypeHashCode(_s0, _s1);
-        }
-
-        public override string ToString()
-        {
-            return this.ToJson();
-        }
-
-        public int CompareTo(object obj)
-        {
-            return CompareTo(obj as XorShiroRandom);
-        }
-
-        public int CompareTo(XorShiroRandom other)
-        {
-            if (other == null)
-            {
-                return -1;
-            }
-
-            int comparison = _s0.CompareTo(other._s0);
-            if (comparison != 0)
-            {
-                return comparison;
-            }
-
-            return _s1.CompareTo(other._s1);
-        }
-    }
-}
+namespace UnityHelpers.Core.Random
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using System.Text.Json.Serialization;
+    using Extension;
+    using Helper;
+
+    public sealed class XorShiroRandom
+        : AbstractRandom,
+            IEquatable<XorShiroRandom>,
+            IComparable,
+            IComparable<XorShiroRandom>
+    {
+        public override RandomState InternalState => new(_s0, _s1, _cachedGaussian);
+
+        internal ulong _s0;
+        internal ulong _s1;
+
+        public XorShiroRandom()
+            : this(Guid.NewGuid()) { }
+
+        public XorShiroRandom(Guid guid)
+        {
+            byte[] bytes = guid.ToByteArray();
+            _s0 = BitConverter.ToUInt64(bytes, 0);
+            _s1 = BitConverter.ToUInt64(bytes, 8);
+        }
+
+        public XorShiroRandom(ulong seed1, ulong seed2)
+        {
+            _s0 = seed1;
+            _s1 = seed2;
+        }
+
+        [JsonConstructor]
+        public XorShiroRandom(RandomState internalState)
+        {
+            _s0 = internalState.State1;
+            _s1 = internalState.State2;
+            _cachedGaussian = internalState.Gaussian;
+        }
+
+        public override uint NextUint()
+        {
+            unchecked
+            {
+                ulong s0 = _s0;
+                ulong s1 = _s1;
+                ulong result = s0 + s1;
+
+                s1 ^= s0;
+                _s0 = Rotl(s0, 24) ^ s1 ^ (s1 << 16);
+                _s1 = Rotl(s1, 37);
+
+                return (uint)result;
+            }
+        }
+
+        public override IRandom Copy()
+        {
+            return new XorShiroRandom(InternalState);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static ulong Rotl(ulong x, int k)
+        {
+            return (x << k) | (x >> (64 - k));
+        }
+
+        public override bool Equals(object obj)
+        {
+            return Equals(obj as XorShiroRandom);
+        }
+
+        public bool Equals(XorShiroRandom other)
+        {
+            if (other == null)
+            {
+                return false;
+            }
+
+            return _s0 == other._s0 && _s1 == other._s1;
+        }
+
+        public override int GetHashCode()
+        {
+            return Objects.ValueTypeHashCode(_s0, _s1);
+        }
+
+        public override string ToString()
+        {
+            return this.ToJson();
+        }
+
+        public int CompareTo(object obj)
+        {
+            return CompareTo(obj as XorShiroRandom);
+        }
+
+        public int CompareTo(XorShiroRandom other)
+        {
+            if (other == null)
+            {
+                return -1;
+            }
+
+            int comparison = _s0.CompareTo(other._s0);
+            if (comparison != 0)
+            {
+                return comparison;
+            }
+
+            return _s1.CompareTo(other._s1);
+        }
+    }
+}

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

@@ -1,3 +1,3 @@
-fileFormatVersion: 2
-guid: 1252767904fc4f4bb2a8a876964f2dfc
+fileFormatVersion: 2
+guid: 1252767904fc4f4bb2a8a876964f2dfc
 timeCreated: 1735610452