com.wallstop-studios.unity-helpers 1.0.0-rc4

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

@@ -0,0 +1,274 @@
+namespace UnityHelpers.Core.DataStructure.Adapters
+{
+    using System;
+    using System.Runtime.Serialization;
+    using Helper;
+    using ProtoBuf;
+
+    [Serializable]
+    [DataContract]
+    [ProtoContract]
+    public struct KGuid : IEquatable<KGuid>, IEquatable<Guid>, IComparable<KGuid>
+    {
+        /*
+            We need to store this in a NetworkList somewhere, and that means we can't have arrays.
+            Since we know the underlying data, do this shit (this is what a Guid looks like anyway)...
+         */
+        [ProtoMember(1)]
+        private int _a;
+        [ProtoMember(2)]
+        private short _b;
+        [ProtoMember(3)]
+        private short _c;
+        [ProtoMember(4)]
+        private byte _d;
+        [ProtoMember(5)]
+        private byte _e;
+        [ProtoMember(6)]
+        private byte _f;
+        [ProtoMember(7)]
+        private byte _g;
+        [ProtoMember(8)]
+        private byte _h;
+        [ProtoMember(9)]
+        private byte _i;
+        [ProtoMember(10)]
+        private byte _j;
+        [ProtoMember(11)]
+        private byte _k;
+
+        private int _hashCode;
+
+        [DataMember] 
+        private string Guid => ((Guid) this).ToString();
+
+        public static KGuid NewGuid()
+        {
+            return new KGuid(System.Guid.NewGuid());
+        }
+        
+        public KGuid(Guid guid) : this(guid.ToByteArray())
+        {
+        }
+
+        public KGuid(byte[] guidBytes)
+        {
+            _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];
+            _e = guidBytes[9];
+            _f = guidBytes[10];
+            _g = guidBytes[11];
+            _h = guidBytes[12];
+            _i = guidBytes[13];
+            _j = guidBytes[14];
+            _k = guidBytes[15];
+            _hashCode = 0;
+        }
+
+        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);
+        }
+
+        public static implicit operator KGuid(Guid guid)
+        {
+            return new KGuid(guid);
+        }
+
+        public static bool operator ==(KGuid lhs, KGuid rhs)
+        {
+            return lhs.Equals(rhs);
+        }
+
+        public static bool operator !=(KGuid lhs, KGuid rhs)
+        {
+            return !lhs.Equals(rhs);
+        }
+
+        public bool Equals(KGuid other)
+        {
+            if (GetHashCode() != other.GetHashCode())
+            {
+                return false;
+            }
+
+            if (_a != other._a)
+            {
+                return false;
+            }
+
+            if (_b != other._b)
+            {
+                return false;
+            }
+
+            if (_c != other._c)
+            {
+                return false;
+            }
+
+            if (_d != other._d)
+            {
+                return false;
+            }
+
+            if (_e != other._e)
+            {
+                return false;
+            }
+
+            if (_f != other._f)
+            {
+                return false;
+            }
+
+            if (_g != other._g)
+            {
+                return false;
+            }
+
+            if (_h != other._h)
+            {
+                return false;
+            }
+
+            if (_i != other._i)
+            {
+                return false;
+            }
+
+            if (_j != other._j)
+            {
+                return false;
+            }
+
+            return _k == other._k;
+        }
+
+        public bool Equals(Guid other)
+        {
+            return other.Equals(new Guid(_a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k));
+        }
+
+        public int CompareTo(KGuid other)
+        {
+            int comparison = _a.CompareTo(other._a);
+            if (comparison != 0)
+            {
+                return comparison;
+            }
+
+            comparison = _b.CompareTo(other._b);
+            if (comparison != 0)
+            {
+                return comparison;
+            }
+
+            comparison = _c.CompareTo(other._c);
+            if (comparison != 0)
+            {
+                return comparison;
+            }
+
+            comparison = _d.CompareTo(other._d);
+            if (comparison != 0)
+            {
+                return comparison;
+            }
+
+            comparison = _e.CompareTo(other._e);
+            if (comparison != 0)
+            {
+                return comparison;
+            }
+
+            comparison = _f.CompareTo(other._f);
+            if (comparison != 0)
+            {
+                return comparison;
+            }
+
+            comparison = _g.CompareTo(other._g);
+            if (comparison != 0)
+            {
+                return comparison;
+            }
+
+            comparison = _h.CompareTo(other._h);
+            if (comparison != 0)
+            {
+                return comparison;
+            }
+
+            comparison = _i.CompareTo(other._i);
+            if (comparison != 0)
+            {
+                return comparison;
+            }
+
+            comparison = _j.CompareTo(other._j);
+            if (comparison != 0)
+            {
+                return comparison;
+            }
+
+            return _k.CompareTo(other._k);
+        }
+
+        public override bool Equals(object other)
+        {
+            return other switch
+            {
+                KGuid otherKGuid => Equals(otherKGuid),
+                Guid otherGuid => Equals(otherGuid),
+                _ => false
+            };
+        }
+
+        public override int GetHashCode()
+        {
+            if (_hashCode == 0)
+            {
+                _hashCode = Objects.ValueTypeHashCode(_a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k);
+            }
+
+            return _hashCode;
+        }
+
+        public override string ToString()
+        {
+            return Guid;
+        }
+
+        public byte[] ToByteArray()
+        {
+            return new []
+            {
+                (byte) _a,
+                (byte) (_a >> 8),
+                (byte) (_a >> 16),
+                (byte) (_a >> 24),
+                (byte) _b,
+                (byte) ((uint) _b >> 8),
+                (byte) _c,
+                (byte) ((uint) _c >> 8),
+                _d,
+                _e,
+                _f,
+                _g,
+                _h,
+                _i,
+                _j,
+                _k
+            };
+        }
+
+        [ProtoAfterDeserialization]
+        private void AfterDeserialize()
+        {
+            _hashCode = 0;
+        }
+    }
+}

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

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 26956dbaa8371b844a4f479d0cca7697
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

