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

package/README.md

@@ -1,2 +1,12 @@
 # A Grab-Bag
 Various Unity Helpers. Includes many deterministic, seedable random number generators.
+
+# To Install as Unity Package
+1. Open Unity Package Manager
+2. (Optional) Enable Pre-release packages to get the latest, cutting-edge builds
+3. Open the Advanced Package Settings
+4. Add an entry for a new "Scoped Registry"
+    - Name: `NPM`
+    - URL: `https://registry.npmjs.org`
+    - Scope(s): `com.wallstop-studios.unity-helpers`
+5. Resolve the latest `com.wallstop-studios.unity-helpers`

package/Runtime/Core/DataStructure/CyclicBuffer.cs

@@ -4,13 +4,15 @@
     using System.Collections;
     using System.Collections.Generic;
     using System.Linq;
+    using Extension;
     using Helper;
 
     [Serializable]
     public sealed class CyclicBuffer<T> : IReadOnlyList<T>
     {
+        public int Capacity { get; private set; }
         public int Count { get; private set; }
-        public readonly int capacity;
+        public bool IsReadOnly => false;
 
         private readonly List<T> _buffer;
         private int _position;
@@ -36,7 +38,7 @@
                 throw new ArgumentException(nameof(capacity));
             }
 
-            this.capacity = capacity;
+            Capacity = capacity;
             _position = 0;
             Count = 0;
             _buffer = new List<T>();
@@ -62,7 +64,7 @@
 
         public void Add(T item)
         {
-            if (capacity == 0)
+            if (Capacity == 0)
             {
                 return;
             }
@@ -76,8 +78,8 @@
                 _buffer.Add(item);
             }
 
-            _position = _position.WrappedIncrement(capacity);
-            if (Count < capacity)
+            _position = _position.WrappedIncrement(Capacity);
+            if (Count < Capacity)
             {
                 ++Count;
             }
@@ -88,28 +90,46 @@
             /* Simply reset state */
             Count = 0;
             _position = 0;
+            _buffer.Clear();
         }
 
-        public bool Peek(out T value)
+        public void Resize(int newCapacity)
         {
-            const int firstIndex = 0;
-            if (InBounds(firstIndex))
+            if (newCapacity < 0)
             {
-                value = _buffer[AdjustedIndexFor(firstIndex)];
-                return true;
+                throw new ArgumentException(nameof(newCapacity));
             }
 
-            value = default;
-            return false;
+            Capacity = newCapacity;
+            _buffer.Shift(-_position);
+            if (newCapacity < _buffer.Count)
+            {
+                _buffer.RemoveRange(newCapacity, _buffer.Count - newCapacity);
+                _position = 0;
+            }
+
+            Count = Math.Min(newCapacity, Count);
+        }
+
+        public bool Contains(T item)
+        {
+            return _buffer.Contains(item);
         }
 
         private int AdjustedIndexFor(int index)
         {
-            if (index < _buffer.Count)
+            long longCapacity = Capacity;
+            if (longCapacity == 0L)
+            {
+                return 0;
+            }
+            unchecked
             {
-                return index;
+                int adjustedIndex = (int)(
+                    (_position - 1L + longCapacity - (_buffer.Count - 1 - index)) % longCapacity
+                );
+                return adjustedIndex;
             }
-            return (_position - 1 + capacity - index) % capacity;
         }
 
         private void BoundsCheck(int index)

package/Runtime/Core/DataStructure/StringWrapper.cs

@@ -7,6 +7,7 @@
         Used to cache strings, meant to be used in place of strings as keys for when a Dictionary
         has a known set of values
      */
+    [Serializable]
     public sealed class StringWrapper : IEquatable<StringWrapper>, IComparable<StringWrapper>
     {
         private static readonly ConcurrentDictionary<string, StringWrapper> Cache = new();

package/Runtime/Core/Extension/IListExtensions.cs

@@ -1,6 +1,7 @@
 namespace UnityHelpers.Core.Extension
 {
     using System.Collections.Generic;
+    using Helper;
     using Random;
 
     public static class IListExtensions
@@ -26,6 +27,35 @@
             }
         }
 
