com.wallstop-studios.unity-helpers 2.0.0-rc58 → 2.0.0-rc59

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

@@ -1,80 +1,80 @@
-namespace UnityHelpers.Core.DataStructure.Adapters
-{
-    using System;
-    using System.Runtime.Serialization;
-    using Helper;
-    using ProtoBuf;
-    using UnityEngine;
-
-    [Serializable]
-    [DataContract]
-    [ProtoContract]
-    public struct KVector2 : IEquatable<KVector2>, IEquatable<Vector2>
-    {
-        [DataMember]
-        [ProtoMember(1)]
-        public float x;
-
-        [DataMember]
-        [ProtoMember(2)]
-        public float y;
-
-        public float Magnitude => (float)Math.Sqrt(x * (double)x + y * (double)y);
-
-        public KVector2(float x, float y)
-        {
-            this.x = x;
-            this.y = y;
-        }
-
-        public KVector2(Vector2 vector)
-        {
-            x = vector.x;
-            y = vector.y;
-        }
-
-        public static implicit operator Vector2(KVector2 vector)
-        {
-            return new Vector2(vector.x, vector.y);
-        }
-
-        public static implicit operator KVector2(Vector2 vector)
-        {
-            return new KVector2(vector);
-        }
-
-        public bool Equals(Vector2 vector)
-        {
-            // ReSharper disable once CompareOfFloatsByEqualityOperator
-            if (x != vector.x)
-            {
-                return false;
-            }
-
-            // ReSharper disable once CompareOfFloatsByEqualityOperator
-            return y == vector.y;
-        }
-
-        public bool Equals(KVector2 vector)
-        {
-            // ReSharper disable once CompareOfFloatsByEqualityOperator
-            if (x != vector.x)
-            {
-                return false;
-            }
-
-            // ReSharper disable once CompareOfFloatsByEqualityOperator
-            return y == vector.y;
-        }
-
-        public override bool Equals(object obj)
-        {
-            return obj is KVector2 vector && Equals(vector);
-        }
-
-        public override int GetHashCode()
-        {
-            return Objects.ValueTypeHashCode(x, y);
-        }
-    }
-}
+namespace UnityHelpers.Core.DataStructure.Adapters
+{
+    using System;
+    using System.Runtime.Serialization;
+    using Helper;
+    using ProtoBuf;
+    using UnityEngine;
+
+    [Serializable]
+    [DataContract]
+    [ProtoContract]
+    public struct KVector2 : IEquatable<KVector2>, IEquatable<Vector2>
+    {
+        [DataMember]
+        [ProtoMember(1)]
+        public float x;
+
+        [DataMember]
+        [ProtoMember(2)]
+        public float y;
+
+        public float Magnitude => (float)Math.Sqrt(x * (double)x + y * (double)y);
+
+        public KVector2(float x, float y)
+        {
+            this.x = x;
+            this.y = y;
+        }
+
+        public KVector2(Vector2 vector)
+        {
+            x = vector.x;
+            y = vector.y;
+        }
+
+        public static implicit operator Vector2(KVector2 vector)
+        {
+            return new Vector2(vector.x, vector.y);
+        }
+
+        public static implicit operator KVector2(Vector2 vector)
+        {
+            return new KVector2(vector);
+        }
+
+        public bool Equals(Vector2 vector)
+        {
+            // ReSharper disable once CompareOfFloatsByEqualityOperator
+            if (x != vector.x)
+            {
+                return false;
+            }
+
+            // ReSharper disable once CompareOfFloatsByEqualityOperator
+            return y == vector.y;
+        }
+
+        public bool Equals(KVector2 vector)
+        {
+            // ReSharper disable once CompareOfFloatsByEqualityOperator
+            if (x != vector.x)
+            {
+                return false;
+            }
+
+            // ReSharper disable once CompareOfFloatsByEqualityOperator
+            return y == vector.y;
+        }
+
+        public override bool Equals(object obj)
+        {
+            return obj is KVector2 vector && Equals(vector);
+        }
+
+        public override int GetHashCode()
+        {
+            return Objects.ValueTypeHashCode(x, y);
+        }
+    }
+}

package/Runtime/Core/DataStructure/Circle.cs

