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

package/Runtime/Core/Random/PerlinNoise.cs

@@ -0,0 +1,369 @@
+namespace UnityHelpers.Core.Random
+{
+    using System;
+    using Extension;
+    using UnityEngine;
+
+    public sealed class PerlinNoise
+    {
+        // Permutation array. This is a standard permutation of numbers from 0 to 255.
+        private static readonly int[] DefaultPermutations =
+        {
+            151,
+            160,
+            137,
+            91,
+            90,
+            15,
+            131,
+            13,
+            201,
+            95,
+            96,
+            53,
+            194,
+            233,
+            7,
+            225,
+            140,
+            36,
+            103,
+            30,
+            69,
+            142,
+            8,
+            99,
+            37,
+            240,
+            21,
+            10,
+            23,
+            190,
+            6,
+            148,
+            247,
+            120,
+            234,
+            75,
+            0,
+            26,
+            197,
+            62,
+            94,
+            252,
+            219,
+            203,
+            117,
+            35,
+            11,
+            32,
+            57,
+            177,
+            33,
+            88,
+            237,
+            149,
+            56,
+            87,
+            174,
+            20,
+            125,
+            136,
+            171,
+            168,
+            68,
+            175,
+            74,
+            165,
+            71,
+            134,
+            139,
+            48,
+            27,
+            166,
+            77,
+            146,
+            158,
+            231,
+            83,
+            111,
+            229,
+            122,
+            60,
+            211,
+            133,
+            230,
+            220,
+            105,
+            92,
+            41,
+            55,
+            46,
+            245,
+            40,
+            244,
+            102,
+            143,
+            54,
+            65,
+            25,
+            63,
+            161,
+            1,
+            216,
+            80,
+            73,
+            209,
+            76,
+            132,
+            187,
+            208,
+            89,
+            18,
+            169,
+            200,
+            196,
+            135,
+            130,
+            116,
+            188,
+            159,
+            86,
+            164,
+            100,
+            109,
+            198,
+            173,
+            186,
+            3,
+            64,
+            52,
+            217,
+            226,
+            250,
+            124,
+            123,
+            5,
+            202,
+            38,
+            147,
+            118,
+            126,
+            255,
+            82,
+            85,
+            212,
+            207,
+            206,
+            59,
+            227,
+            47,
+            16,
+            58,
+            17,
+            182,
+            189,
+            28,
+            42,
+            223,
+            183,
+            170,
+            213,
+            119,
+            248,
+            152,
+            2,
+            44,
+            154,
+            163,
+            70,
+            221,
+            153,
+            101,
+            155,
+            167,
+            43,
+            172,
+            9,
+            129,
+            22,
+            39,
+            253,
+            19,
+            98,
+            108,
+            110,
+            79,
+            113,
+            224,
+            232,
+            178,
+            185,
+            112,
+            104,
+            218,
+            246,
+            97,
+            228,
+            251,
+            34,
+            242,
+            193,
+            238,
+            210,
+            144,
+            12,
+            191,
+            179,
+            162,
+            241,
+            81,
+            51,
+            145,
+            235,
+            249,
+            14,
+            239,
+            107,
+            49,
+            192,
+            214,
+            31,
+            181,
+            199,
+            106,
+            157,
+            184,
+            84,
+            204,
+            176,
+            115,
+            121,
+            50,
+            45,
+            127,
+            4,
+            150,
+            254,
+            138,
+            236,
+            205,
+            93,
+            222,
+            114,
+            67,
+            29,
+            24,
+            72,
+            243,
+            141,
+            128,
+            195,
+            78,
+            66,
+            215,
+            61,
+            156,
+            180,
+        };
+
+        public static readonly PerlinNoise Instance = new();
+
+        private readonly int[] _permutations = new int[DefaultPermutations.Length];
+
+        // Doubled permutation to avoid overflow
+        private readonly int[] _doubledPermutations = new int[DefaultPermutations.Length * 2];
+
+        public PerlinNoise()
+            : this(null) { }
+
+        // Static constructor to initialize the doubled permutation array
+        public PerlinNoise(IRandom random)
+        {
+            Array.Copy(DefaultPermutations, 0, _permutations, 0, DefaultPermutations.Length);
+            if (random != null)
+            {
+                _permutations.Shuffle(random);
+            }
+            for (int i = 0; i < _doubledPermutations.Length; ++i)
+            {
+                _doubledPermutations[i] = _permutations[i % _permutations.Length];
+            }
+        }
+
+        // Fade function as defined by Ken Perlin. This eases coordinate values
+        // so that they will "ease" towards integral values. This ends up smoothing the final output.
+        public static float Fade(float t)
+        {
+            return t * t * t * (t * (t * 6 - 15) + 10);
+        }
+
+        // Linear interpolation function
+        public static float Lerp(float t, float a, float b)
+        {
+            return a + t * (b - a);
+        }
+
+        // Gradient function calculates the dot product between a pseudorandom gradient vector and the vector from the input coordinate to the grid coordinate
+        public static float Grad(int hash, float x, float y)
+        {
+            int h = hash & 7; // Convert low 3 bits of hash code
+            float u = h < 4 ? x : y; // If h < 4, use x, else use y
+            float v = h < 4 ? y : x; // If h < 4, use y, else use x
+            return ((h & 1) == 0 ? u : -u) + ((h & 2) == 0 ? v : -v);
+        }
+
+        // The Perlin noise function
+        public float Noise(float x, float y)
+        {
+            // Find unit grid cell containing point
+            int clampedX = (int)Mathf.Floor(x) & 255;
+            int clampedY = (int)Mathf.Floor(y) & 255;
+
+            // Get relative xy coordinates inside the cell
+            x -= Mathf.Floor(x);
+            y -= Mathf.Floor(y);
+
+            // Compute fade curves for x and y
+            float u = Fade(x);
+            float v = Fade(y);
+
+            // Hash coordinates of the square's corners
+            int aa = _doubledPermutations[_doubledPermutations[clampedX] + clampedY];
+            int ab = _doubledPermutations[_doubledPermutations[clampedX] + clampedY + 1];
+            int ba = _doubledPermutations[_doubledPermutations[clampedX + 1] + clampedY];
+            int bb = _doubledPermutations[_doubledPermutations[clampedX + 1] + clampedY + 1];
+
+            // Add blended results from the corners
+            float res = Lerp(
+                v,
+                Lerp(u, Grad(aa, x, y), Grad(ba, x - 1, y)),
+                Lerp(u, Grad(ab, x, y - 1), Grad(bb, x - 1, y - 1))
+            );
+
+            // Optional: Scale result to [0,1]
+            return (res + 1.0f) / 2.0f;
+        }
+
+        // Optional: Generate noise with multiple octaves for more complexity
+        public float OctaveNoise(float x, float y, int octaves, float persistence)
+        {
+            float total = 0;
+            float frequency = 1;
+            float amplitude = 1;
+            float maxValue = 0; // Used for normalizing result to [0,1]
+
+            for (int i = 0; i < octaves; ++i)
+            {
+                total += Noise(x * frequency, y * frequency) * amplitude;
+
+                maxValue += amplitude;
+
+                amplitude *= persistence;
+                frequency *= 2;
+            }
+
+            return total / maxValue;
+        }
+    }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 9798fa1ddadd48958dacd90cfa254962
+timeCreated: 1732743633

package/Runtime/Core/Random/SquirrelRandom.cs

@@ -37,7 +37,7 @@
 
         public override uint NextUint()
         {
-            return _position = NextUintInternal(_position);
+            return NextUintInternal(ref _position);
         }
 
         // Does not advance the RNG
@@ -51,16 +51,15 @@
             return new SquirrelRandom(InternalState);
         }
 
