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

package/Tests/Runtime/DataStructures/SpatialTreeTests.cs

@@ -8,9 +8,10 @@
     using NUnit.Framework;
     using Vector2 = UnityEngine.Vector2;
 
-    public abstract class SpatialTreeTests<TTree> where TTree : ISpatialTree<Vector2>
+    public abstract class SpatialTreeTests<TTree>
+        where TTree : ISpatialTree<Vector2>
     {
-        private IRandom Random => PcgRandom.Instance;
+        private IRandom Random => PRNG.Instance;
 
         protected abstract TTree CreateTree(IEnumerable<Vector2> points);
 
@@ -28,14 +29,18 @@
                 do
                 {
                     point = Helpers.GetRandomPointInCircle(center, radius);
-                }
-                while (!points.Add(point));
+                } while (!points.Add(point));
             }
 
             TTree quadTree = CreateTree(points);
 
             List<Vector2> pointsInRange = quadTree.GetElementsInRange(center, radius).ToList();
-            Assert.IsTrue(points.SetEquals(pointsInRange), "Found {0} points in range, expected {1}.", pointsInRange.Count, points.Count);
+            Assert.IsTrue(
+                points.SetEquals(pointsInRange),
+                "Found {0} points in range, expected {1}.",
+                pointsInRange.Count,
+                points.Count
+            );
             // Translate by a unit-square - there should be no points in this range
             Vector2 offset = center;
             offset.x -= radius * 2;
@@ -43,8 +48,14 @@
 
             pointsInRange = quadTree.GetElementsInRange(offset, radius).ToList();
             Assert.AreEqual(
-                0, pointsInRange.Count, "Found {0} points within {1} range of {2} (original center {3})",
-                pointsInRange.Count, radius, offset, center);
+                0,
+                pointsInRange.Count,
+                "Found {0} points within {1} range of {2} (original center {3})",
+                pointsInRange.Count,
+                radius,
+                offset,
+                center
+            );
         }
 
         [Test]
@@ -58,10 +69,19 @@
             List<Vector2> points = new(1) { testPoint };
 
             TTree quadTree = CreateTree(points);
-            List<Vector2> pointsInRange = quadTree.GetElementsInRange(point, range * 0.99f).ToList();
+            List<Vector2> pointsInRange = quadTree
+                .GetElementsInRange(point, range * 0.99f)
+                .ToList();
             Assert.AreEqual(0, pointsInRange.Count);
             pointsInRange = quadTree.GetElementsInRange(point, range * 1.01f).ToList();
-            Assert.AreEqual(1, pointsInRange.Count, "Failed to find point {0} from test point {1} with {2:0.00} range.", point, testPoint, range);
+            Assert.AreEqual(
+                1,
+                pointsInRange.Count,
+                "Failed to find point {0} from test point {1} with {2:0.00} range.",
+                point,
+                testPoint,
+                range
+            );
             Assert.AreEqual(testPoint, pointsInRange[0]);
         }
 
@@ -95,7 +115,11 @@
             nearestNeighborCount = 16;
             quadTree.GetApproximateNearestNeighbors(center, nearestNeighborCount, nearestNeighbors);
             Assert.AreEqual(nearestNeighborCount, nearestNeighbors.Count);
-            Assert.IsTrue(nearestNeighbors.All(neighbor => (neighbor - center).magnitude <= 5.6f), "Max: {0}", nearestNeighbors.Select(neighbor => (neighbor - center).magnitude).Max());
+            Assert.IsTrue(
+                nearestNeighbors.All(neighbor => (neighbor - center).magnitude <= 5.6f),
+                "Max: {0}",
+                nearestNeighbors.Select(neighbor => (neighbor - center).magnitude).Max()
+            );
 
             center = new Vector2(-100, -100);
 

package/Tests/Runtime/Helper/ArrayConverterTests.cs