@@ -0,0 +1,79 @@
+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/Adapters/KVector2.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 388685065c015d1488f74e5302f4e3c3
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Core/DataStructure/Adapters.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: c195b0991ed00bb4398808bc2607bdf4
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Core/DataStructure/Circle.cs

@@ -0,0 +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);
+        }
+    }
+}

package/Runtime/Core/DataStructure/Circle.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b8e35268d046d56448f436c53521ad8d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Core/DataStructure/CyclicBuffer.cs

@@ -0,0 +1,130 @@
+namespace UnityHelpers.Core.DataStructure
+{
+    using Helper;
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.ComponentModel;
+
+    public enum BufferAddMethod
+    {
+        Prepend,
+        Append
+    }
+
+    [Serializable]
+    public sealed class CyclicBuffer<T> : IEnumerable<T>
+    {
+        private readonly T[] _buffer;
+
+        private int _position;
+
+        public readonly BufferAddMethod AddMethod;
+
+        public readonly int Capacity;
+
+        public int Count { get; private set; }
+
+        public readonly bool IsReadOnly;
+
+        public T this[int index]
+        {
+            get
+            {
+                BoundsCheck(index);
+                return _buffer[AdjustedIndexFor(index)];
+            }
+            set
+            {
+                BoundsCheck(index);
+                _buffer[AdjustedIndexFor(index)] = value;
+            }
+        }
+
+        public CyclicBuffer(int capacity, BufferAddMethod addMethod = BufferAddMethod.Prepend)
+        {
+            if (capacity < 0)
+            {
+                throw new ArgumentException(nameof(capacity));
+            }
+            AddMethod = addMethod;
+            Capacity = capacity;
+            _position = 0;
+            _buffer = new T[capacity];
+            IsReadOnly = false;
+        }
+
+        public IEnumerator<T> GetEnumerator()
+        {
+            for (int i = 0; i < Count; ++i)
+            {
+                yield return this[i];
+            }
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+
+        public void Add(T item)
+        {
+            _buffer[_position] = item;
+            _position = WallMath.WrappedIncrement(_position, Capacity);
+            if (Count < Capacity)
+            {
+                ++Count;
+            }
+        }
+
+        public void Clear()
+        {
+            /* Simply reset state */
+            Count = 0;
+            _position = 0;
+        }
+
+        public bool Peek(out T value)
+        {
+            if (InBounds(0))
+            {
+                value = this[0];
+                return true;
+            }
+            value = default(T);
+            return false;
+        }
+
+        private int AdjustedIndexFor(int index)
+        {
+            switch (AddMethod)
+            {
+                case BufferAddMethod.Prepend:
+                    {
+                        return (_position - 1 + Capacity - index) % Capacity;
+                    }
+                case BufferAddMethod.Append:
+                    {
+                        return index;
+                    }
+                default:
+                    {
+                        throw new InvalidEnumArgumentException("Unexpected AddMethod: " + AddMethod);
+                    }
+            }
+        }
+
+        private void BoundsCheck(int index)
+        {
+            if (!InBounds(index))
+            {
+                throw new IndexOutOfRangeException($"{index} is outside of bounds [0, {Count})");
+            }
+        }
+
+        private bool InBounds(int index)
+        {
+            return !(Count <= index || index < 0);
+        }
+    }
+}

package/Runtime/Core/DataStructure/CyclicBuffer.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e54ab068d0e1e66458304160e46b878d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Core/DataStructure/ISpatialTree.cs

@@ -0,0 +1,58 @@
+namespace UnityHelpers.Core.DataStructure
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using UnityEngine;
+
+    public interface ISpatialTree<T>
+    {
+        Bounds Boundary { get; }
+        Func<T, Vector2> ElementTransformer { get; }
+
+        IEnumerable<T> GetElementsInRange(Vector2 position, float range, float minimumRange = 0f)
+        {
+            Circle area = new(position, range);
+            Func<T, Vector2> elementTransformer = ElementTransformer;
+            if (0 < minimumRange)
+            {
+                Circle minimumArea = new(position, minimumRange);
+                return GetElementsInBounds(
+                        new Bounds(
+                            new Vector3(position.x, position.y, 0f),
+                            new Vector3(range * 2f, range * 2f, 1f)))
+                    .Where(
+                        element =>
+                        {
+                            Vector2 elementPosition = elementTransformer(element);
+                            if (!area.Contains(elementPosition))
+                            {
+                                return false;
+                            }
+
+                            return !minimumArea.Contains(elementPosition);
+                        });
+            }
+
+            return GetElementsInBounds(
+                    new Bounds(
+                        new Vector3(position.x, position.y, 0f),
+                        new Vector3(range * 2f, range * 2f, 1f)))
+                .Where(
+                    element =>
+                    {
+                        Vector2 elementPosition = elementTransformer(element);
+                        if (!area.Contains(elementPosition))
+                        {
+                            return false;
+                        }
+
+                        return true;
+                    });
+        }
+
+        IEnumerable<T> GetElementsInBounds(Bounds bounds);
+
+        void GetApproximateNearestNeighbors(Vector2 position, int count, List<T> nearestNeighbors);
+    }
+}

package/Runtime/Core/DataStructure/ISpatialTree.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: cd3750502b187ae40a121cd34343d38c
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: