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

package/Runtime/Core/DataStructure/Adapters/KGuid.cs

@@ -59,14 +59,20 @@
             return new KGuid(System.Guid.NewGuid());
         }
 
-        public KGuid(Guid guid) : this(guid.ToByteArray()) { }
+        public KGuid(Guid guid)
+            : this(guid.ToByteArray()) { }
 
         [JsonConstructor]
-        public KGuid(string guid) : this(System.Guid.Parse(guid)) { }
+        public KGuid(string guid)
+            : this(System.Guid.Parse(guid)) { }
 
         public KGuid(byte[] guidBytes)
         {
-            _a = (int)guidBytes[3] << 24 | (int)guidBytes[2] << 16 | (int)guidBytes[1] << 8 | (int)guidBytes[0];
+            _a =
+                (int)guidBytes[3] << 24
+                | (int)guidBytes[2] << 16
+                | (int)guidBytes[1] << 8
+                | (int)guidBytes[0];
             _b = (short)((int)guidBytes[5] << 8 | (int)guidBytes[4]);
             _c = (short)((int)guidBytes[7] << 8 | (int)guidBytes[6]);
             _d = guidBytes[8];
@@ -83,7 +89,18 @@
         public static implicit operator Guid(KGuid guid)
         {
             return new Guid(
-                guid._a, guid._b, guid._c, guid._d, guid._e, guid._f, guid._g, guid._h, guid._i, guid._j, guid._k);
+                guid._a,
+                guid._b,
+                guid._c,
+                guid._d,
+                guid._e,
+                guid._f,
+                guid._g,
+                guid._h,
+                guid._i,
+                guid._j,
+                guid._k
+            );
         }
 
         public static implicit operator KGuid(Guid guid)
@@ -237,7 +254,7 @@
             {
                 KGuid otherKGuid => Equals(otherKGuid),
                 Guid otherGuid => Equals(otherGuid),
-                _ => false
+                _ => false,
             };
         }
 
@@ -275,7 +292,7 @@
                 _h,
                 _i,
                 _j,
-                _k
+                _k,
             };
         }
 
@@ -285,4 +302,4 @@
             _hashCode = 0;
         }
     }
-}
+}

package/Runtime/Core/DataStructure/Adapters/KVector2.cs

@@ -14,6 +14,7 @@
         [DataMember]
         [ProtoMember(1)]
         public float x;
+
         [DataMember]
         [ProtoMember(2)]
         public float y;

package/Runtime/Core/DataStructure/Circle.cs

@@ -3,7 +3,7 @@
     using System;
     using Extension;
     using UnityEngine;
-    
+
     public readonly struct Circle
     {
         public readonly Vector2 center;

package/Runtime/Core/DataStructure/CyclicBuffer.cs

@@ -1,31 +1,19 @@
 namespace UnityHelpers.Core.DataStructure
 {
-    using Helper;
     using System;
     using System.Collections;
     using System.Collections.Generic;
-    using System.ComponentModel;
-
-    public enum BufferAddMethod
-    {
-        Prepend,
-        Append
-    }
+    using System.Linq;
+    using Helper;
 
     [Serializable]
-    public sealed class CyclicBuffer<T> : IEnumerable<T>
+    public sealed class CyclicBuffer<T> : IReadOnlyList<T>
     {
-        private readonly T[] _buffer;
-
-        private int _position;
-
-        public readonly BufferAddMethod AddMethod;
-
-        public readonly int Capacity;
-
         public int Count { get; private set; }
+        public readonly int capacity;
 
-        public readonly bool IsReadOnly;
+        private readonly List<T> _buffer;
+        private int _position;
 
         public T this[int index]
         {
@@ -41,24 +29,29 @@
             }
         }
 
-        public CyclicBuffer(int capacity, BufferAddMethod addMethod = BufferAddMethod.Prepend)
+        public CyclicBuffer(int capacity, IEnumerable<T> initialContents = null)
         {
             if (capacity < 0)
             {
                 throw new ArgumentException(nameof(capacity));
             }
-            AddMethod = addMethod;
-            Capacity = capacity;
+
+            this.capacity = capacity;
             _position = 0;
-            _buffer = new T[capacity];
-            IsReadOnly = false;
+            Count = 0;
+            _buffer = new List<T>();
+            foreach (T item in initialContents ?? Enumerable.Empty<T>())
+            {
+                Add(item);
+            }
         }
 
         public IEnumerator<T> GetEnumerator()
         {
             for (int i = 0; i < Count; ++i)
             {
-                yield return this[i];
+                // No need for bounds check, we're safe
+                yield return _buffer[AdjustedIndexFor(i)];
             }
         }
 
@@ -69,9 +62,22 @@
 
         public void Add(T item)
         {
-            _buffer[_position] = item;
-            _position = WallMath.WrappedIncrement(_position, Capacity);
-            if (Count < Capacity)
+            if (capacity == 0)
+            {
+                return;
+            }
+
+            if (_position < _buffer.Count)
+            {
+                _buffer[_position] = item;
+            }
+            else
+            {
+                _buffer.Add(item);
+            }
+
+            _position = _position.WrappedIncrement(capacity);
+            if (Count < capacity)
             {
                 ++Count;
             }
@@ -86,32 +92,24 @@
 
         public bool Peek(out T value)
         {
-            if (InBounds(0))
+            const int firstIndex = 0;
+            if (InBounds(firstIndex))
             {
-                value = this[0];
+                value = _buffer[AdjustedIndexFor(firstIndex)];
                 return true;
             }
-            value = default(T);
+
+            value = default;
             return false;
         }
 
         private int AdjustedIndexFor(int index)
         {
-            switch (AddMethod)
+            if (index < _buffer.Count)
             {
-                case BufferAddMethod.Prepend:
-                    {
-                        return (_position - 1 + Capacity - index) % Capacity;
-                    }
-                case BufferAddMethod.Append:
-                    {
-                        return index;
-                    }
-                default:
-                    {
-                        throw new InvalidEnumArgumentException("Unexpected AddMethod: " + AddMethod);
-                    }
+                return index;
             }
+            return (_position - 1 + capacity - index) % capacity;
         }
 
         private void BoundsCheck(int index)
@@ -124,7 +122,7 @@
 
         private bool InBounds(int index)
         {
-            return !(Count <= index || index < 0);
+            return 0 <= index && index < Count;
         }
     }
 }

package/Runtime/Core/DataStructure/ISpatialTree.cs

@@ -20,35 +20,37 @@
                 return GetElementsInBounds(
                         new Bounds(
                             new Vector3(position.x, position.y, 0f),
-                            new Vector3(range * 2f, range * 2f, 1f)))
-                    .Where(
-                        element =>
+                            new Vector3(range * 2f, range * 2f, 1f)
+                        )
+                    )
+                    .Where(element =>
+                    {
+                        Vector2 elementPosition = elementTransformer(element);
+                        if (!area.Contains(elementPosition))
                         {
-                            Vector2 elementPosition = elementTransformer(element);
-                            if (!area.Contains(elementPosition))
-                            {
-                                return false;
-                            }
+                            return false;
+                        }
 
-                            return !minimumArea.Contains(elementPosition);
-                        });
+                        return !minimumArea.Contains(elementPosition);
+                    });
             }
 
             return GetElementsInBounds(
                     new Bounds(
                         new Vector3(position.x, position.y, 0f),
-                        new Vector3(range * 2f, range * 2f, 1f)))
-                .Where(
-                    element =>
+                        new Vector3(range * 2f, range * 2f, 1f)
+                    )
+                )
+                .Where(element =>
+                {
+                    Vector2 elementPosition = elementTransformer(element);
+                    if (!area.Contains(elementPosition))
                     {
-                        Vector2 elementPosition = elementTransformer(element);
-                        if (!area.Contains(elementPosition))
-                        {
-                            return false;
-                        }
+                        return false;
+                    }
 
-                        return true;
-                    });
+                    return true;
+                });
         }
 
         IEnumerable<T> GetElementsInBounds(Bounds bounds);

package/Runtime/Core/Extension/CircleExtensions.cs

@@ -9,9 +9,9 @@
     {
         public static IEnumerable<FastVector3Int> EnumerateArea(this Circle circle, int z = 0)
         {
-            for (int x = (int) -circle.radius; x < circle.radius; ++x)
+            for (int x = (int)-circle.radius; x < circle.radius; ++x)
             {
-                for (int y = (int) -circle.radius; y < circle.radius; ++y)
+                for (int y = (int)-circle.radius; y < circle.radius; ++y)
                 {
                     Vector2 point = new(x, y);
                     if (circle.Contains(point))

package/Runtime/Core/Extension/DictionaryExtensions.cs

@@ -7,11 +7,19 @@
 
     public static class DictionaryExtensions
     {
-        public static V GetOrAdd<K, V>(this IDictionary<K, V> dictionary, K key, Func<V> valueProducer)
+        public static V GetOrAdd<K, V>(
+            this IDictionary<K, V> dictionary,
+            K key,
+            Func<V> valueProducer
+        )
         {
             if (dictionary is ConcurrentDictionary<K, V> concurrentDictionary)
             {
-                return concurrentDictionary.GetOrAdd(key, static (_, existing) => existing(), valueProducer);
+                return concurrentDictionary.GetOrAdd(
+                    key,
+                    static (_, existing) => existing(),
+                    valueProducer
+                );
             }
 
             if (dictionary.TryGetValue(key, out V result))
@@ -22,7 +30,11 @@
             return dictionary[key] = valueProducer();
         }
 
-        public static V GetOrAdd<K, V>(this IDictionary<K, V> dictionary, K key, Func<K, V> valueProducer)
+        public static V GetOrAdd<K, V>(
+            this IDictionary<K, V> dictionary,
+            K key,
+            Func<K, V> valueProducer
+        )
         {
             if (dictionary is ConcurrentDictionary<K, V> concurrentDictionary)
             {
@@ -37,7 +49,11 @@
             return dictionary[key] = valueProducer(key);
         }
 
-        public static V GetOrElse<K, V>(this IReadOnlyDictionary<K, V> dictionary, K key, Func<V> valueProducer)
+        public static V GetOrElse<K, V>(
+            this IReadOnlyDictionary<K, V> dictionary,
+            K key,
+            Func<V> valueProducer
+        )
         {
             if (dictionary.TryGetValue(key, out V value))
             {
@@ -47,7 +63,11 @@
             return valueProducer.Invoke();
         }
 
-        public static V GetOrElse<K, V>(this IReadOnlyDictionary<K, V> dictionary, K key, Func<K, V> valueProducer)
+        public static V GetOrElse<K, V>(
+            this IReadOnlyDictionary<K, V> dictionary,
+            K key,
+            Func<K, V> valueProducer
+        )
         {
             if (dictionary.TryGetValue(key, out V value))
             {
@@ -57,11 +77,16 @@
             return valueProducer.Invoke(key);
         }
 
-        public static V GetOrAdd<K, V>(this IDictionary<K, V> dictionary, K key) where V : new()
+        public static V GetOrAdd<K, V>(this IDictionary<K, V> dictionary, K key)
+            where V : new()
         {
             if (dictionary is ConcurrentDictionary<K, V> concurrentDictionary)
             {
-                return concurrentDictionary.AddOrUpdate(key, _ => new V(), (_, existing) => existing);
+                return concurrentDictionary.AddOrUpdate(
+                    key,
+                    _ => new V(),
+                    (_, existing) => existing
+                );
             }
 
             if (dictionary.TryGetValue(key, out V result))
@@ -78,14 +103,20 @@
         }
 
         public static V AddOrUpdate<K, V>(
-            this IDictionary<K, V> dictionary, K key, Func<K, V> creator, Func<K, V, V> updater)
+            this IDictionary<K, V> dictionary,
+            K key,
+            Func<K, V> creator,
+            Func<K, V, V> updater
+        )
         {
             if (dictionary is ConcurrentDictionary<K, V> concurrentDictionary)
             {
                 return concurrentDictionary.AddOrUpdate(key, creator, updater);
             }
 
-            V latest = dictionary.TryGetValue(key, out V value) ? updater(key, value) : creator(key);
+            V latest = dictionary.TryGetValue(key, out V value)
+                ? updater(key, value)
+                : creator(key);
             dictionary[key] = latest;
             return latest;
         }
@@ -107,7 +138,10 @@
             return value;
         }
 
-        public static Dictionary<K, V> Merge<K, V>(this IReadOnlyDictionary<K, V> lhs, IReadOnlyDictionary<K, V> rhs)
+        public static Dictionary<K, V> Merge<K, V>(
+            this IReadOnlyDictionary<K, V> lhs,
+            IReadOnlyDictionary<K, V> rhs
+        )
         {
             Dictionary<K, V> result = new();
             if (0 < lhs.Count)
@@ -137,7 +171,9 @@
         /// <param name="rhs">Changed dictionary.</param>
         /// <returns>All elements of rhs that either don't exist in or are different from lhs</returns>
         public static Dictionary<K, V> Difference<K, V>(
-            this IReadOnlyDictionary<K, V> lhs, IReadOnlyDictionary<K, V> rhs)
+            this IReadOnlyDictionary<K, V> lhs,
+            IReadOnlyDictionary<K, V> rhs
+        )
         {
             Dictionary<K, V> result = new(rhs.Count);
             foreach (KeyValuePair<K, V> kvp in rhs)
@@ -170,18 +206,25 @@
             return new Dictionary<K, V>(dictionary);
         }
 
-        public static Dictionary<K, V> ToDictionary<K, V>(this IEnumerable<KeyValuePair<K, V>> prettyMuchADictionary)
+        public static Dictionary<K, V> ToDictionary<K, V>(
+            this IEnumerable<KeyValuePair<K, V>> prettyMuchADictionary
+        )
         {
             return prettyMuchADictionary.ToDictionary(kvp => kvp.Key, kvp => kvp.Value);
         }
 
-        public static Dictionary<K, V> ToDictionary<K, V>(this IEnumerable<(K, V)> prettyMuchADictionary)
+        public static Dictionary<K, V> ToDictionary<K, V>(
+            this IEnumerable<(K, V)> prettyMuchADictionary
+        )
         {
             return prettyMuchADictionary.ToDictionary(kvp => kvp.Item1, kvp => kvp.Item2);
         }
 
         public static bool ContentEquals<K, V>(
-            this IReadOnlyDictionary<K, V> dictionary, IReadOnlyDictionary<K, V> other) where V : IEquatable<V>
+            this IReadOnlyDictionary<K, V> dictionary,
+            IReadOnlyDictionary<K, V> other
+        )
+            where V : IEquatable<V>
         {
             if (ReferenceEquals(dictionary, other))
             {
@@ -193,8 +236,10 @@
                 return false;
             }
 
-            return dictionary.Count == other.Count && dictionary.All(
-                kvp => other.TryGetValue(kvp.Key, out V value) && kvp.Value.Equals(value));
+            return dictionary.Count == other.Count
+                && dictionary.All(kvp =>
+                    other.TryGetValue(kvp.Key, out V value) && kvp.Value.Equals(value)
+                );
         }
 
         public static void Deconstruct<K, V>(this KeyValuePair<K, V> kvp, out K key, out V value)
@@ -203,4 +248,4 @@
             value = kvp.Value;
         }
     }
-}
+}

package/Runtime/Core/Extension/StringExtensions.cs

@@ -6,8 +6,17 @@
 
     public static class StringExtensions
     {
-        private static readonly HashSet<char> PascalCaseSeparators =
-            new() { '_', ' ', '\r', '\n', '\t', '.', '\'', '"' };
+        private static readonly HashSet<char> PascalCaseSeparators = new()
+        {
+            '_',
+            ' ',
+            '\r',
+            '\n',
+            '\t',
+            '.',
+            '\'',
+            '"',
+        };
 
         public static string Center(this string input, int length)
         {
@@ -41,13 +50,18 @@
             bool appendedAnySeparator = false;
             for (int i = 0; i < value.Length; ++i)
             {
-                while (startIndex < value.Length && PascalCaseSeparators.Contains(value[startIndex]))
+                while (
+                    startIndex < value.Length && PascalCaseSeparators.Contains(value[startIndex])
+                )
                 {
                     ++startIndex;
                 }
 
-                if (startIndex < i && char.IsLower(value[i - 1]) &&
-                    (char.IsUpper(value[i]) || PascalCaseSeparators.Contains(value[i])))
+                if (
+                    startIndex < i
+                    && char.IsLower(value[i - 1])
+                    && (char.IsUpper(value[i]) || PascalCaseSeparators.Contains(value[i]))
+                )
                 {
                     _ = stringBuilder.Append(char.ToUpper(value[startIndex]));
                     if (1 < i - startIndex)
@@ -74,8 +88,11 @@
                     continue;
                 }
 
-                if (startIndex + 1 < i && char.IsLower(value[i]) &&
-                    (char.IsUpper(value[i - 1]) || PascalCaseSeparators.Contains(value[i - 1])))
+                if (
+                    startIndex + 1 < i
+                    && char.IsLower(value[i])
+                    && (char.IsUpper(value[i - 1]) || PascalCaseSeparators.Contains(value[i - 1]))
+                )
                 {
                     _ = stringBuilder.Append(char.ToUpper(value[startIndex]));
                     if (1 < i - 1 - startIndex)
@@ -119,8 +136,11 @@
                     }
                 }
             }
-            else if (appendedAnySeparator && !string.IsNullOrEmpty(separator) &&
-                     separator.Length <= stringBuilder.Length)
+            else if (
+                appendedAnySeparator
+                && !string.IsNullOrEmpty(separator)
+                && separator.Length <= stringBuilder.Length
+            )
             {
                 stringBuilder.Remove(stringBuilder.Length - separator.Length, separator.Length);
             }
@@ -128,4 +148,4 @@
             return stringBuilder.ToString();
         }
     }
-}
+}

package/Runtime/Core/Helper/Enumerables.cs

@@ -6,7 +6,7 @@
     {
         public static IEnumerable<T> Of<T>(T element)
         {
-            return new[] {element};
+            return new[] { element };
         }
 
         public static IEnumerable<T> Of<T>(params T[] elements)

package/Runtime/Core/Helper/LifetimeHelpers.cs

@@ -4,7 +4,8 @@
 
     public static class LifetimeHelpers
     {
-        public static void Destroy<T>(this T source, float? afterTime = null) where T : Object
+        public static void Destroy<T>(this T source, float? afterTime = null)
+            where T : Object
         {
             source.SmartDestroy(afterTime);
         }

package/Runtime/Core/Math/Line.cs

@@ -52,4 +52,4 @@
             return true;
         }
     }
-}
+}

package/Runtime/Core/Math/Parabola.cs

@@ -21,7 +21,9 @@
         {
             if (length <= 0)
             {
-                throw new ArgumentException($"Expected a length greater than 0, but found: {length:0.00}.");
+                throw new ArgumentException(
+                    $"Expected a length greater than 0, but found: {length:0.00}."
+                );
             }
 
             Length = length;
@@ -42,4 +44,4 @@
             return true;
         }
     }
-}
+}

package/Runtime/Core/Math/PointPolygonCheck.cs

@@ -10,11 +10,18 @@
             int j = polygon.Length - 1;
             for (int i = 0; i < polygon.Length; i++)
             {
-                if (polygon[i].y < point.y && polygon[j].y >= point.y ||
-                    polygon[j].y < point.y && polygon[i].y >= point.y)
+                if (
+                    polygon[i].y < point.y && polygon[j].y >= point.y
+                    || polygon[j].y < point.y && polygon[i].y >= point.y
+                )
                 {
-                    if (polygon[i].x + (point.y - polygon[i].y) / (polygon[j].y - polygon[i].y) *
-                        (polygon[j].x - polygon[i].x) < point.x)
+                    if (
+                        polygon[i].x
+                            + (point.y - polygon[i].y)
+                                / (polygon[j].y - polygon[i].y)
+                                * (polygon[j].x - polygon[i].x)
+                        < point.x
+                    )
                     {
                         result = !result;
                     }
@@ -26,4 +33,4 @@
             return result;
         }
     }
-}
+}

package/Runtime/Core/Math/Range.cs

@@ -1,17 +1,18 @@
 namespace UnityHelpers.Core.Math
 {
-    using Extension;
-    using Helper;
     using System;
     using System.Runtime.Serialization;
     using System.Text.Json.Serialization;
+    using Extension;
+    using Helper;
 
     /// <summary>
     ///     Inclusive Range [min,max]
     /// </summary>
     [Serializable]
     [DataContract]
-    public struct Range<T> : IEquatable<Range<T>> where T : IEquatable<T>, IComparable<T>
+    public struct Range<T> : IEquatable<Range<T>>
+        where T : IEquatable<T>, IComparable<T>
     {
         [DataMember]
         [JsonInclude]
@@ -40,10 +41,10 @@
 
         public bool Equals(Range<T> other)
         {
-            return min.Equals(other.min) &&
-                   max.Equals(other.max) &&
-                   startInclusive == other.startInclusive &&
-                   endInclusive == other.endInclusive;
+            return min.Equals(other.min)
+                && max.Equals(other.max)
+                && startInclusive == other.startInclusive
+                && endInclusive == other.endInclusive;
         }
 
         public override bool Equals(object obj)
@@ -88,4 +89,4 @@
             return true;
         }
     }
-}
+}