@@ -0,0 +1,19 @@
+namespace UnityHelpers.Tests.Tests.Runtime.Helper
+{
+    using System.Linq;
+    using Core.Helper;
+    using Core.Random;
+    using NUnit.Framework;
+
+    public sealed class ArrayConverterTests
+    {
+        [Test]
+        public void IntToByteArray()
+        {
+            int[] ints = Enumerable.Range(0, 1000).Select(_ => PRNG.Instance.Next()).ToArray();
+            byte[] bytes = ArrayConverter.IntArrayToByteArrayBlockCopy(ints);
+            int[] decoded = ArrayConverter.ByteArrayToIntArrayBlockCopy(bytes);
+            Assert.IsTrue(ints.SequenceEqual(decoded));
+        }
+    }
+}

package/Tests/Runtime/Helper/ArrayConverterTests.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 35d3b0e1ba0e43bbb9d899a44b36812a
+timeCreated: 1732492102

package/Tests/Runtime/Helper/WallMathTests.cs

@@ -0,0 +1,221 @@
+namespace UnityHelpers.Tests.Tests.Runtime.Helper
+{
+    using Core.Extension;
+    using Core.Helper;
+    using Core.Random;
+    using NUnit.Framework;
+    using UnityEngine;
+
+    public sealed class WallMathTests
+    {
+        private const int TestIterations = 10_000;
+
+        [Test]
+        public void ApproximatelyRandom()
+        {
+            for (int i = 0; i < TestIterations; ++i)
+            {
+                float target = PRNG.Instance.NextFloat(-1_000, 1_000);
+                float delta = PRNG.Instance.NextFloat(0f, 10f);
+
+                float insideOffset = delta * PRNG.Instance.NextFloat();
+                if (PRNG.Instance.NextBool())
+                {
+                    insideOffset *= -1;
+                }
+
+                float inside = target + insideOffset;
+                Assert.IsTrue(
+                    target.Approximately(inside, delta),
+                    $"Target {target} is not close enough to {inside} with a delta of {delta}."
+                );
+
+                float outsideOffset = delta * PRNG.Instance.NextFloat(1.001f, 10f);
+                if (PRNG.Instance.NextBool())
+                {
+                    outsideOffset *= -1;
+                }
+
+                float outside = target + outsideOffset;
+                Assert.IsFalse(
+                    target.Approximately(outside, delta),
+                    $"Target {target} was unexpectedly close to {outside} with a delta of {delta}."
+                );
+            }
+        }
+
+        [Test]
+        public void ApproximatelyExpected()
+        {
+            Assert.IsTrue(0f.Approximately(0f, 0f));
+            Assert.IsTrue(0f.Approximately(0.5f, 1f));
+            Assert.IsFalse(0.001f.Approximately(0f, 0f));
+            Assert.IsFalse(100f.Approximately(5f, 2.4f));
+
+            Assert.IsTrue(0.001f.Approximately(0.0001f));
+        }
+
+        [Test]
+        public void ClampRectInsideRandom()
+        {
+            for (int i = 0; i < TestIterations; ++i)
+            {
+                Vector2 position = PRNG.Instance.NextVector2InRange(10f);
+
+                Vector2 size;
+                do
+                {
+                    size = PRNG.Instance.NextVector2InRange(10f);
+                } while (size.x < 0 || size.y < 0);
+
+                Rect rect = new(position, size);
+
+                Vector2 inside = new(
+                    PRNG.Instance.NextFloat(rect.min.x, rect.max.x),
+                    PRNG.Instance.NextFloat(rect.min.y, rect.max.y)
+                );
+                Assert.IsTrue(rect.Contains(inside), $"Rect {rect} does not contain {inside}.");
+                Vector2 clamped = rect.Clamp(inside);
+                Assert.AreEqual(inside, clamped);
+            }
+        }
+
+        [Test]
+        public void ClampRectInsideExpected()
+        {
+            Rect rect = new Rect(Vector2.one, Vector2.one);
+            Vector2 clamped = rect.Clamp(rect.center);
+            Assert.AreEqual(rect.center, clamped);
+
+            Vector2 inside =
+                rect.center
+                + new Vector2(PRNG.Instance.NextFloat(0.1f), PRNG.Instance.NextFloat(0.1f));
+            clamped = rect.Clamp(inside);
+            Assert.AreEqual(
+                inside,
+                clamped,
+                $"Expected inside point {inside} unexpectedly was clamped to {clamped} for rect {rect}."
+            );
+        }
+
+        [Test]
+        public void ClampRectOutsideRandom()
+        {
+            Rect rect = new(Vector2.one, Vector2.one);
+            for (int i = 0; i < TestIterations; ++i)
+            {
+                Vector2 outside;
+                do
+                {
+                    outside = PRNG.Instance.NextVector2InRange(10f, rect.center);
+                } while (rect.Contains(outside));
+
+                Vector2 originalOutside = outside;
+                Vector2 clamped = rect.Clamp(ref outside);
+                Debug.Log($"Clamped {originalOutside} to {clamped}.");
+                Assert.AreNotEqual(originalOutside, clamped);
+                Assert.AreEqual(clamped, outside);
+
+                // Shrink just a little to ensure within bounds, clamping will put it right on the edge
+                const float shrinkScaleToAccountForPrecision = 0.99f;
+                Vector2 delta = rect.center - clamped;
+                delta *= shrinkScaleToAccountForPrecision;
+                clamped = rect.center + delta;
+                Assert.IsTrue(
+                    rect.Contains(clamped),
+                    $"Expected rect {rect} to contain {clamped}, but it did not."
+                );
+            }
+        }
+
+        [Test]
+        public void ClampRectOutsideExpected()
+        {
+            Rect rect = new(Vector2.one, Vector2.one);
+            Vector2 outside = new(rect.center.x, 100f);
+            Vector2 clamped = rect.Clamp(ref outside);
+            Assert.AreEqual(clamped, outside);
+            Assert.AreEqual(new Vector2(rect.center.x, 2f), clamped);
+
+            // Shrink just a little to ensure within bounds, clamping will put it right on the edge
+            const float shrinkScaleToAccountForPrecision = 0.99f;
+            Vector2 delta = rect.center - clamped;
+            delta *= shrinkScaleToAccountForPrecision;
+            clamped = rect.center + delta;
+            Assert.IsTrue(
+                rect.Contains(clamped),
+                $"Expected rect to contain {clamped}, but it did not."
+            );
+        }
+
+        [Test]
+        public void ClampFloat()
+        {
+            float value = 1.25f;
+            float clamped = value.Clamp(0, 1);
+            Assert.AreEqual(1, clamped);
+            Assert.AreEqual(1.25f, value);
+
+            value = 0.5f;
+            clamped = value.Clamp(0, 1);
+            Assert.AreEqual(0.5f, clamped);
+            Assert.AreEqual(0.5f, value);
+        }
+
+        [Test]
+        public void WrappedIncrementWrapped()
+        {
+            int ten = 10;
+            int one = ten.WrappedIncrement(10);
+            Assert.AreEqual(1, one);
+            Assert.AreEqual(10, ten);
+
+            int toChangeToOne = 10;
+            int returned = WallMath.WrappedIncrement(ref toChangeToOne, 10);
+            Assert.AreEqual(1, returned);
+            Assert.AreEqual(1, toChangeToOne);
+        }
+
+        [Test]
+        public void WrappedIncrementUnwrapped()
+        {
+            int ten = 10;
+            int eleven = ten.WrappedIncrement(100);
+            Assert.AreEqual(11, eleven);
+            Assert.AreEqual(10, ten);
+
+            int toChangeToEleven = 10;
+            int returned = WallMath.WrappedIncrement(ref toChangeToEleven, 100);
+            Assert.AreEqual(11, returned);
+            Assert.AreEqual(11, toChangeToEleven);
+        }
+
+        [Test]
+        public void WrappedAddWrapped()
+        {
+            int ten = 10;
+            int two = ten.WrappedAdd(2, 10);
+            Assert.AreEqual(10, ten);
+            Assert.AreEqual(2, two);
+
+            int toChangeToTwo = 10;
+            int returned = WallMath.WrappedAdd(ref toChangeToTwo, 2, 10);
+            Assert.AreEqual(2, returned);
+            Assert.AreEqual(2, toChangeToTwo);
+        }
+
+        [Test]
+        public void WrappedAddUnwrapped()
+        {
+            int ten = 10;
+            int twelve = ten.WrappedAdd(2, 100);
+            Assert.AreEqual(10, ten);
+            Assert.AreEqual(12, twelve);
+
+            int toChangeToTwelve = 10;
+            int returned = WallMath.WrappedAdd(ref toChangeToTwelve, 2, 100);
+            Assert.AreEqual(12, returned);
+            Assert.AreEqual(12, toChangeToTwelve);
+        }
+    }
+}