@@ -1,50 +1,50 @@
-namespace UnityHelpers.Core.DataStructure
-{
-    using System;
-    using Extension;
-    using UnityEngine;
-
-    public readonly struct Circle
-    {
-        public readonly Vector2 center;
-        public readonly float radius;
-        private readonly float _radiusSquared;
-
-        public Circle(Vector2 center, float radius)
-        {
-            this.center = center;
-            this.radius = radius;
-            _radiusSquared = radius * radius;
-        }
-
-        public bool Contains(Vector2 point)
-        {
-            return (center - point).sqrMagnitude <= _radiusSquared;
-        }
-
-        public bool Intersects(Bounds bounds)
-        {
-            return Intersects(bounds.Rect());
-        }
-
-        // https://www.geeksforgeeks.org/check-if-any-point-overlaps-the-given-circle-and-rectangle/
-        public bool Intersects(Rect rectangle)
-        {
-            float xN = Math.Max(center.x, rectangle.x);
-            float yN = Math.Max(center.y, rectangle.y);
-            float dX = xN - center.x;
-            float dY = yN - center.y;
-            return (dX * dX + dY * dY) <= _radiusSquared;
-        }
-
-        public bool Overlaps(Bounds bounds)
-        {
-            return Overlaps(bounds.Rect());
-        }
-
-        public bool Overlaps(Rect rectangle)
-        {
-            return Contains(rectangle.min) && Contains(rectangle.max);
-        }
-    }
-}
+namespace UnityHelpers.Core.DataStructure
+{
+    using System;
+    using Extension;
+    using UnityEngine;
+
+    public readonly struct Circle
+    {
+        public readonly Vector2 center;
+        public readonly float radius;
+        private readonly float _radiusSquared;
+
+        public Circle(Vector2 center, float radius)
+        {
+            this.center = center;
+            this.radius = radius;
+            _radiusSquared = radius * radius;
+        }
+
+        public bool Contains(Vector2 point)
+        {
+            return (center - point).sqrMagnitude <= _radiusSquared;
+        }
+
+        public bool Intersects(Bounds bounds)
+        {
+            return Intersects(bounds.Rect());
+        }
+
+        // https://www.geeksforgeeks.org/check-if-any-point-overlaps-the-given-circle-and-rectangle/
+        public bool Intersects(Rect rectangle)
+        {
+            float xN = Math.Max(center.x, rectangle.x);
+            float yN = Math.Max(center.y, rectangle.y);
+            float dX = xN - center.x;
+            float dY = yN - center.y;
+            return (dX * dX + dY * dY) <= _radiusSquared;
+        }
+
+        public bool Overlaps(Bounds bounds)
+        {
+            return Overlaps(bounds.Rect());
+        }
+
+        public bool Overlaps(Rect rectangle)
+        {
+            return Contains(rectangle.min) && Contains(rectangle.max);
+        }
+    }
+}

package/Runtime/Core/DataStructure/CyclicBuffer.cs

