com.wallstop-studios.unity-helpers 2.0.0-rc22 → 2.0.0-rc23

package/Runtime/Core/Math/XXHash.cs

@@ -18,7 +18,10 @@
         private const uint k_Prime32v5 = 374761393u;
 
         public static uint Hash32(string text) => Hash32(text, Encoding.UTF8);
-        public static uint Hash32(string text, Encoding encoding) => Hash32(encoding.GetBytes(text));
+
+        public static uint Hash32(string text, Encoding encoding) =>
+            Hash32(encoding.GetBytes(text));
+
         public static uint Hash32(byte[] buffer)
         {
             unsafe
@@ -71,7 +74,10 @@
         }
 
         public static ulong Hash64(string text) => Hash64(text, Encoding.UTF8);
-        public static ulong Hash64(string text, Encoding encoding) => Hash64(encoding.GetBytes(text));
+
+        public static ulong Hash64(string text, Encoding encoding) =>
+            Hash64(encoding.GetBytes(text));
+
         public static ulong Hash64(byte[] buffer)
         {
             unsafe
@@ -120,7 +126,6 @@
             acc += (ulong)len;
             acc = processRemaining64(pInput, acc, remainingLen);
 
-
             return avalanche64(acc);
         }
 
@@ -130,17 +135,19 @@
             ref ulong acc1,
             ref ulong acc2,
             ref ulong acc3,
