com.wallstop-studios.unity-helpers 2.0.0-rc45 → 2.0.0-rc47

package/Runtime/Core/DataStructure/CyclicBuffer.cs

@@ -12,7 +12,6 @@
     {
         public int Capacity { get; private set; }
         public int Count { get; private set; }
-        public bool IsReadOnly => false;
 
         private readonly List<T> _buffer;
         private int _position;
@@ -52,7 +51,7 @@
         {
             for (int i = 0; i < Count; ++i)
             {
-                // No need for bounds check, we're safe
+                // No need for bound check, we're safe
                 yield return _buffer[AdjustedIndexFor(i)];
             }
         }
@@ -87,7 +86,6 @@
 
         public void Clear()
         {
-            /* Simply reset state */
             Count = 0;
             _position = 0;
             _buffer.Clear();

package/Runtime/Core/DataStructure/KDTree.cs

@@ -272,19 +272,21 @@
                 }
             }
 
-            nearestNeighbors.AddRange(nearestNeighborsSet);
+            foreach (T element in nearestNeighborsSet)
+            {
+                nearestNeighbors.Add(element);
+            }
             if (count < nearestNeighbors.Count)
             {
+                Vector2 localPosition = position;
                 nearestNeighbors.Sort(NearestComparison);
                 nearestNeighbors.RemoveRange(count, nearestNeighbors.Count - count);
-            }
 
-            return;
-
-            int NearestComparison(T lhs, T rhs) =>
-                (_elementTransformer(lhs) - position).sqrMagnitude.CompareTo(
-                    (_elementTransformer(rhs) - position).sqrMagnitude
-                );
+                int NearestComparison(T lhs, T rhs) =>
+                    (_elementTransformer(lhs) - localPosition).sqrMagnitude.CompareTo(
+                        (_elementTransformer(rhs) - localPosition).sqrMagnitude
+                    );
+            }
         }
     }
 }

package/Runtime/Core/DataStructure/QuadTree.cs

@@ -231,11 +231,15 @@
             HashSet<T> nearestNeighborsSet = nearestNeighborBuffer ?? new HashSet<T>(count);
             nearestNeighborsSet.Clear();
 
+            Comparison<QuadTreeNode<T>> comparison = Comparison;
             while (!current.isTerminal)
             {
                 childrenCopy.Clear();
-                childrenCopy.AddRange(current.children);
-                childrenCopy.Sort(Comparison);
+                foreach (QuadTreeNode<T> child in current.children)
+                {
+                    childrenCopy.Add(child);
+                }
+                childrenCopy.Sort(comparison);
                 for (int i = childrenCopy.Count - 1; 0 <= i; --i)
                 {
                     stack.Push(childrenCopy[i]);
@@ -256,11 +260,20 @@
                 }
             }
 
-            nearestNeighbors.AddRange(nearestNeighborsSet);
+            foreach (T element in nearestNeighborsSet)
+            {
+                nearestNeighbors.Add(element);
+            }
             if (count < nearestNeighbors.Count)
             {
+                Vector2 localPosition = position;
                 nearestNeighbors.Sort(NearestComparison);
                 nearestNeighbors.RemoveRange(count, nearestNeighbors.Count - count);
+
+                int NearestComparison(T lhs, T rhs) =>
+                    (_elementTransformer(lhs) - localPosition).sqrMagnitude.CompareTo(
+                        (_elementTransformer(rhs) - localPosition).sqrMagnitude
+                    );
             }
 
             return;
@@ -269,11 +282,6 @@
                 ((Vector2)lhs.boundary.center - position).sqrMagnitude.CompareTo(
                     ((Vector2)rhs.boundary.center - position).sqrMagnitude
                 );
-
-            int NearestComparison(T lhs, T rhs) =>
-                (_elementTransformer(lhs) - position).sqrMagnitude.CompareTo(
-                    (_elementTransformer(rhs) - position).sqrMagnitude
-                );
         }
     }
 }

package/Runtime/Core/DataStructure/RTree.cs

@@ -288,11 +288,15 @@
             HashSet<T> nearestNeighborsSet = nearestNeighborsBuffer ?? new HashSet<T>(count);
             nearestNeighborsSet.Clear();
 
+            Comparison<RTreeNode<T>> comparison = Comparison;
             while (!current.isTerminal)
             {
                 childrenCopy.Clear();
-                childrenCopy.AddRange(current.children);
-                childrenCopy.Sort(Comparison);
+                foreach (RTreeNode<T> child in current.children)
+                {
+                    childrenCopy.Add(child);
+                }
+                childrenCopy.Sort(comparison);
                 for (int i = childrenCopy.Count - 1; 0 <= i; --i)
                 {
                     stack.Push(childrenCopy[i]);
@@ -313,11 +317,22 @@
                 }
             }
 
-            nearestNeighbors.AddRange(nearestNeighborsSet);
+            foreach (T element in nearestNeighborsSet)
+            {
+                nearestNeighbors.Add(element);
+            }
             if (count < nearestNeighbors.Count)
             {
+                Vector2 localPosition = position;
                 nearestNeighbors.Sort(NearestComparison);
                 nearestNeighbors.RemoveRange(count, nearestNeighbors.Count - count);
+
+                int NearestComparison(T lhs, T rhs) =>
+                    (
+                        (Vector2)_elementTransformer(lhs).center - localPosition
+                    ).sqrMagnitude.CompareTo(
+                        ((Vector2)_elementTransformer(rhs).center - localPosition).sqrMagnitude
+                    );
             }
 
             return;
@@ -326,11 +341,6 @@
                 ((Vector2)lhs.boundary.center - position).sqrMagnitude.CompareTo(
                     ((Vector2)rhs.boundary.center - position).sqrMagnitude
                 );
-
-            int NearestComparison(T lhs, T rhs) =>
-                ((Vector2)_elementTransformer(lhs).center - position).sqrMagnitude.CompareTo(
-                    ((Vector2)_elementTransformer(rhs).center - position).sqrMagnitude
-                );
         }
     }
 }

package/Runtime/Core/DataStructure/StringWrapper.cs

@@ -19,7 +19,7 @@
         private StringWrapper(string value)
         {
             this.value = value;
-            _hashCode = value?.GetHashCode() ?? 0;
+            _hashCode = value.GetHashCode();
         }
 
         public static StringWrapper Get(string value)
@@ -27,9 +27,9 @@
             return Cache.GetOrAdd(value, key => new StringWrapper(key));
         }
 
-        public static void Remove(string value)
+        public static bool Remove(string value)
         {
-            _ = Cache.TryRemove(value, out _);
+            return Cache.TryRemove(value, out _);
         }
 
         public bool Equals(StringWrapper other)
@@ -49,7 +49,7 @@
                 return false;
             }
 
-            return string.Equals(value, other.value);
+            return string.Equals(value, other.value, StringComparison.Ordinal);
         }
 
         public int CompareTo(StringWrapper other)

package/Runtime/Core/DataStructure/TimedCache.cs

@@ -11,10 +11,23 @@
         {
             get
             {
-                if (!_lastRead.HasValue || Helpers.HasEnoughTimePassed(_lastRead.Value, _cacheTtl))
+                if (!_lastRead.HasValue)
                 {
                     Reset();
                 }
+                else if (
+                    Helpers.HasEnoughTimePassed(
+                        _lastRead.Value,
+                        _cacheTtl + (_shouldUseJitter && !_usedJitter ? _jitterAmount : 0f)
+                    )
+                )
+                {
+                    if (_shouldUseJitter)
+                    {
+                        _usedJitter = true;
+                    }
+                    Reset();
+                }
 
                 return _value;
             }
@@ -26,6 +39,10 @@
         private float? _lastRead;
         private T _value;
 
+        private bool _usedJitter;
+        private readonly bool _shouldUseJitter;
+        private readonly float _jitterAmount;
+
         public TimedCache(Func<T> valueProducer, float cacheTtl, bool useJitter = false)
         {
             _valueProducer =
@@ -36,10 +53,8 @@
             }
 
             _cacheTtl = cacheTtl;
-            if (useJitter && 0 < _cacheTtl)
-            {
-                _cacheTtl += PRNG.Instance.NextFloat(_cacheTtl);
-            }
+            _shouldUseJitter = useJitter;
+            _jitterAmount = useJitter ? PRNG.Instance.NextFloat(0f, cacheTtl) : 0f;
         }
 
         public void Reset()

package/Runtime/Core/Extension/EnumExtensions.cs

@@ -0,0 +1,37 @@
+namespace UnityHelpers.Core.Extension
+{
+    using System;
+    using System.Runtime.CompilerServices;
+
+    public static class EnumExtensions
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool HasFlagNoAlloc<T>(this T value, T flag)
+            where T : unmanaged, Enum
+        {
+            ulong valueUnderlying = GetUInt64(value);
+            ulong flagUnderlying = GetUInt64(flag);
+            return (valueUnderlying & flagUnderlying) == flagUnderlying;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static unsafe ulong GetUInt64<T>(T value)
+            where T : unmanaged
+        {
+            /*
+                Works because T is constrained to unmanaged, so it's safe to reinterpret
+                All enums are value types and have a fixed size
+             */
+            return sizeof(T) switch
+            {
+                1 => *(byte*)&value,
+                2 => *(ushort*)&value,
+                4 => *(uint*)&value,
+                8 => *(ulong*)&value,
+                _ => throw new ArgumentException(
+                    $"Unsupported enum size: {sizeof(T)} for type {typeof(T)}"
+                ),
+            };
+        }
+    }
+}

package/Runtime/Core/Extension/EnumExtensions.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: cb447d880798449cb844f63991aac81b
+timeCreated: 1742771382

package/Runtime/Core/Extension/IListExtensions.cs

@@ -85,5 +85,22 @@
             list[index] = last;
             list.RemoveAt(lastIndex);
         }
+
+        public static void InsertionSort<T, TComparer>(this IList<T> array, TComparer comparer)
+            where TComparer : struct, IComparer<T>
+        {
+            int arrayCount = array.Count;
+            for (int i = 1; i < arrayCount; ++i)
+            {
+                T key = array[i];
+                int j = i - 1;
+                while (j >= 0 && comparer.Compare(array[j], key) > 0)
+                {
+                    array[j + 1] = array[j];
+                    j--;
+                }
+                array[j + 1] = key;
+            }
+        }
     }
 }

package/Runtime/Utils/RuntimeSingleton.cs

@@ -45,12 +45,20 @@
 
         protected virtual void Start()
         {
-            if (_instance != null && _instance != this)
+            if (_instance == null || _instance == this)
             {
-                this.LogError(
-                    $"Double singleton detected, {_instance.name} conflicts with {name}."
-                );
-                gameObject.Destroy();
+                return;
+            }
+
+            this.LogError($"Double singleton detected, {_instance.name} conflicts with {name}.");
+            gameObject.Destroy();
+        }
+
+        protected virtual void OnDestroy()
+        {
+            if (_instance == this)
+            {
+                _instance = null;
             }
         }
     }

package/Tests/Runtime/Extensions/EnumExtensionTests.cs