package/Tests/Runtime/Helper/WallMathTests.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 11e0e2d4098d47159de89eff698b2510
+timeCreated: 1732563313

package/Tests/Runtime/Helper.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: d1cf06665d214b7aa507e42eb1fdfbe4
+timeCreated: 1732492095

package/Tests/Runtime/Performance/RandomPerformanceTests.cs

@@ -10,28 +10,34 @@
         [Test]
         public void Benchmark()
         {
-            TimeSpan timeout = TimeSpan.FromSeconds(1);
+            TimeSpan timeout = TimeSpan.FromSeconds(1.125);
 
             UnityEngine.Debug.Log($"| Random | Next | NextFloat | NextDouble |");
             UnityEngine.Debug.Log($"| ------ | ---- | --------- | ---------- |");
-            
+
             RunTest(new PcgRandom(), timeout);
             RunTest(new SystemRandom(), timeout);
             RunTest(new SquirrelRandom(), timeout);
             RunTest(new XorShiftRandom(), timeout);
+            RunTest(new DotNetRandom(), timeout);
+            RunTest(new WyRandom(), timeout);
         }
 
-        private void RunTest<T>(T random, TimeSpan timeout) where T : IRandom
+        private static void RunTest<T>(T random, TimeSpan timeout)
+            where T : IRandom
         {
             int nextInt = RunNext(timeout, random);
             int nextFloat = RunNextFloat(timeout, random);
             int nextDouble = RunNextDouble(timeout, random);
 
-            UnityEngine.Debug.Log($"| {random.GetType().Name} | {(nextInt / timeout.TotalSeconds):N0} | {(nextFloat / timeout.TotalSeconds):N0} | {(nextDouble / timeout.TotalSeconds):N0} |");
+            UnityEngine.Debug.Log(
+                $"| {random.GetType().Name} | {(nextInt / timeout.TotalSeconds):N0} | {(nextFloat / timeout.TotalSeconds):N0} | {(nextDouble / timeout.TotalSeconds):N0} |"
+            );
         }
 
         // Copy-pasta'd for maximum speed
-        private int RunNext<T>(TimeSpan timeout, T random) where T : IRandom
+        private static int RunNext<T>(TimeSpan timeout, T random)
+            where T : IRandom
         {
             int count = 0;
             Stopwatch timer = Stopwatch.StartNew();
@@ -39,13 +45,13 @@
             {
                 _ = random.Next();
                 ++count;
-            }
-            while (timer.Elapsed < timeout);
+            } while (timer.Elapsed < timeout);
 
             return count;
         }
 
-        private int RunNextFloat<T>(TimeSpan timeout, T random) where T : IRandom
+        private static int RunNextFloat<T>(TimeSpan timeout, T random)
+            where T : IRandom
         {
             int count = 0;
             Stopwatch timer = Stopwatch.StartNew();
@@ -53,13 +59,13 @@
             {
                 _ = random.NextFloat();
                 ++count;
-            }
-            while (timer.Elapsed < timeout);
+            } while (timer.Elapsed < timeout);
 
             return count;
         }
 
-        private int RunNextDouble<T>(TimeSpan timeout, T random) where T : IRandom
+        private static int RunNextDouble<T>(TimeSpan timeout, T random)
+            where T : IRandom
         {
             int count = 0;
             Stopwatch timer = Stopwatch.StartNew();
@@ -67,8 +73,7 @@
             {
                 _ = random.NextDouble();
                 ++count;
-            }
-            while (timer.Elapsed < timeout);
+            } while (timer.Elapsed < timeout);
 
             return count;
         }

package/Tests/Runtime/Performance/SpatialTreePerformanceTest.cs

@@ -1,17 +1,18 @@
 namespace UnityHelpers.Tests.Performance
 {
-    using NUnit.Framework;
-    using System.Collections.Generic;
-    using System.Diagnostics;
     using System;
     using System.Collections;
+    using System.Collections.Generic;
+    using System.Diagnostics;
     using System.Linq;
     using System.Threading.Tasks;
-    using UnityEngine;
     using Core.DataStructure;
+    using NUnit.Framework;
+    using UnityEngine;
     using UnityEngine.TestTools;
 
-    public abstract class SpatialTreePerformanceTest<TTree> where TTree : ISpatialTree<Vector2>
+    public abstract class SpatialTreePerformanceTest<TTree>
+        where TTree : ISpatialTree<Vector2>
     {
         protected abstract TTree CreateTree(IEnumerable<Vector2> points);
 
@@ -23,11 +24,15 @@
 
             Vector2[] points = new Vector2[1_000_000];
             float radius = 500;
-            ParallelLoopResult result = Parallel.For(0, 1_000_000, index =>
-            {
-                // ReSharper disable once PossibleLossOfFraction
-                points[index] = new Vector2(index % 1_000, index / 1_000);
-            });
+            ParallelLoopResult result = Parallel.For(
+                0,
+                1_000_000,
+                index =>
+                {
+                    // ReSharper disable once PossibleLossOfFraction
+                    points[index] = new Vector2(index % 1_000, index / 1_000);
+                }
+            );
 
             while (!result.IsCompleted)
             {
@@ -37,7 +42,9 @@
             Stopwatch timer = Stopwatch.StartNew();
             TTree tree = CreateTree(points);
             timer.Stop();
-            UnityEngine.Debug.Log($"| Construction (1 million points) | {(int)Math.Floor(1 / timer.Elapsed.TotalSeconds)} ({timer.Elapsed.TotalSeconds} total) |");
+            UnityEngine.Debug.Log(
+                $"| Construction (1 million points) | {(int)Math.Floor(1 / timer.Elapsed.TotalSeconds)} ({timer.Elapsed.TotalSeconds} seconds total) |"
+            );
             Vector2 center = tree.Boundary.center;
             int count = 0;
             TimeSpan timeout = TimeSpan.FromSeconds(1);
@@ -47,10 +54,11 @@
                 int elementsInRange = tree.GetElementsInRange(center, radius).Count();
                 Assert.AreEqual(785456, elementsInRange);
                 ++count;
-            }
-            while (timer.Elapsed < timeout);
+            } while (timer.Elapsed < timeout);
 
-            UnityEngine.Debug.Log($"| Elements In Range - Full | {(int)Math.Floor(count / timeout.TotalSeconds)} |");
+            UnityEngine.Debug.Log(
+                $"| Elements In Range - Full | {(int)Math.Floor(count / timeout.TotalSeconds)} |"
+            );
 
             radius /= 2f;
             count = 0;
@@ -60,9 +68,10 @@
                 int elementsInRange = tree.GetElementsInRange(center, radius).Count();
                 Assert.AreEqual(196364, elementsInRange);
                 ++count;
-            }
-            while (timer.Elapsed < timeout);
-            UnityEngine.Debug.Log($"| Elements In Range - Half | {(int)Math.Floor(count / timeout.TotalSeconds)} |");
+            } while (timer.Elapsed < timeout);
+            UnityEngine.Debug.Log(
+                $"| Elements In Range - Half | {(int)Math.Floor(count / timeout.TotalSeconds)} |"
+            );
 
             radius /= 2f;
             count = 0;
@@ -72,9 +81,10 @@
                 int elementsInRange = tree.GetElementsInRange(center, radius).Count();
                 Assert.AreEqual(49080, elementsInRange);
                 ++count;
-            }
-            while (timer.Elapsed < timeout);
-            UnityEngine.Debug.Log($"| Elements In Range - Quarter | {(int)Math.Floor(count / timeout.TotalSeconds)} |");
+            } while (timer.Elapsed < timeout);
+            UnityEngine.Debug.Log(
+                $"| Elements In Range - Quarter | {(int)Math.Floor(count / timeout.TotalSeconds)} |"
+            );
 
             radius = 1f;
             count = 0;
