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

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/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/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-rc46",
   "displayName": "Unity Helpers",
   "description": "Various Unity Helper Library",
   "dependencies": {},