-            ref ulong acc4)
+            ref ulong acc4
+        )
         {
             processLane64(ref acc1, ref pInput);
             processLane64(ref acc2, ref pInput);
             processLane64(ref acc3, ref pInput);
             processLane64(ref acc4, ref pInput);
 
-            ulong acc = Bits.RotateLeft(acc1, 1)
-                        + Bits.RotateLeft(acc2, 7)
-                        + Bits.RotateLeft(acc3, 12)
-                        + Bits.RotateLeft(acc4, 18);
+            ulong acc =
+                Bits.RotateLeft(acc1, 1)
+                + Bits.RotateLeft(acc2, 7)
+                + Bits.RotateLeft(acc3, 12)
+                + Bits.RotateLeft(acc4, 18);
 
             mergeAccumulator64(ref acc, acc1);
             mergeAccumulator64(ref acc, acc2);
@@ -158,10 +165,7 @@
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static unsafe ulong processRemaining64(
-            byte* pInput,
-            ulong acc,
-            int remainingLen)
+        private static unsafe ulong processRemaining64(byte* pInput, ulong acc, int remainingLen)
         {
             for (ulong lane; remainingLen >= 8; remainingLen -= 8, pInput += 8)
             {
@@ -223,7 +227,8 @@
             ref uint acc1,
             ref uint acc2,
             ref uint acc3,
-            ref uint acc4)
+            ref uint acc4
+        )
         {
             processLane32(ref pInput, ref acc1);
             processLane32(ref pInput, ref acc2);
@@ -231,9 +236,9 @@
             processLane32(ref pInput, ref acc4);
 
             return Bits.RotateLeft(acc1, 1)
-                   + Bits.RotateLeft(acc2, 7)
-                   + Bits.RotateLeft(acc3, 12)
-                   + Bits.RotateLeft(acc4, 18);
+                + Bits.RotateLeft(acc2, 7)
+                + Bits.RotateLeft(acc3, 12)
+                + Bits.RotateLeft(acc4, 18);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -245,10 +250,7 @@
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        private static unsafe uint processRemaining32(
-            byte* pInput,
-            uint acc,
-            int remainingLen)
+        private static unsafe uint processRemaining32(byte* pInput, uint acc, int remainingLen)
         {
             for (uint lane; remainingLen >= 4; remainingLen -= 4, pInput += 4)
             {

package/Runtime/Core/Model/Direction.cs

@@ -7,15 +7,32 @@
     [Serializable]
     public enum Direction : short
     {
-        [EnumMember] None = 0,
-        [EnumMember] North = 1,
-        [EnumMember] NorthEast = 2,
-        [EnumMember] East = 4,
-        [EnumMember] SouthEast = 8,
-        [EnumMember] South = 16,
-        [EnumMember] SouthWest = 32,
-        [EnumMember] West = 64,
-        [EnumMember] NorthWest = 128
+        [EnumMember]
+        None = 0,
+
+        [EnumMember]
+        North = 1,
+
+        [EnumMember]
+        NorthEast = 2,
+
+        [EnumMember]
+        East = 4,
+
+        [EnumMember]
+        SouthEast = 8,
+
+        [EnumMember]
+        South = 16,
+
+        [EnumMember]
+        SouthWest = 32,
+
+        [EnumMember]
+        West = 64,
+
+        [EnumMember]
+        NorthWest = 128,
     }
 
     public static class DirectionConstants

package/Runtime/Core/OneOf/FastOneOf.cs

@@ -44,14 +44,15 @@
             {
                 if (_index != 0)
                 {
-                    throw new InvalidOperationException($"Cannot return as T0 as result is T{_index}");
+                    throw new InvalidOperationException(
+                        $"Cannot return as T0 as result is T{_index}"
+                    );
                 }
 
                 return _value0;
             }
         }
 
-
         public T1 AsT1
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -59,7 +60,9 @@
             {
                 if (_index != 1)
                 {
-                    throw new InvalidOperationException($"Cannot return as T1 as result is T{_index}");
+                    throw new InvalidOperationException(
+                        $"Cannot return as T1 as result is T{_index}"
+                    );
                 }
 
                 return _value1;
@@ -73,7 +76,9 @@
             {
                 if (_index != 2)
                 {
-                    throw new InvalidOperationException($"Cannot return as T2 as result is T{_index}");
+                    throw new InvalidOperationException(
+                        $"Cannot return as T2 as result is T{_index}"
+                    );
                 }
 
                 return _value2;
@@ -89,7 +94,9 @@
         }
 
         public static implicit operator FastOneOf<T0, T1, T2>(T0 value) => new(0, value0: value);
+
         public static implicit operator FastOneOf<T0, T1, T2>(T1 value) => new(1, value1: value);
+
         public static implicit operator FastOneOf<T0, T1, T2>(T2 value) => new(2, value2: value);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]

package/Runtime/Core/OneOf/None.cs

@@ -1,6 +1,4 @@
 namespace UnityHelpers.Core.OneOf
 {
-    public readonly struct None
-    {
-    }
+    public readonly struct None { }
 }

package/Runtime/Core/Serialization/JsonConverters/Vector2Converter.cs

@@ -11,14 +11,19 @@
 
         private Vector2Converter() { }
 
-        public override Vector2 Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+        public override Vector2 Read(
+            ref Utf8JsonReader reader,
+            Type typeToConvert,
+            JsonSerializerOptions options
+        )
         {
             if (reader.TokenType != JsonTokenType.StartObject)
             {
                 throw new JsonException($"Invalid token type {reader.TokenType}");
             }
 
-            float x = 0, y = 0;
+            float x = 0,
+                y = 0;
 
             while (reader.Read())
             {
@@ -54,7 +59,11 @@
             throw new JsonException("Incomplete JSON for Vector2");
         }
 
-        public override void Write(Utf8JsonWriter writer, Vector2 value, JsonSerializerOptions options)
+        public override void Write(
+            Utf8JsonWriter writer,
+            Vector2 value,
+            JsonSerializerOptions options
+        )
         {
             writer.WriteStartObject();
             writer.WriteNumber("x", value.x);
@@ -62,4 +71,4 @@
             writer.WriteEndObject();
         }
     }
-}
+}

package/Runtime/Core/Serialization/JsonConverters/Vector3Converter.cs

@@ -1,9 +1,9 @@
 namespace UnityHelpers.Core.Serialization.JsonConverters
 {
     using System;
-    using UnityEngine;
     using System.Text.Json;
     using System.Text.Json.Serialization;
+    using UnityEngine;
 
     public sealed class Vector3Converter : JsonConverter<Vector3>
     {
@@ -11,14 +11,20 @@
 
         private Vector3Converter() { }
 
-        public override Vector3 Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+        public override Vector3 Read(
+            ref Utf8JsonReader reader,
+            Type typeToConvert,
+            JsonSerializerOptions options
+        )
         {
             if (reader.TokenType != JsonTokenType.StartObject)
             {
                 throw new JsonException($"Invalid token type {reader.TokenType}");
             }
 
-            float x = 0, y = 0, z = 0;
+            float x = 0,
+                y = 0,
+                z = 0;
 
             while (reader.Read())
             {
@@ -59,7 +65,11 @@
             throw new JsonException("Incomplete JSON for Vector3");
         }
 
-        public override void Write(Utf8JsonWriter writer, Vector3 value, JsonSerializerOptions options)
+        public override void Write(
+            Utf8JsonWriter writer,
+            Vector3 value,
+            JsonSerializerOptions options
+        )
         {
             writer.WriteStartObject();
             writer.WriteNumber("x", value.x);
@@ -68,4 +78,4 @@
             writer.WriteEndObject();
         }
     }
-}
+}

package/Runtime/Core/Threading/SingleThreadedThreadPool.cs

@@ -83,8 +83,7 @@
             do
             {
                 active = Interlocked.CompareExchange(ref _active, 0, _active);
-            }
-            while (active != 0);
+            } while (active != 0);
 
             if (disposing)
             {
@@ -105,4 +104,4 @@
             _disposed = true;
         }
     }