@@ -0,0 +1,128 @@
+namespace UnityHelpers.Tests.Extensions
+{
+    using Core.Extension;
+    using NUnit.Framework;
+    using UnityEngine.TestTools.Constraints;
+    using Is = NUnit.Framework.Is;
+
+    public sealed class EnumExtensionTests
+    {
+        private enum TestEnum
+        {
+            None = 0,
+            First = 1 << 0,
+            Second = 1 << 1,
+            Third = 1 << 2,
+        }
+
+        private enum TinyTestEnum : byte
+        {
+            None = 0,
+            First = 1 << 0,
+            Second = 1 << 1,
+            Third = 1 << 2,
+        }
+
+        private enum SmallTestEnum : short
+        {
+            None = 0,
+            First = 1 << 0,
+            Second = 1 << 1,
+            Third = 1 << 2,
+        }
+
+        private enum BigTestEnum : long
+        {
+            None = 0,
+            First = 1 << 0,
+            Second = 1 << 1,
+            Third = 1 << 2,
+        }
+
+        [Test]
+        public void HasFlagNoAlloc()
+        {
+            Assert.IsTrue(TestEnum.First.HasFlagNoAlloc(TestEnum.First));
+            Assert.IsFalse(TestEnum.First.HasFlagNoAlloc(TestEnum.Second));
+            Assert.IsTrue((TestEnum.First | TestEnum.Second).HasFlagNoAlloc(TestEnum.First));
+            Assert.IsTrue((TestEnum.First | TestEnum.Second).HasFlagNoAlloc(TestEnum.Second));
+            Assert.IsFalse((TestEnum.First | TestEnum.Second).HasFlagNoAlloc(TestEnum.Third));
+            Assert.IsFalse(TestEnum.First.HasFlagNoAlloc((TestEnum.First | TestEnum.Second)));
+        }
+
+        [Test]
+        public void HasFlagNoAllocTiny()
+        {
+            Assert.IsTrue(TinyTestEnum.First.HasFlagNoAlloc(TinyTestEnum.First));
+            Assert.IsFalse(TinyTestEnum.First.HasFlagNoAlloc(TinyTestEnum.Second));
+            Assert.IsTrue(
+                (TinyTestEnum.First | TinyTestEnum.Second).HasFlagNoAlloc(TinyTestEnum.First)
+            );
+            Assert.IsTrue(
+                (TinyTestEnum.First | TinyTestEnum.Second).HasFlagNoAlloc(TinyTestEnum.Second)
+            );
+            Assert.IsFalse(
+                (TinyTestEnum.First | TinyTestEnum.Second).HasFlagNoAlloc(TinyTestEnum.Third)
+            );
+            Assert.IsFalse(
+                TinyTestEnum.First.HasFlagNoAlloc((TinyTestEnum.First | TinyTestEnum.Second))
+            );
+        }
+
+        [Test]
+        public void HasFlagNoAllocSmall()
+        {
+            Assert.IsTrue(SmallTestEnum.First.HasFlagNoAlloc(SmallTestEnum.First));
+            Assert.IsFalse(SmallTestEnum.First.HasFlagNoAlloc(SmallTestEnum.Second));
+            Assert.IsTrue(
+                (SmallTestEnum.First | SmallTestEnum.Second).HasFlagNoAlloc(SmallTestEnum.First)
+            );
+            Assert.IsTrue(
+                (SmallTestEnum.First | SmallTestEnum.Second).HasFlagNoAlloc(SmallTestEnum.Second)
+            );
+            Assert.IsFalse(
+                (SmallTestEnum.First | SmallTestEnum.Second).HasFlagNoAlloc(SmallTestEnum.Third)
+            );
+            Assert.IsFalse(
+                SmallTestEnum.First.HasFlagNoAlloc((SmallTestEnum.First | SmallTestEnum.Second))
+            );
+        }
+
+        [Test]
+        public void HasFlagNoAllocBig()
+        {
+            Assert.IsTrue(BigTestEnum.First.HasFlagNoAlloc(BigTestEnum.First));
+            Assert.IsFalse(BigTestEnum.First.HasFlagNoAlloc(BigTestEnum.Second));
+            Assert.IsTrue(
+                (BigTestEnum.First | BigTestEnum.Second).HasFlagNoAlloc(BigTestEnum.First)
+            );
+            Assert.IsTrue(
+                (BigTestEnum.First | BigTestEnum.Second).HasFlagNoAlloc(BigTestEnum.Second)
+            );
+            Assert.IsFalse(
+                (BigTestEnum.First | BigTestEnum.Second).HasFlagNoAlloc(BigTestEnum.Third)
+            );
+            Assert.IsFalse(
+                BigTestEnum.First.HasFlagNoAlloc((BigTestEnum.First | BigTestEnum.Second))
+            );
+        }
+
+        [Test]
+        public void HasFlagsNoAllocDoesNotAlloc()
+        {
+            Assert.That(
+                () =>
+                {
+                    TestEnum.First.HasFlagNoAlloc(TestEnum.First);
+                    TinyTestEnum.First.HasFlagNoAlloc(TinyTestEnum.First);
+                    BigTestEnum.First.HasFlagNoAlloc(BigTestEnum.First);
+
+                    TestEnum.First.HasFlagNoAlloc(TestEnum.Second);
+                    TinyTestEnum.First.HasFlagNoAlloc(TinyTestEnum.Second);
+                    BigTestEnum.First.HasFlagNoAlloc(BigTestEnum.Second);
+                },
+                Is.Not.AllocatingGCMemory()
+            );
+        }
+    }
+}

package/Tests/Runtime/Extensions/EnumExtensionTests.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 08e6640512474d02bc94651af90a6ffd
+timeCreated: 1742771579

package/Tests/Runtime/Extensions/IListExtensionTests.cs

@@ -1,12 +1,21 @@
 namespace UnityHelpers.Tests.Extensions
 {
     using System;
+    using System.Collections.Generic;
     using System.Linq;
     using Core.Extension;
+    using Core.Random;
     using NUnit.Framework;
 
     public sealed class IListExtensionTests
     {
+        private const int NumTries = 1_000;
+
+        private readonly struct IntComparer : IComparer<int>
+        {
+            public int Compare(int x, int y) => x.CompareTo(y);
+        }
+
         [Test]
         public void ShiftLeft()
         {
@@ -72,5 +81,24 @@
             Assert.Throws<ArgumentException>(() => input.Reverse(1, int.MaxValue));
             Assert.Throws<ArgumentException>(() => input.Reverse(1, int.MinValue));
         }
+
+        [Test]
+        public void InsertionSort()
+        {
+            for (int i = 0; i < NumTries; ++i)
+            {
+                int[] input = Enumerable
+                    .Range(0, 100)
+                    .Select(_ => PRNG.Instance.Next(int.MinValue, int.MaxValue))
+                    .ToArray();
+                int[] conventionalSorted = input.ToArray();
+                Array.Sort(conventionalSorted);
+
+                int[] insertionSorted = input.ToArray();
+                insertionSorted.InsertionSort(new IntComparer());
+                Assert.That(conventionalSorted, Is.EqualTo(insertionSorted));
+                Assert.That(input.OrderBy(x => x), Is.EqualTo(insertionSorted));
+            }
+        }
     }
 }

package/package.json

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