@@ -84,9 +94,10 @@
                 int elementsInRange = tree.GetElementsInRange(center, radius).Count();
                 Assert.AreEqual(4, elementsInRange);
                 ++count;
-            }
-            while (timer.Elapsed < timeout);
-            UnityEngine.Debug.Log($"| Elements In Range - 1 Range | {(int)Math.Floor(count / timeout.TotalSeconds)} |");
+            } while (timer.Elapsed < timeout);
+            UnityEngine.Debug.Log(
+                $"| Elements In Range - 1 Range | {(int)Math.Floor(count / timeout.TotalSeconds)} |"
+            );
 
             int nearestNeighborCount = 500;
             List<Vector2> nearestNeighbors = new();
@@ -97,9 +108,10 @@
                 tree.GetApproximateNearestNeighbors(center, nearestNeighborCount, nearestNeighbors);
                 Assert.IsTrue(nearestNeighbors.Count <= nearestNeighborCount);
                 ++count;
-            }
-            while (timer.Elapsed < timeout);
-            UnityEngine.Debug.Log($"| ANN - 500 | {(int)Math.Floor(count / timeout.TotalSeconds)} |");
+            } while (timer.Elapsed < timeout);
+            UnityEngine.Debug.Log(
+                $"| ANN - 500 | {(int)Math.Floor(count / timeout.TotalSeconds)} |"
+            );
 
             nearestNeighborCount = 100;
             count = 0;
@@ -109,9 +121,10 @@
                 tree.GetApproximateNearestNeighbors(center, nearestNeighborCount, nearestNeighbors);
                 Assert.IsTrue(nearestNeighbors.Count <= nearestNeighborCount);
                 ++count;
-            }
-            while (timer.Elapsed < timeout);
-            UnityEngine.Debug.Log($"| ANN - 100 | {(int)Math.Floor(count / timeout.TotalSeconds)} |");
+            } while (timer.Elapsed < timeout);
+            UnityEngine.Debug.Log(
+                $"| ANN - 100 | {(int)Math.Floor(count / timeout.TotalSeconds)} |"
+            );
 
             nearestNeighborCount = 10;
             count = 0;
@@ -121,9 +134,10 @@
                 tree.GetApproximateNearestNeighbors(center, nearestNeighborCount, nearestNeighbors);
                 Assert.IsTrue(nearestNeighbors.Count <= nearestNeighborCount);
                 ++count;
-            }
-            while (timer.Elapsed < timeout);
-            UnityEngine.Debug.Log($"| ANN - 10 | {(int)Math.Floor(count / timeout.TotalSeconds)} |");
+            } while (timer.Elapsed < timeout);
+            UnityEngine.Debug.Log(
+                $"| ANN - 10 | {(int)Math.Floor(count / timeout.TotalSeconds)} |"
+            );
 
             nearestNeighborCount = 1;
             count = 0;
@@ -133,8 +147,7 @@
                 tree.GetApproximateNearestNeighbors(center, nearestNeighborCount, nearestNeighbors);
                 Assert.IsTrue(nearestNeighbors.Count <= nearestNeighborCount);
                 ++count;
-            }
-            while (timer.Elapsed < timeout);
+            } while (timer.Elapsed < timeout);
             UnityEngine.Debug.Log($"| ANN - 1 | {(int)Math.Floor(count / timeout.TotalSeconds)} |");
         }
     }

package/Tests/Runtime/Random/DotNetRandomTests.cs

@@ -0,0 +1,9 @@
+namespace UnityHelpers.Tests.Random
+{
+    using Core.Random;
+
+    public sealed class DotNetRandomTests : RandomTestBase
+    {
+        protected override IRandom NewRandom() => new DotNetRandom();
+    }
+}

package/Tests/Runtime/Random/DotNetRandomTests.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 45efbe46a3704e97b7d86757c8528a5c
+timeCreated: 1732482168