Renamed NoiseRng. PoissonDiskSampling now using Noise rng.

Author: Cory Leach

Runtime/Utility/PoissonDiskSampling.cs

@@ -4,13 +4,13 @@
 
 namespace Gameframe.Procgen
 {
-  
+
   public static class PoissonDiskSampling
   {
     public static List<Vector2> GeneratePoints(float radius, Vector2 size, int seed, int maxSamplesPerPoint = 30,
       Func<Vector2, bool> validate = null)
     {
-      var rng = new System.Random(seed);
+      var rng = new RandomGeneratorStruct((uint)seed);
       var points = new List<Vector2>();
       var cellSize = radius / Mathf.Sqrt(2);
       var gridWidth = Mathf.CeilToInt(size.x / cellSize);
@@ -24,17 +24,17 @@ public static List<Vector2> GeneratePoints(float radius, Vector2 size, int seed,
       while (spawnPoints.Count > 0)
       {
         //Get a random spawn point from the list
-        var spawnIndex = rng.Next(0, spawnPoints.Count);
+        var spawnIndex = rng.NextIntRange(0, spawnPoints.Count-1);
         var spawnCenter = spawnPoints[spawnIndex];
         var accepted = false;
 
         for (int i = 0; i < maxSamplesPerPoint; i++)
         {
           //Get a random direction vector
-          var angle = (float) (rng.NextDouble() * Mathf.PI * 2);
+          var angle = (float) (rng.NextFloatZeroToOne() * Mathf.PI * 2);
           var dir = new Vector2(Mathf.Sin(angle), Mathf.Cos(angle));
           //Get point along that direction vector between radius and 2radius distance away
-          var distance = (float) (radius + rng.NextDouble() * radius * 2);
+          var distance = (float) (radius + rng.NextFloatZeroToOne() * radius * 2);
           var candidate = spawnCenter + dir * distance;
 
           //If point is valid we can accept it stop sampling
@@ -60,14 +60,14 @@ public static List<Vector2> GeneratePoints(float radius, Vector2 size, int seed,
       return points;
     }
 
-    public static List<Vector2Int> GenerateIntPoints(float radius, Vector2Int size, int seed,
-      int maxSamplesPerPoint = 30, Func<Vector2Int, bool> validate = null)
+    public static List<Vector2Int> GenerateIntPoints(float radius, Vector2Int size, int seed, int maxSamplesPerPoint = 30, Func<Vector2Int, bool> validate = null)
     {
-      var rng = new System.Random(seed);
+      var rng = new RandomGeneratorStruct((uint)seed);
       var points = new List<Vector2Int>();
       var cellSize = radius / Mathf.Sqrt(2);
       var gridWidth = Mathf.CeilToInt(size.x / cellSize);
       var gridHeight = Mathf.CeilToInt(size.y / cellSize);
+
       //Grid values equal to zero mean there is no point in that grid cell
       var grid = new int[gridWidth, gridHeight];
       var spawnPoints = new List<Vector2Int>();
@@ -77,17 +77,17 @@ public static List<Vector2Int> GenerateIntPoints(float radius, Vector2Int size,
       while (spawnPoints.Count > 0)
       {
         //Get a random spawn point from the list
-        var spawnIndex = rng.Next(0, spawnPoints.Count);
+        var spawnIndex = rng.NextIntRange(0, spawnPoints.Count - 1);
         var spawnCenter = spawnPoints[spawnIndex];
         var accepted = false;
 
         for (int i = 0; i < maxSamplesPerPoint; i++)
         {
           //Get a random direction vector
-          var angle = (float) (rng.NextDouble() * Mathf.PI * 2);
+          var angle = (float) (rng.NextFloatZeroToOne() * Mathf.PI * 2);
           var dir = new Vector2(Mathf.Sin(angle), Mathf.Cos(angle));
           //Get point along that direction vector between radius and 2radius distance away
-          var distance = (float) (radius + rng.NextDouble() * radius * 2);
+          var distance = (float) (radius + rng.NextFloatZeroToOne() * radius * 2);
           var pt = spawnCenter + dir * distance;
           var candidate = new Vector2Int((int) pt.x, (int) pt.y);
 
@@ -200,4 +200,4 @@ private static bool IsValid(Vector2 pt, Vector2 sampleRegionSize, float cellSize
 
   }
 
-}
+}

Runtime/Utility/NoiseRng.cs Runtime/Utility/RandomGenerator.csRuntime/Utility/NoiseRng.cs renamed to Runtime/Utility/RandomGenerator.cs

@@ -4,11 +4,11 @@
 namespace Gameframe.Procgen
 {
     /// <summary>
-    /// Noise based random number generator
+    /// Noise based random number generator (Struct version)
     /// Allows for fast random-access within a sequence of generated numbers
     /// Based on GDC 2017 talk and code by Squirrel Eiserloh
     /// </summary>
-    public class NoiseRng : IRandomAccessRandomNumberGenerator
+    public struct RandomGeneratorStruct : IRandomAccessRandomNumberGenerator
     {
         private uint seed;
         private int position;
@@ -17,21 +17,12 @@ public class NoiseRng : IRandomAccessRandomNumberGenerator
         /// Initialize random number generator with a given seed
         /// </summary>
         /// <param name="seed">see for the random number generator</param>
-        public NoiseRng(uint seed)
+        public RandomGeneratorStruct(uint seed)
         {
             this.seed = seed;
             position = 0;
         }
 
-        /// <summary>
-        /// Seeds using DateTime.UtcNow.Ticks
-        /// </summary>
-        public NoiseRng()
-        {
-            this.seed = (uint)DateTime.UtcNow.Ticks;
-            position = 0;
-        }
-
         /// <summary>
         /// Current position in the number generator sequence
         /// </summary>
@@ -194,4 +185,134 @@ public Vector3 NextDirection3D()
         #endregion
 
     }
+
+    /// <summary>
+    /// Noise based random number generator
+    /// Allows for fast random-access within a sequence of generated numbers
+    /// Based on GDC 2017 talk and code by Squirrel Eiserloh
+    /// </summary>
+    public class RandomGenerator : IRandomAccessRandomNumberGenerator
+    {
+        private RandomGeneratorStruct _randomGeneratorStruct;
+
+        /// <summary>
+        /// Initialize random number generator with a given seed
+        /// </summary>
+        /// <param name="seed">see for the random number generator</param>
+        public RandomGenerator(uint seed)
+        {
+            _randomGeneratorStruct = new RandomGeneratorStruct(seed);
+        }
+
+        /// <summary>
+        /// Seeds using DateTime.UtcNow.Ticks
+        /// </summary>
+        public RandomGenerator()
+        {
+            _randomGeneratorStruct = new RandomGeneratorStruct((uint)DateTime.UtcNow.Ticks);
+        }
+
+        /// <summary>
+        /// Current position in the number generator sequence
+        /// </summary>
+        public int Position
+        {
+            get => _randomGeneratorStruct.Position;
+            set => _randomGeneratorStruct.Position = value;
+        }
+
+        /// <summary>
+        /// Current Seed
+        /// </summary>
+        public uint Seed => _randomGeneratorStruct.Seed;
+
+        /// <summary>
+        /// Reseed the number generator with a new seed and position
+        /// </summary>
+        /// <param name="seed">seed</param>
+        /// <param name="position">position in number generation sequence</param>
+        public void ReSeed(uint seed, int position = 0) => _randomGeneratorStruct.ReSeed(seed, position);
+
+        #region Rand Methods
+
+        /// <summary>
+        /// Next random unsigned integer
+        /// </summary>
+        /// <returns>next random unsigned integer in the current sequence</returns>
+        public uint NextUint() => _randomGeneratorStruct.NextUint();
+
+        /// <summary>
+        /// Next random unsigned short
+        /// </summary>
+        /// <returns>next random unsigned short in the current sequence</returns>
+        public ushort NextUshort() => _randomGeneratorStruct.NextUshort();
+
+        /// <summary>
+        /// Next random byte
+        /// </summary>
+        /// <returns>next random byte in the current sequence</returns>
+        public byte NextByte() => _randomGeneratorStruct.NextByte();
+
+        /// <summary>
+        /// Next random integer
+        /// </summary>
+        /// <returns>next random integer in the current sequence</returns>
+        public int NextInt() => _randomGeneratorStruct.NextInt();
+
+        /// <summary>
+        /// Next random short
+        /// </summary>
+        /// <returns>next random short in the current sequence</returns>
+        public short NextShort() => _randomGeneratorStruct.NextShort();
+
+        /// <summary>
+        /// Next random float in the range 0 to 1
+        /// </summary>
+        /// <returns>Next random float in the range 0 to 1 (inclusive, inclusive)</returns>
+        public float NextFloatZeroToOne() => _randomGeneratorStruct.NextFloatZeroToOne();
+
+        /// <summary>
+        /// Next random float in the range -1 to 1
+        /// </summary>
+        /// <returns>Next random float in the range -1 to 1 (inclusive, inclusive)</returns>
+        public float NextFloatNegOneToOne() => _randomGeneratorStruct.NextFloatNegOneToOne();
+
+        /// <summary>
+        /// Next random float in the range min to max
+        /// </summary>
+        /// <param name="min">min return value</param>
+        /// <param name="max">max return value</param>
+        /// <returns>Next random float in the range min to max (inclusive, inclusive)</returns>
+        public float NextFloatRange(float min, float max) => _randomGeneratorStruct.NextFloatRange(min,max);
+
+        /// <summary>
+        /// Next random integer in the range min to max
+        /// </summary>
+        /// <param name="min">min return value</param>
+        /// <param name="max">max return value</param>
+        /// <returns>Next random int in the range min to max (inclusive, inclusive)</returns>
+        public int NextIntRange(int min, int max) => _randomGeneratorStruct.NextIntRange(min,max);
+
+        /// <summary>
+        /// Rolls for a true for false with the given probability
+        /// </summary>
+        /// <param name="probabilityOfReturningTrue">probably that this function will return true</param>
+        /// <returns>true or false</returns>
+        public bool RollChance(float probabilityOfReturningTrue) =>
+            _randomGeneratorStruct.RollChance(probabilityOfReturningTrue);
+
+        /// <summary>
+        /// Next uniformly distributed randomized 2d direction
+        /// </summary>
+        /// <returns>Random Normalized Vector2</returns>
+        public Vector2 NextDirection2D() => _randomGeneratorStruct.NextDirection2D();
+
+        /// <summary>
+        /// Next uniformly distributed randomized 3d direction
+        /// </summary>
+        /// <returns>Random Normalized Vector3</returns>
+        public Vector3 NextDirection3D() => _randomGeneratorStruct.NextDirection3D();
+
+        #endregion
+    }
 }

Runtime/Utility/NoiseRng.cs.meta Runtime/Utility/RandomGenerator.cs.metaRuntime/Utility/NoiseRng.cs.meta renamed to Runtime/Utility/RandomGenerator.cs.meta

@@ -19,7 +19,7 @@ public class RandomDirectionVisualizer : MonoBehaviour
         public Color sphereColor = Color.white;
         public Color pointColor = Color.white;
 
-        private NoiseRng rand;
+        private RandomGenerator rand;
 
         public enum DirectionDimensions
         {
@@ -31,7 +31,7 @@ private void OnDrawGizmos()
         {
             if (rand == null)
             {
-                rand = new NoiseRng(seed);
+                rand = new RandomGenerator(seed);
             }
 
             rand.ReSeed(seed, 0);

Runtime/Visualizers/RandomDirectionVisualizer.cs

@@ -7,13 +7,13 @@ public class PoissonMapLayerGenerator : WorldMapLayerGenerator
   {
     [SerializeField]
     private float radius = 10;
-    
+
     [SerializeField]
     private int maxSamplesPerPoint = 30;
-    
+
     [SerializeField]
     private bool useRegions = true;
-    
+
     [SerializeField]
     private int edgeAvoidance;
 
@@ -81,13 +81,12 @@ private void AddToWorldUsingRegions(WorldMapData mapData)
 
     private void AddToWorldDefault(WorldMapData mapData)
     {
-      var points = PoissonDiskSampling.GenerateIntPoints(radius, new Vector2Int(mapData.width, mapData.height),
-        mapData.seed, maxSamplesPerPoint);
+      var points = PoissonDiskSampling.GenerateIntPoints(radius, new Vector2Int(mapData.width, mapData.height), mapData.seed, maxSamplesPerPoint);
       var layer = new PoissonMapLayerData
       {
         points = points
       };
       mapData.layers.Add(layer);
     }
   }
-}
+}

Runtime/WorldMap/Layers/PoissonMapLayerGenerator.cs

@@ -9,7 +9,7 @@ public class RuntimeTests
         [Test]
         public void NoiseRNG_IntRange()
         {
-            var noiseRng = new NoiseRng((uint)DateTime.UtcNow.Ticks);
+            var noiseRng = new RandomGenerator((uint)DateTime.UtcNow.Ticks);
 
             const int maxRange = 2;
             var totals = new int[maxRange+1];
@@ -35,7 +35,7 @@ public void NoiseRNG_IntRange()
         [Test]
         public void NoiseRNG_RollChance_33percent()
         {
-            var noiseRng = new NoiseRng((uint)DateTime.UtcNow.Ticks);
+            var noiseRng = new RandomGenerator((uint)DateTime.UtcNow.Ticks);
 
             const float probability = 0.33f;
             var totals = new int[2];