-}
+}

package/Runtime/Utils/AnimationEventEqualityComparer.cs

@@ -4,14 +4,13 @@
     using System.Collections.Generic;
     using UnityEngine;
 
-    public sealed class AnimationEventEqualityComparer : EqualityComparer<AnimationEvent>, IComparer<AnimationEvent>
+    public sealed class AnimationEventEqualityComparer
+        : EqualityComparer<AnimationEvent>,
+            IComparer<AnimationEvent>
     {
         public static readonly AnimationEventEqualityComparer Instance = new();
 
-        private AnimationEventEqualityComparer()
-        {
-
-        }
+        private AnimationEventEqualityComparer() { }
 
         // Returns a shallow copy with equatable values propagated
         public AnimationEvent Copy(AnimationEvent instance)
@@ -93,13 +92,18 @@
 
             return true;
         }
-    
 
         public override int GetHashCode(AnimationEvent instance)
         {
             return HashCode.Combine(
-                instance.time, instance.functionName, instance.intParameter, instance.floatParameter,
-                instance.stringParameter, instance.objectReferenceParameter, instance.messageOptions);
+                instance.time,
+                instance.functionName,
+                instance.intParameter,
+                instance.floatParameter,
+                instance.stringParameter,
+                instance.objectReferenceParameter,
+                instance.messageOptions
+            );
         }
 
         public int Compare(AnimationEvent lhs, AnimationEvent rhs)
@@ -125,7 +129,11 @@
                 return timeComparison;
             }
 
-            int functionNameComparison = string.Compare(lhs.functionName, rhs.functionName, StringComparison.Ordinal);
+            int functionNameComparison = string.Compare(
+                lhs.functionName,
+                rhs.functionName,
+                StringComparison.Ordinal
+            );
             if (functionNameComparison != 0)
             {
                 return functionNameComparison;
@@ -137,7 +145,11 @@
                 return intParameterComparison;
             }
 
-            int stringParameterComparison = string.Compare(lhs.stringParameter, rhs.stringParameter, StringComparison.Ordinal);
+            int stringParameterComparison = string.Compare(
+                lhs.stringParameter,
+                rhs.stringParameter,
+                StringComparison.Ordinal
+            );
             if (stringParameterComparison != 0)
             {
                 return stringParameterComparison;

package/Runtime/Utils/AnimatorEnumStateMachine.cs

@@ -1,12 +1,12 @@
 namespace UnityHelpers.Utils
 {
-    using Core.Extension;
     using System;
     using System.Collections.Generic;
     using System.Globalization;
     using System.Linq;
     using System.Runtime.Serialization;
     using System.Text.Json.Serialization;
+    using Core.Extension;
     using UnityEngine;
 
     /// <summary>
@@ -15,8 +15,7 @@
     /// <typeparam name="T">Specific Enum being managed.</typeparam>
     [DataContract]
     public sealed class AnimatorEnumStateMachine<T>
-        where T : struct, IConvertible, IComparable,
-        IFormattable // This is as close as we can get to saying where T : Enum (https://stackoverflow.com/questions/79126/create-generic-method-constraining-t-to-an-enum)
+        where T : struct, IConvertible, IComparable, IFormattable // This is as close as we can get to saying where T : Enum (https://stackoverflow.com/questions/79126/create-generic-method-constraining-t-to-an-enum)
     {
         private static readonly T[] Values = Enum.GetValues(typeof(T)).OfType<T>().ToArray();
 
@@ -86,4 +85,4 @@
             return this.ToJson();
         }
     }
-}
+}

package/Runtime/Utils/Buffers.cs

@@ -29,4 +29,4 @@
         public static readonly Stack<T> Stack = new();
         public static readonly LinkedList<T> LinkedList = new();
     }
-}
+}