+        public static void Shift<T>(this IList<T> list, int amount)
+        {
+            int count = list.Count;
+            if (count <= 1)
+            {
+                return;
+            }
+
+            amount = amount.PositiveMod(count);
+            if (amount == 0)
+            {
+                return;
+            }
+
+            Reverse(list, 0, count - 1);
+            Reverse(list, 0, amount - 1);
+            Reverse(list, amount, count - 1);
+        }
+
+        public static void Reverse<T>(this IList<T> list, int start, int end)
+        {
+            while (start < end)
+            {
+                (list[start], list[end]) = (list[end], list[start]);
+                start++;
+                end--;
+            }
+        }
+
         public static void RemoveAtSwapBack<T>(this IList<T> list, int index)
         {
             if (list.Count <= 1)

package/Runtime/Core/Helper/WallMath.cs

@@ -31,6 +31,34 @@
                 );
         }
 
+        public static float PositiveMod(this float value, float max)
+        {
+            value %= max;
+            value += max;
+            return value % max;
+        }
+
+        public static double PositiveMod(this double value, double max)
+        {
+            value %= max;
+            value += max;
+            return value % max;
+        }
+
+        public static int PositiveMod(this int value, int max)
+        {
+            value %= max;
+            value += max;
+            return value % max;
+        }
+
+        public static long PositiveMod(this long value, long max)
+        {
+            value %= max;
+            value += max;
+            return value % max;
+        }
+
         public static int WrappedAdd(this int value, int increment, int max)
         {
             WrappedAdd(ref value, increment, max);

package/Tests/Runtime/DataStructures/CyclicBufferTests.cs

@@ -25,6 +25,28 @@
             }
         }
 
+        [Test]
+        public void CapacityInitializedOk()
+        {
+            for (int i = 0; i < NumTries; i++)
+            {
+                int capacity = PRNG.Instance.Next(1, int.MaxValue);
+                CyclicBuffer<int> buffer = new(capacity);
+                Assert.AreEqual(capacity, buffer.Capacity);
+            }
+        }
+
+        [Test]
+        public void CountInitializedOk()
+        {
+            for (int i = 0; i < NumTries; i++)
+            {
+                int capacity = PRNG.Instance.Next(1, int.MaxValue);
+                CyclicBuffer<int> buffer = new(capacity);
+                Assert.AreEqual(0, buffer.Count);
+            }
+        }
+
         [Test]
         public void ZeroCapacityOk()
         {
@@ -49,7 +71,14 @@
                 int value = PRNG.Instance.Next();
                 buffer.Add(value);
                 expected.Add(value);
-                CollectionAssert.AreEquivalent(expected, buffer);
+                if (!expected.SequenceEqual(buffer))
+                {
+                    Assert.Fail(
+                        $"Failure at iteration {i}, capacity={buffer.Capacity}, "
+                            + $"capacityMultiplier={CapacityMultiplier}\n"
+                            + $"Expected: [{string.Join(",", expected)}], Actual: [{string.Join(",", buffer)}]"
+                    );
+                }
             }
         }
 
@@ -68,10 +97,58 @@
             }
         }
 
+        [Test]
+        public void InitialElementsVariableSize()
+        {
+            for (int i = 0; i < NumTries; ++i)
+            {
+                int capacity = PRNG.Instance.Next(100, 1_000);
+                int[] elements = Enumerable
+                    .Range(0, (int)(capacity * PRNG.Instance.NextFloat(0.5f, 1.5f)))
+                    .Select(_ => PRNG.Instance.Next())
+                    .ToArray();
+                CyclicBuffer<int> buffer = new(capacity, elements);
+                if (capacity < elements.Length)
+                {
+                    Assert.IsTrue(elements.Skip(elements.Length - capacity).SequenceEqual(buffer));
+                }
+                else
+                {
+                    Assert.IsTrue(elements.SequenceEqual(buffer));
+                }
+            }
+        }
+
+        [Test]
+        public void InitialElementsSizeSameAsCapacity()
+        {
+            for (int i = 0; i < NumTries; ++i)
+            {
+                int capacity = PRNG.Instance.Next(100, 1_000);
+                int[] elements = Enumerable
+                    .Range(0, capacity)
+                    .Select(_ => PRNG.Instance.Next())
+                    .ToArray();
+                CyclicBuffer<int> buffer = new(capacity, elements);
+                Assert.IsTrue(elements.SequenceEqual(buffer));
+            }
+        }
+
+        [Test]
+        public void InitialElementsEmptyInput()
+        {
+            for (int i = 0; i < NumTries; ++i)
+            {
+                int capacity = PRNG.Instance.Next(100, 1_000);
+                CyclicBuffer<int> buffer = new(capacity, Array.Empty<int>());
+                Assert.IsTrue(Array.Empty<int>().SequenceEqual(buffer));
+            }
+        }
+
         [Test]
         public void NormalAndWrappingBehavior()
         {
-            List<int> expected = new();
+            LinkedList<int> expected = new();
             for (int i = 0; i < NumTries; ++i)
             {
                 int capacity = PRNG.Instance.Next(100, 1_000);
@@ -81,20 +158,130 @@
                 for (int j = 0; j < capacity * CapacityMultiplier; ++j)
                 {
                     int newValue = PRNG.Instance.Next();
-                    if (capacity <= j)
+                    expected.AddLast(newValue);
+                    while (capacity < expected.Count)
                     {
-                        expected[j % capacity] = newValue;
+                        expected.RemoveFirst();
                     }
-                    else
+                    buffer.Add(newValue);
+                    Assert.AreEqual(expected.Count, buffer.Count);
+                    if (!expected.SequenceEqual(buffer))
                     {
-                        expected.Add(newValue);
+                        Assert.Fail(
+                            $"Failure at iteration {i}, j={j}, capacity={buffer.Capacity}, "
+                                + $"capacityMultiplier={CapacityMultiplier}\n"
+                                + $"Expected: [{string.Join(",", expected)}], Actual: [{string.Join(",", buffer)}]"
+                        );
                     }
-                    buffer.Add(newValue);
-                    Assert.IsTrue(
-                        expected.SequenceEqual(buffer),
-                        $"Failure at iteration {i}, j={j}, capacity={capacity}, capacityMultiplier={CapacityMultiplier}"
-                    );
                 }
+
+                foreach (int item in expected)
+                {
+                    Assert.IsTrue(buffer.Contains(item));
+                }
+
+                for (int j = 0; j < NumTries; ++j)
+                {
+                    Assert.IsFalse(buffer.Contains(PRNG.Instance.Next(int.MinValue, -1)));
+                }
+            }
+        }
+
+        [Test]
+        public void ClearOk()
+        {
+            HashSet<int> seen = new();
+            for (int i = 0; i < NumTries; ++i)
+            {
+                int capacity = PRNG.Instance.Next(100, 1_000);
+                CyclicBuffer<int> buffer = new(capacity);
+                float fillPercent = PRNG.Instance.NextFloat(0.5f, 1.5f);
+                seen.Clear();
+                for (int j = 0; j < capacity * fillPercent; ++j)
+                {
+                    int value = PRNG.Instance.Next();
+                    seen.Add(value);
+                    buffer.Add(value);
+                }
+
+                Assert.AreNotEqual(0, buffer.Count);
+                Assert.IsFalse(Array.Empty<int>().SequenceEqual(buffer));
+                buffer.Clear();
+
+                Assert.AreEqual(0, buffer.Count);
+                Assert.AreEqual(capacity, buffer.Capacity);
+                Assert.IsTrue(Array.Empty<int>().SequenceEqual(buffer));
+
+                // Make sure our data is actually cleaned up, none of our input data should be "Contained"
+                foreach (int value in seen)
+                {
+                    Assert.IsFalse(buffer.Contains(value));
+                }
+            }
+        }
+
+        [Test]
+        public void ResizeFullOk()
+        {
+            for (int i = 0; i < NumTries; ++i)
+            {
+                int capacity = PRNG.Instance.Next(100, 1_000);
+                CyclicBuffer<int> buffer = new(capacity);
+                float fillPercent = PRNG.Instance.NextFloat(1f, 2f);
+                float capacityPercent = PRNG.Instance.NextFloat(0.3f, 0.9f);
+                for (int j = 0; j < capacity * fillPercent; ++j)
+                {
+                    int value = PRNG.Instance.Next();
+                    buffer.Add(value);
+                }
+
+                int[] values = buffer.ToArray();
+
+                int newCapacity = Math.Max(0, (int)(capacity * capacityPercent));
+                buffer.Resize(newCapacity);
+                int[] newValues = buffer.ToArray();
+                Assert.AreEqual(newCapacity, buffer.Capacity);
+                Assert.AreEqual(newCapacity, newValues.Length);
+                Assert.That(values.Take(newCapacity), Is.EqualTo(newValues));
+
+                newCapacity = 0;
+                buffer.Resize(newCapacity);
+                newValues = buffer.ToArray();
+                Assert.AreEqual(newCapacity, buffer.Capacity);
+                Assert.AreEqual(newCapacity, newValues.Length);
+            }
+        }
+
+        [Test]
+        public void ResizePartialOk()
+        {
+            for (int i = 0; i < NumTries; ++i)
+            {
+                int capacity = PRNG.Instance.Next(100, 1_000);
+                CyclicBuffer<int> buffer = new(capacity);
+                float fillPercent = PRNG.Instance.NextFloat(0.3f, 0.9f);
+                float capacityPercent = PRNG.Instance.NextFloat(0.3f, 0.9f);
+                int filled = (int)(capacity * fillPercent);
+                for (int j = 0; j < filled; ++j)
+                {
+                    int value = PRNG.Instance.Next();
+                    buffer.Add(value);
+                }
+
+                int[] values = buffer.ToArray();
+
+                int newCapacity = Math.Max(0, (int)(capacity * capacityPercent));
+                buffer.Resize(newCapacity);
+                int[] newValues = buffer.ToArray();
+                Assert.AreEqual(newCapacity, buffer.Capacity);
+                Assert.AreEqual(Math.Min(filled, newCapacity), newValues.Length);
+                Assert.That(values.Take(newCapacity), Is.EqualTo(newValues));
+
+                newCapacity = 0;
+                buffer.Resize(newCapacity);
+                newValues = buffer.ToArray();
+                Assert.AreEqual(newCapacity, buffer.Capacity);
+                Assert.AreEqual(newCapacity, newValues.Length);
             }
         }
     }

package/Tests/Runtime/Helper/WallMathTests.cs

@@ -44,6 +44,19 @@
             }
         }
 
+        [Test]
+        public void PositiveMod()
+        {
+            Assert.AreEqual(9, (-1).PositiveMod(10));
+            Assert.AreEqual(1, 1.PositiveMod(10));
+            Assert.AreEqual(9f, (-1f).PositiveMod(10f));
+            Assert.AreEqual(1f, 1f.PositiveMod(10f));
+            Assert.AreEqual(9.0, (-1.0).PositiveMod(10.0));
+            Assert.AreEqual(1.0, 1.0.PositiveMod(10.0));
+            Assert.AreEqual(9L, (-1L).PositiveMod(10L));
+            Assert.AreEqual(1L, 1L.PositiveMod(10L));
+        }
+
         [Test]
         public void ApproximatelyExpected()
         {
@@ -51,7 +64,6 @@
             Assert.IsTrue(0f.Approximately(0.5f, 1f));
             Assert.IsFalse(0.001f.Approximately(0f, 0f));
             Assert.IsFalse(100f.Approximately(5f, 2.4f));
-
             Assert.IsTrue(0.001f.Approximately(0.0001f));
         }
 

package/package.json

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