com.wallstop-studios.unity-helpers 2.0.0-rc15 → 2.0.0-rc17

package/Runtime/Core/Extension/RandomExtensions.cs

@@ -1,5 +1,8 @@
 namespace UnityHelpers.Core.Extension
 {
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
     using Helper;
     using Random;
     using UnityEngine;
@@ -11,6 +14,61 @@
             return random.NextVector2(-amplitude, amplitude);
         }
 
+        public static T NextEnumExcept<T>(this IRandom random, params T[] exceptions)
+            where T : struct, Enum
+        {
+            T value;
+            do
+            {
+                value = random.NextEnum<T>();
+            } while (0 <= Array.IndexOf(exceptions, value));
+
+            return value;
+        }
+
+        public static T NextOfExcept<T>(
+            this IRandom random,
+            IEnumerable<T> values,
+            params T[] exceptions
+        )
+        {
+            T value;
+
+            switch (values)
+            {
+                case IReadOnlyList<T> list:
+                {
+                    do
+                    {
+                        value = random.NextOf(list);
+                    } while (0 <= Array.IndexOf(exceptions, value));
+
+                    break;
+                }
+                case IReadOnlyCollection<T> collection:
+                {
+                    do
+                    {
+                        value = random.NextOf(collection);
+                    } while (0 <= Array.IndexOf(exceptions, value));
+
+                    break;
+                }
+                default:
+                {
+                    T[] input = values.ToArray();
+                    do
+                    {
+                        value = random.NextOf(input);
+                    } while (0 <= Array.IndexOf(exceptions, value));
+
+                    break;
+                }
+            }
+
+            return value;
+        }
+
         public static Vector2 NextVector2(
             this IRandom random,
             float minAmplitude,

package/Runtime/Core/Random/AbstractRandom.cs

@@ -417,16 +417,40 @@
 
         public Guid NextGuid()
         {
-            byte[] guidBytes = new byte[16];
-            NextBytes(guidBytes);
-            return new Guid(guidBytes);
+            return new Guid(GenerateGuidBytes());
         }
 
         public KGuid NextKGuid()
+        {
+            return new KGuid(GenerateGuidBytes());
+        }
+
+        private byte[] GenerateGuidBytes()
         {
             byte[] guidBytes = new byte[16];
             NextBytes(guidBytes);
-            return new KGuid(guidBytes);
+            SetUuidV4Bits(guidBytes);
+            return guidBytes;
+        }
+
+        public static void SetUuidV4Bits(byte[] bytes)
+        {
+            // Set version to 4 (bits 6-7 of byte 6)
+
+            // Clear the version bits first (clear bits 4-7)
+            byte value = bytes[6];
+            value &= 0x0f;
+            // Set version 4 (set bits 4-7 to 0100)
+            value |= 0x40;
+            bytes[6] = value;
+
+            // Set variant to RFC 4122 (bits 6-7 of byte 8)
+            value = bytes[8];
+            // Clear the variant bits first (clear bits 6-7)
+            value &= 0x3f;
+            // Set RFC 4122 variant (set bits 6-7 to 10)
+            value |= 0x80;
+            bytes[8] = value;
         }
 
         // Advances the RNG

package/Tests/Runtime/Random/RandomTestBase.cs

@@ -549,6 +549,26 @@
             }
         }
 
+        [Test]
+        [Parallelizable]
+        public void NextEnumerableExcept()
+        {
+            IRandom random = NewRandom();
+            for (int i = 0; i < NormalIterations; ++i)
+            {
+                TestValues exception = random.NextEnum<TestValues>();
+                HashSet<TestValues> selected = Enum.GetValues(typeof(TestValues))
+                    .OfType<TestValues>()
+                    .Shuffled(random)
+                    .Skip(3)
+                    .ToHashSet();
+
+                TestValues value = random.NextOfExcept(selected.Shuffled(random), exception);
+                Assert.IsTrue(selected.Contains(value));
+                Assert.AreNotEqual(value, exception);
+            }
+        }
+
         [Test]
         [Parallelizable]
         public void NextArray()
@@ -636,6 +656,23 @@
             Assert.AreEqual(Enum.GetValues(typeof(TestValues)).Length, seenEnums.Count);
         }
 
+        [Test]
+        [Parallelizable]
+        public void NextEnumExcept()
+        {
+            IRandom random = NewRandom();
+            HashSet<TestValues> seenEnums = new();
+            for (int i = 0; i < NormalIterations; ++i)
+            {
+                TestValues value = random.NextEnumExcept(TestValues.Value8, TestValues.Value9);
+                _ = seenEnums.Add(value);
+            }
+
+            Assert.AreEqual(Enum.GetValues(typeof(TestValues)).Length - 2, seenEnums.Count);
+            Assert.IsFalse(seenEnums.Contains(TestValues.Value8));
+            Assert.IsFalse(seenEnums.Contains(TestValues.Value9));
+        }
+
         [Test]
         [Parallelizable]
         public void NextNoiseMap()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "com.wallstop-studios.unity-helpers",
-  "version": "2.0.0-rc15",
+  "version": "2.0.0-rc17",
   "displayName": "Unity Helpers",
   "description": "Various Unity Helper Library",
   "dependencies": {},