package/Runtime/Utils/CenterPointOffset.cs

@@ -27,5 +27,4 @@
             }
         }
     }
-
-}
+}

package/Runtime/Utils/CoroutineHandler.cs

@@ -1,4 +1,4 @@
 namespace UnityHelpers.Utils
 {
     public sealed class CoroutineHandler : RuntimeSingleton<CoroutineHandler> { }
-}
+}

package/Runtime/Utils/Oscillator.cs

@@ -10,7 +10,7 @@
         public float height = 1f;
 
         private Vector3 _initialLocalPosition;
-        
+
         private void Awake()
         {
             _initialLocalPosition = transform.localPosition;
@@ -19,7 +19,9 @@
         private void Update()
         {
             float time = Time.time;
-            transform.localPosition = _initialLocalPosition + new Vector3(Mathf.Cos(time * speed) * width, Mathf.Sin(time * speed) * height);
+            transform.localPosition =
+                _initialLocalPosition
+                + new Vector3(Mathf.Cos(time * speed) * width, Mathf.Sin(time * speed) * height);
         }
     }
 }

package/Runtime/Utils/SetTextureImportData.cs

@@ -66,4 +66,4 @@
 # endif
         }
     }
-}
+}

package/Runtime/Utils/SpriteRendererSyncer.cs

@@ -47,7 +47,8 @@
 
         private void LateUpdate()
         {
-            SpriteRenderer localToMatch = dynamicToMatch != null ? GetDynamicSpriteRenderer() : toMatch;
+            SpriteRenderer localToMatch =
+                dynamicToMatch != null ? GetDynamicSpriteRenderer() : toMatch;
             if (localToMatch == null)
             {
                 _spriteRenderer.sprite = null;
@@ -75,7 +76,8 @@
 
             if (matchOrderInLayer)
             {
-                _spriteRenderer.sortingOrder = DynamicSortingOrderOverride ?? localToMatch.sortingOrder;
+                _spriteRenderer.sortingOrder =
+                    DynamicSortingOrderOverride ?? localToMatch.sortingOrder;
             }
 
             _spriteRenderer.size = localToMatch.size;
@@ -95,4 +97,4 @@
             return _cachedSpriteRenderer;
         }
     }
-}
+}

package/Runtime/Utils/TextureScale.cs

@@ -38,7 +38,12 @@
             ThreadedScale(tex, newWidth, newHeight, true);
         }
 
-        private static void ThreadedScale(Texture2D tex, int newWidth, int newHeight, bool useBilinear)
+        private static void ThreadedScale(
+            Texture2D tex,
+            int newWidth,
+            int newHeight,
+            bool useBilinear
+        )
         {
             texColors = tex.GetPixels();
             newColors = new Color[newWidth * newHeight];
@@ -123,9 +128,18 @@
                     int xFloor = (int)Mathf.Floor(x * ratioX);
                     float xLerp = x * ratioX - xFloor;
                     newColors[yw + x] = ColorLerpUnclamped(
-                        ColorLerpUnclamped(texColors[y1 + xFloor], texColors[y1 + xFloor + 1], xLerp),
-                        ColorLerpUnclamped(texColors[y2 + xFloor], texColors[y2 + xFloor + 1], xLerp),
-                        y * ratioY - yFloor);
+                        ColorLerpUnclamped(
+                            texColors[y1 + xFloor],
+                            texColors[y1 + xFloor + 1],
+                            xLerp
+                        ),
+                        ColorLerpUnclamped(
+                            texColors[y2 + xFloor],
+                            texColors[y2 + xFloor + 1],
+                            xLerp
+                        ),
+                        y * ratioY - yFloor
+                    );
                 }
             }
 
@@ -158,7 +172,8 @@
                 c1.r + (c2.r - c1.r) * value,
                 c1.g + (c2.g - c1.g) * value,
                 c1.b + (c2.b - c1.b) * value,
-                c1.a + (c2.a - c1.a) * value);
+                c1.a + (c2.a - c1.a) * value
+            );
         }
     }
-}
+}

package/Tests/Runtime/DataStructures/BalancedKDTreeTests.cs