@@ -1,153 +1,193 @@
-namespace UnityHelpers.Core.DataStructure
-{
-    using System;
-    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; }
-
-        private readonly List<T> _buffer;
-        private int _position;
-
-        public T this[int index]
-        {
-            get
-            {
-                BoundsCheck(index);
-                return _buffer[AdjustedIndexFor(index)];
-            }
-            set
-            {
-                BoundsCheck(index);
-                _buffer[AdjustedIndexFor(index)] = value;
-            }
-        }
-
-        public CyclicBuffer(int capacity, IEnumerable<T> initialContents = null)
-        {
-            if (capacity < 0)
-            {
-                throw new ArgumentException(nameof(capacity));
-            }
-
-            Capacity = capacity;
-            _position = 0;
-            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)
-            {
-                // No need for bound check, we're safe
-                yield return _buffer[AdjustedIndexFor(i)];
-            }
-        }
-
-        IEnumerator IEnumerable.GetEnumerator()
-        {
-            return GetEnumerator();
-        }
-
-        public void Add(T item)
-        {
-            if (Capacity == 0)
-            {
-                return;
-            }
-
-            if (_position < _buffer.Count)
-            {
-                _buffer[_position] = item;
-            }
-            else
-            {
-                _buffer.Add(item);
-            }
-
-            _position = _position.WrappedIncrement(Capacity);
-            if (Count < Capacity)
-            {
-                ++Count;
-            }
-        }
-
-        public void Clear()
-        {
-            Count = 0;
-            _position = 0;
-            _buffer.Clear();
-        }
-
-        public void Resize(int newCapacity)
-        {
-            if (newCapacity == Capacity)
-            {
-                return;
-            }
-
-            if (newCapacity < 0)
-            {
-                throw new ArgumentException(nameof(newCapacity));
-            }
-
-            int oldCapacity = Capacity;
-            Capacity = newCapacity;
-            _buffer.Shift(-_position);
-            if (newCapacity < _buffer.Count)
-            {
-                _buffer.RemoveRange(newCapacity, _buffer.Count - newCapacity);
-            }
-
-            _position =
-                newCapacity < oldCapacity && newCapacity <= _buffer.Count ? 0 : _buffer.Count;
-            Count = Math.Min(newCapacity, Count);
-        }
-
-        public bool Contains(T item)
-        {
-            return _buffer.Contains(item);
-        }
-
-        private int AdjustedIndexFor(int index)
-        {
-            long longCapacity = Capacity;
-            if (longCapacity == 0L)
-            {
-                return 0;
-            }
-            unchecked
-            {
-                int adjustedIndex = (int)(
-                    (_position - 1L + longCapacity - (_buffer.Count - 1 - index)) % longCapacity
-                );
-                return adjustedIndex;
-            }
-        }
-
-        private void BoundsCheck(int index)
-        {
-            if (!InBounds(index))
-            {
-                throw new IndexOutOfRangeException($"{index} is outside of bounds [0, {Count})");
-            }
-        }
-
-        private bool InBounds(int index)
-        {
-            return 0 <= index && index < Count;
-        }
-    }
-}
+namespace UnityHelpers.Core.DataStructure
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Linq;
+    using Extension;
+    using Helper;
+
+    [Serializable]
+    public sealed class CyclicBuffer<T> : IReadOnlyList<T>
+    {
+        public struct CyclicBufferEnumerator : IEnumerator<T>
+        {
+            private readonly CyclicBuffer<T> _buffer;
+
+            private int _index;
+            private T _current;
+
+            internal CyclicBufferEnumerator(CyclicBuffer<T> buffer)
+            {
+                _buffer = buffer;
+                _index = -1;
+                _current = default;
+            }
+
+            public bool MoveNext()
+            {
+                if (++_index < _buffer.Count)
+                {
+                    _current = _buffer._buffer[_buffer.AdjustedIndexFor(_index)];
+                    return true;
+                }
+
+                _current = default;
+                return false;
+            }
+
+            public T Current => _current;
+
+            object IEnumerator.Current => Current;
+
+            public void Reset()
+            {
+                _index = -1;
+                _current = default;
+            }
+
+            public void Dispose() { }
+        }
+
+        public int Capacity { get; private set; }
+        public int Count { get; private set; }
+
+        private readonly List<T> _buffer;
+        private int _position;
+
+        public T this[int index]
+        {
+            get
+            {
+                BoundsCheck(index);
+                return _buffer[AdjustedIndexFor(index)];
+            }
+            set
+            {
+                BoundsCheck(index);
+                _buffer[AdjustedIndexFor(index)] = value;
+            }
+        }
+
+        public CyclicBuffer(int capacity, IEnumerable<T> initialContents = null)
+        {
+            if (capacity < 0)
+            {
+                throw new ArgumentException(nameof(capacity));
+            }
+
+            Capacity = capacity;
+            _position = 0;
+            Count = 0;
+            _buffer = new List<T>();
+            foreach (T item in initialContents ?? Enumerable.Empty<T>())
+            {
+                Add(item);
+            }
+        }
+
+        public CyclicBufferEnumerator GetEnumerator()
+        {
+            return new CyclicBufferEnumerator(this);
+        }
+
+        IEnumerator<T> IEnumerable<T>.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+
+        public void Add(T item)
+        {
+            if (Capacity == 0)
+            {
+                return;
+            }
+
+            if (_position < _buffer.Count)
+            {
+                _buffer[_position] = item;
+            }
+            else
+            {
+                _buffer.Add(item);
+            }
+
+            _position = _position.WrappedIncrement(Capacity);
+            if (Count < Capacity)
+            {
+                ++Count;
+            }
+        }
+
+        public void Clear()
+        {
+            Count = 0;
+            _position = 0;
+            _buffer.Clear();
+        }
+
+        public void Resize(int newCapacity)
+        {
+            if (newCapacity == Capacity)
+            {
+                return;
+            }
+
+            if (newCapacity < 0)
+            {
+                throw new ArgumentException(nameof(newCapacity));
+            }
+
+            int oldCapacity = Capacity;
+            Capacity = newCapacity;
+            _buffer.Shift(-_position);
+            if (newCapacity < _buffer.Count)
+            {
+                _buffer.RemoveRange(newCapacity, _buffer.Count - newCapacity);
+            }
+
+            _position =
+                newCapacity < oldCapacity && newCapacity <= _buffer.Count ? 0 : _buffer.Count;
+            Count = Math.Min(newCapacity, Count);
+        }
+
+        public bool Contains(T item)
+        {
+            return _buffer.Contains(item);
+        }
+
+        private int AdjustedIndexFor(int index)
+        {
+            long longCapacity = Capacity;
+            if (longCapacity == 0L)
+            {
+                return 0;
+            }
+            unchecked
+            {
+                int adjustedIndex = (int)(
+                    (_position - 1L + longCapacity - (_buffer.Count - 1 - index)) % longCapacity
+                );
+                return adjustedIndex;
+            }
+        }
+
+        private void BoundsCheck(int index)
+        {
+            if (!InBounds(index))
+            {
+                throw new IndexOutOfRangeException($"{index} is outside of bounds [0, {Count})");
+            }
+        }
+
+        private bool InBounds(int index)
+        {
+            return 0 <= index && index < Count;
+        }
+    }
+}