com.wallstop-studios.unity-helpers 1.0.0-rc4

package/Runtime/Core/Random/NativePcgRandom.cs

@@ -0,0 +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;
+        }
+    }
+}

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

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

package/Runtime/Core/Random/PcgRandom.cs

@@ -0,0 +1,142 @@
+namespace UnityHelpers.Core.Random
+{
+    using System;
+    using System.Runtime.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 IRandom Instance => ThreadLocalRandom<PcgRandom>.Instance;
+
+        [DataMember(Name = "Increment")]
+        internal readonly ulong _increment;
+        [DataMember(Name = "State")]
+        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));
+        }
+
+        public PcgRandom(RandomState randomState)
+        {
+            _state = randomState.State1;
+            _increment = randomState.State2;
+            _cachedGaussian = randomState.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 RandomState InternalState => new (_state, _increment, _cachedGaussian);
+
+        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 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 override bool Equals(object other)
+        {
+            return Equals(other as PcgRandom);
+        }
+
+        public override int GetHashCode()
+        {
+            return _increment.GetHashCode();
+        }
+
+        public override string ToString()
+        {
+            return $"{{\"Increment\": {_increment}, \"State\": {_state}}}";
+        }
+
+        public int CompareTo(object other)
+        {
+            return CompareTo(other as PcgRandom);
+        }
+
+        public override IRandom Copy()
+        {
+            return new PcgRandom(InternalState);
+        }
+    }
+}

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

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

package/Runtime/Core/Random/RandomState.cs

@@ -0,0 +1,92 @@
+namespace UnityHelpers.Core.Random
+{
+    using System;
+    using Extension;
+    using Helper;
+    using ProtoBuf;
+
+    [Serializable]
+    [ProtoContract]
+    public struct RandomState : IEquatable<RandomState>
+    {
+        public ulong State1 => _state1;
+        public ulong State2 => _state2;
+
+        public double? Gaussian
+        {
+            get
+            {
+                if (_hasGaussian)
+                {
+                    return _gaussian;
+                }
+
+                return null;
+            }
+        }
+
+        [ProtoMember(1)]
+        private ulong _state1;
+        [ProtoMember(2)]
+        private ulong _state2;
+
+        [ProtoMember(3)]
+        private bool _hasGaussian;
+
+        [ProtoMember(4)]
+        private double _gaussian;
+
+        private int _hashCode;
+
+        public RandomState(ulong state1, ulong state2 = 0, double? gaussian = null)
+        {
+            _state1 = state1;
+            _state2 = state2;
+            _hasGaussian = gaussian.HasValue;
+            _gaussian = gaussian ?? 0;
+            _hashCode = Objects.ValueTypeHashCode(state1, state2, _hasGaussian, _gaussian);
+        }
+
+        public RandomState(Guid guid)
+        {
+            byte[] guidBytes = guid.ToByteArray();
+            _state1 = BitConverter.ToUInt64(guidBytes, 0);
+            _state2 = BitConverter.ToUInt64(guidBytes, sizeof(ulong));
+            _hasGaussian = false;
+            _gaussian = 0;
+            _hashCode = Objects.ValueTypeHashCode(_state1, _state2, _hasGaussian, _gaussian);
+        }
+
+        [ProtoAfterDeserialization]
+        private void OnProtoDeserialize()
+        {
+            _hashCode = Objects.ValueTypeHashCode(_state1, _state2, _hasGaussian, _gaussian);
+        }
+
+        public override bool Equals(object other)
+        {
+            return other is RandomState randomState && Equals(randomState);
+        }
+
+        public bool Equals(RandomState other)
+        {
+            // ReSharper disable once CompareOfFloatsByEqualityOperator
+            return _state1 == other._state1 && _state2 == other._state2 && _hasGaussian == other._hasGaussian && (!_hasGaussian || _gaussian == other._gaussian);
+        }
+
+        public override int GetHashCode()
+        {
+            if (_hashCode == 0)
+            {
+                return _hashCode = Objects.ValueTypeHashCode(_state1, _state2, _hasGaussian, _gaussian);
+            }
+
+            return _hashCode;
+        }
+
+        public override string ToString()
+        {
+            return this.ToJson();
+        }
+    }
+}

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

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

package/Runtime/Core/Random/RandomUtilities.cs

@@ -0,0 +1,26 @@
+namespace UnityHelpers.Core.Random
+{
+    using UnityEngine;
+
+    public static class RandomUtilities
+    {
+        public static float GetRandomVariance(this IRandom random, float baseValue, float variance)
+        {
+            if (variance < 0.0f)
+            {
+                Debug.LogError("Variance cannot be negative");
+                return baseValue;
+            }
+
+            if (variance == 0.0f)
+            {
+                return baseValue;
+            }
+
+            float higher = variance / 2;
+            float lower = -higher;
+
+            return baseValue + random.NextFloat(lower, higher);
+        }
+    }
+}

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

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

package/Runtime/Core/Random/SquirrelRandom.cs