@@ -1,8 +1,8 @@
 namespace UnityHelpers.Tests.DataStructures
 {
     using System.Collections.Generic;
-    using UnityEngine;
     using Core.DataStructure;
+    using UnityEngine;
 
     public sealed class BalancedKDTreeTests : SpatialTreeTests<KDTree<Vector2>>
     {

package/Tests/Runtime/DataStructures/CyclicBufferTests.cs

@@ -0,0 +1,101 @@
+namespace UnityHelpers.Tests.DataStructures
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using Core.DataStructure;
+    using Core.Random;
+    using NUnit.Framework;
+
+    public sealed class CyclicBufferTests
+    {
+        private const int NumTries = 100;
+        private const int CapacityMultiplier = 3;
+
+        [Test]
+        public void InvalidCapacity()
+        {
+            Assert.Throws<ArgumentException>(() => new CyclicBuffer<int>(-1));
+            Assert.Throws<ArgumentException>(() => new CyclicBuffer<int>(int.MinValue));
+            for (int i = 0; i < NumTries; i++)
+            {
+                Assert.Throws<ArgumentException>(
+                    () => new CyclicBuffer<int>(PRNG.Instance.Next(int.MinValue, -1))
+                );
+            }
+        }
+
+        [Test]
+        public void ZeroCapacityOk()
+        {
+            CyclicBuffer<int> buffer = new(0);
+            CollectionAssert.AreEquivalent(Array.Empty<int>(), buffer);
+            for (int i = 0; i < NumTries; ++i)
+            {
+                buffer.Add(PRNG.Instance.Next());
+                CollectionAssert.AreEquivalent(Array.Empty<int>(), buffer);
+            }
+        }
+
+        [Test]
+        public void IntMaxCapacityOk()
+        {
+            CyclicBuffer<int> buffer = new(int.MaxValue);
+            CollectionAssert.AreEquivalent(Array.Empty<int>(), buffer);
+            const int tries = 50;
+            List<int> expected = new(tries);
+            for (int i = 0; i < tries; ++i)
+            {
+                int value = PRNG.Instance.Next();
+                buffer.Add(value);
+                expected.Add(value);
+                CollectionAssert.AreEquivalent(expected, buffer);
+            }
+        }
+
+        [Test]
+        public void OneCapacityOk()
+        {
+            CyclicBuffer<int> buffer = new(1);
+            CollectionAssert.AreEquivalent(Array.Empty<int>(), buffer);
+            int[] expected = new int[1];
+            for (int i = 0; i < NumTries; ++i)
+            {
+                int value = PRNG.Instance.Next();
+                buffer.Add(value);
+                expected[0] = value;
+                CollectionAssert.AreEquivalent(expected, buffer);
+            }
+        }
+
+        [Test]
+        public void NormalAndWrappingBehavior()
+        {
+            List<int> expected = new();
+            for (int i = 0; i < NumTries; ++i)
+            {
+                int capacity = PRNG.Instance.Next(100, 1_000);
+                CyclicBuffer<int> buffer = new(capacity);
+                CollectionAssert.AreEquivalent(Array.Empty<int>(), buffer);
+                expected.Clear();
+                for (int j = 0; j < capacity * CapacityMultiplier; ++j)
+                {
+                    int newValue = PRNG.Instance.Next();
+                    if (capacity <= j)
+                    {
+                        expected[j % capacity] = newValue;
+                    }
+                    else
+                    {
+                        expected.Add(newValue);
+                    }
+                    buffer.Add(newValue);
+                    Assert.IsTrue(
+                        expected.SequenceEqual(buffer),
+                        $"Failure at iteration {i}, j={j}, capacity={capacity}, capacityMultiplier={CapacityMultiplier}"
+                    );
+                }
+            }
+        }
+    }
+}

package/Tests/Runtime/DataStructures/CyclicBufferTests.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: e6e1c3d02ef74aabb922aa776a8648f0
+timeCreated: 1740364919

package/Tests/Runtime/DataStructures/QuadTreeTests.cs

@@ -1,8 +1,8 @@
 namespace UnityHelpers.Tests.DataStructures
 {
     using System.Collections.Generic;
-    using UnityEngine;
     using Core.DataStructure;
+    using UnityEngine;
 
     public sealed class QuadTreeTests : SpatialTreeTests<QuadTree<Vector2>>
     {

package/Tests/Runtime/DataStructures/UnbalancedKDTreeTests.cs

@@ -1,8 +1,8 @@
 namespace UnityHelpers.Tests.DataStructures
 {
     using System.Collections.Generic;
-    using UnityEngine;
     using Core.DataStructure;
+    using UnityEngine;
 
     public sealed class UnbalancedKDTreeTests : SpatialTreeTests<KDTree<Vector2>>
     {