com.wallstop-studios.unity-helpers 2.0.0-rc05 → 2.0.0-rc07

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 5041bafe46dc450bb37153e394011636
+timeCreated: 1732564259

package/Runtime/Core/Random/PcgRandom.cs

@@ -15,8 +15,6 @@
             IComparable,
             IComparable<PcgRandom>
     {
-        [DataMember(Name = "State")]
-        [JsonPropertyName("State")]
         public static IRandom Instance => ThreadLocalRandom<PcgRandom>.Instance;
 
         internal readonly ulong _increment;
@@ -34,11 +32,11 @@
         }
 
         [JsonConstructor]
-        public PcgRandom(RandomState state)
+        public PcgRandom(RandomState internalState)
         {
-            _state = state.State1;
-            _increment = state.State2;
-            _cachedGaussian = state.Gaussian;
+            _state = internalState.State1;
+            _increment = internalState.State2;
+            _cachedGaussian = internalState.Gaussian;
         }
 
         public PcgRandom(ulong increment, ulong state)

package/Runtime/Core/Random/RandomState.cs

@@ -1,16 +1,20 @@
 namespace UnityHelpers.Core.Random
 {
     using System;
+    using System.Linq;
+    using System.Runtime.Serialization;
     using System.Text.Json.Serialization;
     using Extension;
     using Helper;
     using ProtoBuf;
 
     [Serializable]
+    [DataContract]
     [ProtoContract]
     public struct RandomState : IEquatable<RandomState>
     {
         public ulong State1 => _state1;
+
         public ulong State2 => _state2;
 
         public double? Gaussian
@@ -26,6 +30,8 @@
             }
         }
 
+        public byte[] Payload => _payload;
+
         [ProtoMember(1)]
         private ulong _state1;
 
@@ -38,16 +44,31 @@
         [ProtoMember(4)]
         private double _gaussian;
 
+        [ProtoMember(5)]
+        private byte[] _payload;
+
         private int _hashCode;
 
         [JsonConstructor]
-        public RandomState(ulong state1, ulong state2 = 0, double? gaussian = null)
+        public RandomState(
+            ulong state1,
+            ulong state2 = 0,
+            double? gaussian = null,
+            byte[] payload = null
+        )
         {
             _state1 = state1;
             _state2 = state2;
             _hasGaussian = gaussian.HasValue;
             _gaussian = gaussian ?? 0;
-            _hashCode = Objects.ValueTypeHashCode(state1, state2, _hasGaussian, _gaussian);
+            _payload = payload?.ToArray();
+            _hashCode = Objects.ValueTypeHashCode(
+                state1,
+                state2,
+                _hasGaussian,
+                _gaussian,
+                _payload != null
+            );
         }
 
         public RandomState(Guid guid)
@@ -57,7 +78,14 @@
             _state2 = BitConverter.ToUInt64(guidBytes, sizeof(ulong));
             _hasGaussian = false;
             _gaussian = 0;
-            _hashCode = Objects.ValueTypeHashCode(_state1, _state2, _hasGaussian, _gaussian);
+            _payload = null;
+            _hashCode = Objects.ValueTypeHashCode(
+                _state1,
+                _state2,
+                _hasGaussian,
+                _gaussian,
+                _payload != null
+            );
         }
 
         [ProtoAfterDeserialization]

package/Runtime/Core/Random/SquirrelRandom.cs

@@ -16,8 +16,6 @@
 
         public static readonly SquirrelRandom Instance = ThreadLocalRandom<SquirrelRandom>.Instance;
 
-        [JsonPropertyName("State")]
-        [DataMember(Name = "State")]
         public override RandomState InternalState => new(_position, gaussian: _cachedGaussian);
 
         private uint _position;
@@ -31,15 +29,15 @@
         }
 
         [JsonConstructor]
-        public SquirrelRandom(RandomState randomState)
+        public SquirrelRandom(RandomState internalState)
         {
-            _position = unchecked((uint)randomState.State1);
-            _cachedGaussian = randomState.Gaussian;
+            _position = unchecked((uint)internalState.State1);
+            _cachedGaussian = internalState.Gaussian;
         }
 
         public override uint NextUint()
         {
-            return _position = NextUintInternal(_position);
+            return NextUintInternal(ref _position);
         }
 
         // Does not advance the RNG
@@ -53,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

@@ -3,6 +3,7 @@
     using System;
     using System.Runtime.Serialization;
     using System.Text.Json.Serialization;
+    using Helper;
 
     /// <summary>
     ///     Implementation dependent upon .Net's Random class.
@@ -11,105 +12,150 @@
     [DataContract]
     public sealed class SystemRandom : AbstractRandom
     {
-        [JsonPropertyName("State")]
-        [DataMember(Name = "State")]
+        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), _cachedGaussian);
+            new(
+                unchecked((ulong)_inext),
+                unchecked((ulong)_inextp),
+                _cachedGaussian,
+                ArrayConverter.IntArrayToByteArrayBlockCopy(_seedArray)
+            );
 
         /*
             Copied from Random.cs source. Apparently it isn't guaranteed to be the
-            same across platforms and we depend on that.
+            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];
-
-        public static IRandom Instance => ThreadLocalRandom<SystemRandom>.Instance;
+        private int _inext;
+        private int _inextp;
+        private readonly int[] _seedArray = new int[SeedArraySize];
 
         public SystemRandom()
-            : this(Environment.TickCount) { }
+            : this(Guid.NewGuid().GetHashCode()) { }
 
         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]
-        public SystemRandom(RandomState randomState)
+        public SystemRandom(RandomState internalState)
         {
-            inext = unchecked((int)randomState.State1);
-            inextp = unchecked((int)randomState.State2);
-            _cachedGaussian = randomState.Gaussian;
+            unchecked
+            {
+                _inext = (int)internalState.State1;
+                _inextp = (int)internalState.State2;
+            }
+            _cachedGaussian = internalState.Gaussian;
+            _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/Runtime/Core/Random/ThreadLocalRandom.cs

@@ -2,7 +2,8 @@
 {
     using System.Threading;
 
-    public static class ThreadLocalRandom<T> where T : IRandom, new()
+    public static class ThreadLocalRandom<T>
+        where T : IRandom, new()
     {
         private static readonly ThreadLocal<T> RandomCache = new ThreadLocal<T>(() => new T());
 

package/Runtime/Core/Random/UnityRandom.cs

@@ -10,8 +10,6 @@
     {
         public static readonly UnityRandom Instance = new();
 
-        [JsonPropertyName("State")]
-        [DataMember(Name = "State")]
         public override RandomState InternalState
         {
             get
@@ -38,11 +36,11 @@
         }
 
         [JsonConstructor]
-        public UnityRandom(RandomState state)
+        public UnityRandom(RandomState internalState)
         {
             unchecked
             {
-                _seed = state.Gaussian != null ? (int)state.State1 : null;
+                _seed = internalState.Gaussian != null ? (int)internalState.State1 : null;
             }
         }
 

package/Runtime/Core/Random/WyRandom.cs

@@ -16,8 +16,6 @@
 
         public static IRandom Instance => ThreadLocalRandom<WyRandom>.Instance;
 
-        [JsonPropertyName("State")]
-        [DataMember(Name = "State")]
         public override RandomState InternalState => new RandomState(_state);
 
         private ulong _state;
@@ -32,9 +30,9 @@
         }
 
         [JsonConstructor]
-        public WyRandom(RandomState randomState)
+        public WyRandom(RandomState internalState)
         {
-            _state = randomState.State1;
+            _state = internalState.State1;
         }
 
         public WyRandom(ulong state)

package/Runtime/Core/Random/XorShiftRandom.cs

@@ -10,8 +10,6 @@
     {
         public static IRandom Instance => ThreadLocalRandom<XorShiftRandom>.Instance;
 
-        [JsonPropertyName("State")]
-        [DataMember(Name = "State")]
         public override RandomState InternalState => new(_state, 0, _cachedGaussian);
 
         private uint _state;
@@ -25,10 +23,10 @@
         }
 
         [JsonConstructor]
-        public XorShiftRandom(RandomState state)
+        public XorShiftRandom(RandomState internalState)
         {
-            _state = unchecked((uint)state.State1);
-            _cachedGaussian = state.Gaussian;
+            _state = unchecked((uint)internalState.State1);
+            _cachedGaussian = internalState.Gaussian;
         }
 
         public override uint NextUint()

package/Runtime/Core/Serialization/Serializer.cs

@@ -2,13 +2,13 @@
 {
     using System;
     using System.ComponentModel;
-    using Extension;
-    using JsonConverters;
     using System.IO;
     using System.Runtime.Serialization.Formatters.Binary;
     using System.Text;
     using System.Text.Json;
     using System.Text.Json.Serialization;
+    using Extension;
+    using JsonConverters;
 
     internal static class SerializerEncoding
     {
@@ -30,7 +30,7 @@
                 {
                     new JsonStringEnumConverter(),
                     Vector3Converter.Instance,
-                    Vector2Converter.Instance
+                    Vector2Converter.Instance,
                 },
             };
 
@@ -45,7 +45,7 @@
                 {
                     new JsonStringEnumConverter(),
                     Vector3Converter.Instance,
-                    Vector2Converter.Instance
+                    Vector2Converter.Instance,
                 },
                 WriteIndented = true,
             };
@@ -70,7 +70,10 @@
                     return ProtoDeserialize<T>(serialized);
                 default:
                     throw new InvalidEnumArgumentException(
-                        nameof(serializationType), (int)serializationType, typeof(SerializationType));
+                        nameof(serializationType),
+                        (int)serializationType,
+                        typeof(SerializationType)
+                    );
             }
         }
 
@@ -84,7 +87,10 @@
                     return ProtoSerialize(instance);
                 default:
                     throw new InvalidEnumArgumentException(
-                        nameof(serializationType), (int)serializationType, typeof(SerializationType));
+                        nameof(serializationType),
+                        (int)serializationType,
+                        typeof(SerializationType)
+                    );
             }
         }
 
@@ -123,9 +129,14 @@
             return memoryStream.ToArray();
         }
 
-        public static T JsonDeserialize<T>(string data)
+        public static T JsonDeserialize<T>(string data, Type type = null)
         {
-            return JsonSerializer.Deserialize<T>(data, SerializerEncoding.NormalJsonOptions);
+            return (T)
+                JsonSerializer.Deserialize(
+                    data,
+                    type ?? typeof(T),
+                    SerializerEncoding.NormalJsonOptions
+                );
         }
 
         public static byte[] JsonSerialize<T>(T input)
@@ -135,13 +146,24 @@
 
         public static string JsonStringify<T>(T input, bool pretty = false)
         {
-            JsonSerializerOptions options =
-                pretty ? SerializerEncoding.PrettyJsonOptions : SerializerEncoding.NormalJsonOptions;
-            if (typeof(T) == typeof(object))
+            JsonSerializerOptions options = pretty
+                ? SerializerEncoding.PrettyJsonOptions
+                : SerializerEncoding.NormalJsonOptions;
+            Type parameterType = typeof(T);
+            if (
+                parameterType.IsAbstract
+                || parameterType.IsInterface
+                || parameterType == typeof(object)
+            )
             {
                 object data = input;
-                Type type = data?.GetType();
-                return JsonSerializer.Serialize(data, data?.GetType(), options);
+                if (data == null)
+                {
+                    return "{}";
+                }
+
+                Type type = data.GetType();
+                return JsonSerializer.Serialize(data, type, options);
             }
 
             return JsonSerializer.Serialize(input, options);
@@ -159,4 +181,4 @@
             File.WriteAllText(path, jsonAsText);
         }
     }
-}
+}

package/Runtime/Utils/CircleLineRenderer.cs

@@ -17,7 +17,7 @@
         public int baseSegments = 4;
         public float updateRateSeconds = 0.1f;
         public Color color = Color.grey;
-        
+
         public Vector3 Offset
         {
             get => _offset;
@@ -26,6 +26,7 @@
 
         [SiblingComponent]
         private CircleCollider2D _collider;
+
         [SiblingComponent]
         private LineRenderer[] _lineRenderers;
 
@@ -70,7 +71,11 @@
 
             if (maxLineWidth < minLineWidth)
             {
-                this.LogWarn("MaxLineWidth {0} smaller than MinLineWidth {1}.", maxLineWidth, minLineWidth);
+                this.LogWarn(
+                    "MaxLineWidth {0} smaller than MinLineWidth {1}.",
+                    maxLineWidth,
+                    minLineWidth
+                );
             }
         }
 
@@ -98,7 +103,10 @@
                 lineRenderer.positionCount = numSegments;
 
                 // ReSharper disable once CompareOfFloatsByEqualityOperator
-                float lineWidth = minLineWidth == maxLineWidth ? minLineWidth : PcgRandom.Instance.NextFloat(minLineWidth, maxLineWidth);
+                float lineWidth =
+                    minLineWidth == maxLineWidth
+                        ? minLineWidth
+                        : PRNG.Instance.NextFloat(minLineWidth, maxLineWidth);
 
                 lineRenderer.startWidth = lineWidth;
                 lineRenderer.endWidth = lineWidth;
@@ -106,12 +114,16 @@
                 float distanceMultiplier = _collider.radius;
 
                 float angle = 360f / numSegments;
-                float offsetRadians = PcgRandom.Instance.NextFloat(angle);
+                float offsetRadians = PRNG.Instance.NextFloat(angle);
                 float currentOffset = offsetRadians;
                 Vector3[] positions = new Vector3[numSegments];
                 for (int i = 0; i < numSegments; ++i)
                 {
-                    positions[i] = new Vector3(Mathf.Cos(Mathf.Deg2Rad * currentOffset), Mathf.Sin(Mathf.Deg2Rad * currentOffset)) * distanceMultiplier;
+                    positions[i] =
+                        new Vector3(
+                            Mathf.Cos(Mathf.Deg2Rad * currentOffset),
+                            Mathf.Sin(Mathf.Deg2Rad * currentOffset)
+                        ) * distanceMultiplier;
                     currentOffset += angle % 360f;
                 }