@@ -0,0 +1,82 @@
+namespace UnityHelpers.Core.Random
+{
+    using System;
+
+    // https://youtu.be/LWFzPP8ZbdU?t=2673
+    public sealed class SquirrelRandom : AbstractRandom
+    {
+        private const uint BitNoise1 = 0xB5297A4D;
+        private const uint BitNoise2 = 0x68E31DA4;
+        private const uint BitNoise3 = 0x1B56C4E9;
+        private const int LargePrime = 198491317;
+
+        public static readonly SquirrelRandom Instance = new();
+
+        private uint _position;
+
+        public SquirrelRandom() : this(Guid.NewGuid().GetHashCode())
+        {
+
+        }
+
+        public SquirrelRandom(int seed)
+        {
+            _position = unchecked((uint)seed);
+        }
+
+        public SquirrelRandom(RandomState randomState)
+        {
+            _position = unchecked((uint)randomState.State1);
+            _cachedGaussian = randomState.Gaussian;
+        }
+
+        public override RandomState InternalState => new(_position, gaussian: _cachedGaussian);
+
+        public override uint NextUint()
+        {
+            return _position = NextUintInternal(_position);
+        }
+
+        // Does not advance the RNG
+        public float NextNoise(int x, int y)
+        {
+            return NextNoise(x, y, _position);
+        }
+
+        public override IRandom Copy()
+        {
+            return new SquirrelRandom(InternalState);
+        }
+
+        private static uint NextUintInternal(uint seed)
+        {
+            uint result = seed;
+            result *= BitNoise1;
+            result ^= (result >> 8);
+            result += BitNoise2;
+            result ^= (result << 8);
+            result *= BitNoise3;
+            result ^= (result >> 8);
+            return result;
+        }
+
+        // https://youtu.be/LWFzPP8ZbdU?t=2906
+        private static float NextNoise(int x, uint seed)
+        {
+            uint result = unchecked((uint)x);
+            result *= BitNoise1;
+            result += seed;
+            result ^= (result >> 8);
+            result += BitNoise2;
+            result ^= (result << 8);
+            result *= BitNoise3;
+            result ^= (result >> 8);
+            return (result >> 8) * MagicFloat;
+        }
+
+        private static float NextNoise(int x, int y, uint seed)
+        {
+            return NextNoise(x + (LargePrime * y), seed);
+        }
+    }
+}

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

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

package/Runtime/Core/Random/SystemRandom.cs

@@ -0,0 +1,110 @@
+namespace UnityHelpers.Core.Random
+{
+    using System;
+
+    /// <summary>
+    ///     Implementation dependent upon .Net's Random class.
+    /// </summary>
+    public sealed class SystemRandom : AbstractRandom
+    {
+        /*
+            Copied from Random.cs source. Apparently it isn't guaranteed to be the
+            same across platforms and we depend on that.
+         */
+        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)
+        {
+        }
+
+        public SystemRandom(int seed)
+        {
+            int num1 = 161803398 - (seed == int.MinValue ? int.MaxValue : Math.Abs(seed));
+            this.SeedArray[55] = num1;
+            int num2 = 1;
+            for (int index1 = 1; index1 < 55; ++index1)
+            {
+                int index2 = 21 * index1 % 55;
+                this.SeedArray[index2] = num2;
+                num2 = num1 - num2;
+                if (num2 < 0)
+                    num2 += int.MaxValue;
+                num1 = this.SeedArray[index2];
+            }
+            for (int index3 = 1; index3 < 5; ++index3)
+            {
+                for (int index4 = 1; index4 < 56; ++index4)
+                {
+                    this.SeedArray[index4] -= this.SeedArray[1 + (index4 + 30) % 55];
+                    if (this.SeedArray[index4] < 0)
+                        this.SeedArray[index4] += int.MaxValue;
+                }
+            }
+            this.inext = 0;
+            this.inextp = 21;
+        }
+
+        public SystemRandom(RandomState randomState)
+        {
+            inext = unchecked((int)randomState.State1);
+            inextp = unchecked((int)randomState.State2);
+            _cachedGaussian = randomState.Gaussian;
+        }
+
+        public override RandomState InternalState => new(unchecked((ulong)inext), unchecked((ulong)inextp), _cachedGaussian);
+
+        public override uint NextUint()
+        {
+            int inext = this.inext;
+            int inextp = this.inextp;
+            int index1;
+            if ((index1 = inext + 1) >= 56)
+                index1 = 1;
+            int index2;
+            if ((index2 = inextp + 1) >= 56)
+                index2 = 1;
+            int num = this.SeedArray[index1] - this.SeedArray[index2];
+            if (num == int.MaxValue)
+                --num;
+            if (num < 0)
+                num += int.MaxValue;
+            this.SeedArray[index1] = num;
+            this.inext = index1;
+            this.inextp = index2;
+            return unchecked((uint) num);
+        }
+
+        public override double NextDouble()
+        {
+            double generated;
+            do
+            {
+                generated = unchecked((int)NextUint()) * 4.6566128752458E-10;
+            }
+            while (generated < 0 || 1 <= generated);
+
+            return generated;
+        }
+
+        public override float NextFloat()
+        {
+            return (float) NextDouble();
+        }
+
+        public override IRandom Copy()
+        {
+            SystemRandom copy = new(InternalState);
+
+            for (int i = 0; i < SeedArray.Length; ++i)
+            {
+                copy.SeedArray[i] = SeedArray[i];
+            }
+
+            return copy;
+        }
+    }
+}

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

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

package/Runtime/Core/Random/ThreadLocalRandom.cs

@@ -0,0 +1,11 @@
+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/ThreadLocalRandom.cs.meta

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

package/Runtime/Core/Random/UnityRandom.cs

@@ -0,0 +1,24 @@
+namespace UnityHelpers.Core.Random
+{
+    using System;
+
+    public sealed class UnityRandom : AbstractRandom
+    {
+        public static readonly UnityRandom Instance = new UnityRandom();
+
+        private UnityRandom()
+        {
+        }
+
+        public override RandomState InternalState => throw new NotSupportedException("Unity Random does not expose its internal state");
+        public override uint NextUint()
+        {
+            return unchecked((uint)UnityEngine.Random.Range(int.MinValue, int.MaxValue));
+        }
+
+        public override IRandom Copy()
+        {
+            throw new NotSupportedException("Unity Random does not support copying / seeding");
+        }
+    }
+}

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

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