-        private static uint NextUintInternal(uint seed)
+        private static uint NextUintInternal(ref uint seed)
         {
-            uint result = seed;
-            result *= BitNoise1;
-            result ^= (result >> 8);
-            result += BitNoise2;
-            result ^= (result << 8);
-            result *= BitNoise3;
-            result ^= (result >> 8);
-            return result;
+            seed *= BitNoise1;
+            seed ^= (seed >> 8);
+            seed += BitNoise2;
+            seed ^= (seed << 8);
+            seed *= BitNoise3;
+            seed ^= (seed >> 8);
+            return seed;
         }
 
         // https://youtu.be/LWFzPP8ZbdU?t=2906

package/Runtime/Core/Random/SystemRandom.cs

@@ -12,14 +12,18 @@
     [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),
+                unchecked((ulong)_inext),
+                unchecked((ulong)_inextp),
                 _cachedGaussian,
-                ArrayConverter.IntArrayToByteArrayBlockCopy(SeedArray)
+                ArrayConverter.IntArrayToByteArrayBlockCopy(_seedArray)
             );
 
         /*
@@ -27,9 +31,9 @@
             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];
+        private int _inext;
+        private int _inextp;
+        private readonly int[] _seedArray = new int[SeedArraySize];
 
         public SystemRandom()
             : this(Guid.NewGuid().GetHashCode()) { }
@@ -37,28 +41,34 @@
         public SystemRandom(int seed)
         {
             int num1 = 161803398 - (seed == int.MinValue ? int.MaxValue : Math.Abs(seed));
-            this.SeedArray[55] = num1;
+            _seedArray[LastSeedIndex] = num1;
             int num2 = 1;
-            for (int index1 = 1; index1 < 55; ++index1)
+            for (int index1 = 1; index1 < LastSeedIndex; ++index1)
             {
-                int index2 = 21 * index1 % 55;
-                this.SeedArray[index2] = num2;
+                int index2 = 21 * index1 % LastSeedIndex;
+                _seedArray[index2] = num2;
                 num2 = num1 - num2;
                 if (num2 < 0)
+                {
                     num2 += int.MaxValue;
-                num1 = this.SeedArray[index2];
+                }
+
+                num1 = _seedArray[index2];
             }
             for (int index3 = 1; index3 < 5; ++index3)
             {
-                for (int index4 = 1; index4 < 56; ++index4)
+                for (int index4 = 1; index4 < SeedArraySize; ++index4)
                 {
-                    this.SeedArray[index4] -= this.SeedArray[1 + (index4 + 30) % 55];
-                    if (this.SeedArray[index4] < 0)
-                        this.SeedArray[index4] += int.MaxValue;
+                    int value = _seedArray[index4] -= _seedArray[1 + (index4 + 30) % LastSeedIndex];
+                    if (value < 0)
+                    {
+                        _seedArray[index4] += int.MaxValue;
+                    }
                 }
             }
-            this.inext = 0;
-            this.inextp = 21;
+
+            _inext = 0;
+            _inextp = 21;
         }
 
         [JsonConstructor]
@@ -66,59 +76,86 @@
         {
             unchecked
             {
-                inext = (int)internalState.State1;
-                inextp = (int)internalState.State2;
+                _inext = (int)internalState.State1;
+                _inextp = (int)internalState.State2;
             }
             _cachedGaussian = internalState.Gaussian;
-            SeedArray = ArrayConverter.ByteArrayToIntArrayBlockCopy(internalState.Payload);
+            _seedArray = ArrayConverter.ByteArrayToIntArrayBlockCopy(internalState.Payload);
         }
 
-        public override uint NextUint()
+        public override int Next()
         {
-            int inext = this.inext;
-            int inextp = this.inextp;
+            int localINext = _inext;
+            int localINextP = _inextp;
             int index1;
-            if ((index1 = inext + 1) >= 56)
+            if ((index1 = localINext + 1) >= SeedArraySize)
+            {
                 index1 = 1;
+            }
+
             int index2;
-            if ((index2 = inextp + 1) >= 56)
+            if ((index2 = localINextP + 1) >= SeedArraySize)
+            {
                 index2 = 1;
-            int num = this.SeedArray[index1] - this.SeedArray[index2];
+            }
+
+            int num = _seedArray[index1] - _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);
+            }
+
+            _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 generated;
+            double random;
             do
             {
-                generated = unchecked((int)NextUint()) * 4.6566128752458E-10;
-            } while (generated < 0 || 1 <= generated);
+                random = Next() / (1.0 * int.MaxValue);
+            } while (1.0 <= random);
 
-            return generated;
+            return random;
         }
 
         public override float NextFloat()
         {
-            return (float)NextDouble();
+            float random;
+            do
+            {
+                random = Next() * (1f / int.MaxValue);
+            } while (1f <= random);
+
+            return random;
         }
 
         public override IRandom Copy()
         {
             SystemRandom copy = new(InternalState);
-
-            for (int i = 0; i < SeedArray.Length; ++i)
-            {
-                copy.SeedArray[i] = SeedArray[i];
-            }
-
+            Array.Copy(_seedArray, copy._seedArray, _seedArray.Length);
             return copy;
         }
     }

package/Tests/Runtime/Extensions/RandomExtensionTests.cs

@@ -0,0 +1,27 @@
+namespace UnityHelpers.Tests.Extensions
+{
+    using System.Collections.Generic;
+    using Core.Extension;
+    using Core.Random;
+    using NUnit.Framework;
+    using UnityEngine;
+
+    public sealed class RandomExtensionTests
+    {
+        [Test]
+        public void NextVector2InRange()
+        {
+            HashSet<float> seenAngles = new();
+            for (int i = 0; i < 1_000; ++i)
+            {
+                Vector2 vector = PRNG.Instance.NextVector2(-100, 100);
+                float range = PRNG.Instance.NextFloat(100f);
+                Vector2 inRange = PRNG.Instance.NextVector2InRange(range, vector);
+                Assert.LessOrEqual(Vector2.Distance(vector, inRange), range);
+                seenAngles.Add(Vector2.SignedAngle(vector, inRange));
+            }
+
+            Assert.LessOrEqual(3, seenAngles.Count);
+        }
+    }
+}

package/Tests/Runtime/Extensions/RandomExtensionTests.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 610d56fdeadc4caf9d50c75574db4204
+timeCreated: 1732732306