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

package/Runtime/Core/Helper/WallMath.cs

@@ -0,0 +1,75 @@
+namespace UnityHelpers.Core.Helper
+{
+    using System;
+    using UnityEngine;
+
+    public static class WallMath
+    {
+        /**
+            http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/8-b132/java/util/concurrent/ThreadLocalRandom.java#356
+            <summary>
+                BoundedDouble borrowed from Java's ThreadLocalRandom
+            </summary>
+        */
+
+        public static double BoundedDouble(double max, double value)
+        {
+            return value < max ? value : BitConverter.Int64BitsToDouble(BitConverter.DoubleToInt64Bits(value) - 1);
+        }
+
+        public static float BoundedFloat(float max, float value)
+        {
+            return value < max
+                ? value
+                : BitConverter.ToSingle(
+                    BitConverter.GetBytes(BitConverter.ToInt32(BitConverter.GetBytes(value), 0) - 1), 0);
+        }
+
+        public static int WrappedAdd(int value, int increment, int max)
+        {
+            WrappedAdd(ref value, increment, max);
+            return value;
+        }
+
+        public static void WrappedAdd(ref int value, int increment, int max)
+        {
+            value = value + increment;
+            if (value < max)
+            {
+                return;
+            }
+            value %= max;
+        }
+
+        public static int WrappedIncrement(int value, int max)
+        {
+            return WrappedAdd(value, 1, max);
+        }
+
+        public static void WrappedIncrement(ref int value, int max)
+        {
+            WrappedAdd(ref value, 1, max);
+        }
+
+        public static void Clamp(this Rect bounds, ref Vector2 point)
+        {
+            if (!bounds.Contains(point))
+            {
+                Vector2 xClamp = bounds.width < 0 ?
+                    new Vector2(bounds.x + bounds.width, bounds.x) :
+                    new Vector2(bounds.x, bounds.x + bounds.width);
+                Vector2 yClamp = bounds.height < 0 ?
+                    new Vector2(bounds.y + bounds.height, bounds.y) :
+                    new Vector2(bounds.y, bounds.y + bounds.height);
+
+                point.x = Mathf.Clamp(point.x, xClamp.x, xClamp.y);
+                point.y = Mathf.Clamp(point.y, yClamp.x, yClamp.y);
+            }
+        }
+
+        public static bool Approximately(float lhs, float rhs, float tolerance = 0.045f)
+        {
+            return Math.Abs(lhs - rhs) <= tolerance;
+        }
+    }
+}

package/Runtime/Core/Helper/WallMath.cs.meta

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

package/Runtime/Core/Helper.meta

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

package/Runtime/Core/Math/Line.cs

@@ -0,0 +1,51 @@
+namespace UnityHelpers.Core.Math
+{
+    using Extension;
+    using UnityEngine;
+
+    // https://pastebin.com/iQDhQTFN
+    public readonly struct Line
+    {
+        public readonly Vector2 from;
+        public readonly Vector2 to;
+
+        private readonly float _a;
+        private readonly float _b;
+        private readonly float _c;
+
+        public Line(Vector2 from, Vector2 to)
+        {
+            this.from = from;
+            this.to = to;
+            _a = to.y - from.y;
+            _b = from.x - to.x;
+            _c = _a * from.x + _b * from.y;
+        }
+
+        public bool Intersects(Line other)
+        {
+            return UnityExtensions.Intersects(from, to, other.from, other.to);
+        }
+
+        public bool TryGetIntersectionPoint(Line other, out Vector2 intersection)
+        {
+            if (!Intersects(other))
+            {
+                intersection = default;
+                return false;
+            }
+
+            float determinant = _a * other._b - other._a * _b;
+            if (Mathf.Approximately(determinant, 0))
+            {
+                intersection = default;
+                return false;
+            }
+
+            float x = (other._b * _c - _b * other._c) / determinant;
+            float y = (_a * other._c - other._a * _c) / determinant;
+            intersection = new Vector2(x, y);
+            return true;
+        }
+    }
+}

package/Runtime/Core/Math/Line.cs.meta

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

package/Runtime/Core/Math/Parabola.cs

@@ -0,0 +1,44 @@
+namespace UnityHelpers.Core.Math
+{
+    using System;
+    using System.Runtime.Serialization;
+
+    [DataContract]
+    [Serializable]
+    public sealed class Parabola
+    {
+        public readonly float Length;
+
+        public readonly float A;
+        public readonly float B;
+
+        /// <summary>
+        /// Creates a Parabola that reaches a max height and has a specified length.
+        /// </summary>
+        /// <param name="max">Max height of parabola.</param>
+        /// <param name="length">Length of parabola (between x intercepts).</param>
+        public Parabola(float max, float length)
+        {
+            if (length <= 0)
+            {
+                throw new ArgumentException($"Expected a length greater than 0, but found: {length:0.00}.");
+            }
+            Length = length;
+
+            A = -4 * max / (length * length);
+            B = -A * length;
+        }
+
+        public bool ValueAt(float x, out float y)
+        {
+            if (x < 0 || Length < x)
+            {
+                y = float.NaN;
+                return false;
+            }
+
+            y = A * (x * x) + B * x;
+            return true;
+        }
+    }
+}

package/Runtime/Core/Math/Parabola.cs.meta

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

package/Runtime/Core/Math/PointPolygonCheck.cs

@@ -0,0 +1,25 @@
+namespace UnityHelpers.Core.Math
+{
+    using UnityEngine;
+
+    public static class PointPolygonCheck
+    {
+        public static bool IsPointInsidePolygon(Vector2 point, Vector2[] polygon)
+        {
+            bool result = false;
+            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].x + (point.y - polygon[i].y) / (polygon[j].y - polygon[i].y) * (polygon[j].x - polygon[i].x) < point.x)
+                    {
+                        result = !result;
+                    }
+                }
+                j = i;
+            }
+            return result;
+        }
+    }
+}

package/Runtime/Core/Math/PointPolygonCheck.cs.meta

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

package/Runtime/Core/Math/Range.cs

@@ -0,0 +1,56 @@
+namespace UnityHelpers.Core.Math
+{
+    using Extension;
+    using Helper;
+    using System;
+    using System.Runtime.Serialization;
+
+    /// <summary>
+    ///     Inclusive Range [min,max]
+    /// </summary>
+    [Serializable]
+    [DataContract]
+    public struct Range<T> : IEquatable<Range<T>> where T: IEquatable<T>, IComparable<T>
+    {
+        [DataMember]
+        public T min;
+        [DataMember]
+        public T max;
+
+        public Range(T min, T max)
+        {
+            this.min = min;
+            this.max = max;
+        }
+
+        public bool Equals(Range<T> other)
+        {
+            return Equals(min, other.min) && Equals(max, other.max);
+        }
+
+        public override bool Equals(object obj)
+        {
+            return obj is Range<T> other && Equals(other);
+        }
+
+        public override int GetHashCode()
+        {
+            return Objects.HashCode(min, max);
+        }
+
+        public override string ToString()
+        {
+            return this.ToJson();
+        }
+
+        public bool WithinRange(T value)
+        {
+            if (value.CompareTo(min) < 0)
+            {
+                return false;
+            }
+
+            return value.CompareTo(max) <= 0;
+        }
+    }
+}

package/Runtime/Core/Math/Range.cs.meta

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

package/Runtime/Core/Math/XXHash.cs

@@ -0,0 +1,308 @@
+namespace UnityHelpers.Core.Math
+{
+    using System.Runtime.CompilerServices;
+    using System.Text;
+
+    internal static class XXHash
+    {
+        private const ulong k_Prime64v1 = 11400714785074694791ul;
+        private const ulong k_Prime64v2 = 14029467366897019727ul;
+        private const ulong k_Prime64v3 = 1609587929392839161ul;
+        private const ulong k_Prime64v4 = 9650029242287828579ul;
+        private const ulong k_Prime64v5 = 2870177450012600261ul;
+
+        private const uint k_Prime32v1 = 2654435761u;
+        private const uint k_Prime32v2 = 2246822519u;
+        private const uint k_Prime32v3 = 3266489917u;
+        private const uint k_Prime32v4 = 668265263u;
+        private const uint k_Prime32v5 = 374761393u;
+
+        public static uint Hash32(string text) => Hash32(text, Encoding.UTF8);
+        public static uint Hash32(string text, Encoding encoding) => Hash32(encoding.GetBytes(text));
+        public static uint Hash32(byte[] buffer)
+        {
+            unsafe
+            {
+                fixed (byte* ptr = buffer)
+                {
+                    return Hash32(ptr, buffer.Length);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Generate a 32-bit xxHash value.
+        /// </summary>
+        /// <param name="buffer">Input buffer.</param>
+        /// <param name="bufferLength">Input buffer length.</param>
+        /// <param name="seed">Optional seed.</param>
+        /// <returns>32-bit hash value.</returns>
+        public static unsafe uint Hash32(byte* buffer, int bufferLength, uint seed = 0)
+        {
+            const int stripeLength = 16;
+
+            int len = bufferLength;
+            int remainingLen = len;
+            uint acc;
+
+            byte* pInput = buffer;
+            if (len >= stripeLength)
+            {
+                uint acc1 = seed + k_Prime32v1 + k_Prime32v2;
+                uint acc2 = seed + k_Prime32v2;
+                uint acc3 = seed;
+                uint acc4 = seed - k_Prime32v1;
+
+                do
+                {
+                    acc = processStripe32(ref pInput, ref acc1, ref acc2, ref acc3, ref acc4);
+                    remainingLen -= stripeLength;
+                } while (remainingLen >= stripeLength);
+            }
+            else
+            {
+                acc = seed + k_Prime32v5;
+            }
+
+            acc += (uint)len;
+            acc = processRemaining32(pInput, acc, remainingLen);
+
+            return avalanche32(acc);
+        }
+
+        public static ulong Hash64(string text) => Hash64(text, Encoding.UTF8);
+        public static ulong Hash64(string text, Encoding encoding) => Hash64(encoding.GetBytes(text));
+        public static ulong Hash64(byte[] buffer)
+        {
+            unsafe
+            {
+                fixed (byte* ptr = buffer)
+                {
+                    return Hash64(ptr, buffer.Length);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Generate a 64-bit xxHash value.
+        /// </summary>
+        /// <param name="buffer">Input buffer.</param>
+        /// <param name="bufferLength">Input buffer length.</param>
+        /// <param name="seed">Optional seed.</param>
+        /// <returns>Computed 64-bit hash value.</returns>
+        public static unsafe ulong Hash64(byte* buffer, int bufferLength, ulong seed = 0)
+        {
+            const int stripeLength = 32;
+
+            int len = bufferLength;
+            int remainingLen = len;
+            ulong acc;
+
+            byte* pInput = buffer;
+            if (len >= stripeLength)
+            {
+                ulong acc1 = seed + k_Prime64v1 + k_Prime64v2;
+                ulong acc2 = seed + k_Prime64v2;
+                ulong acc3 = seed;
+                ulong acc4 = seed - k_Prime64v1;
+
+                do
+                {
+                    acc = processStripe64(ref pInput, ref acc1, ref acc2, ref acc3, ref acc4);
+                    remainingLen -= stripeLength;
+                } while (remainingLen >= stripeLength);
+            }
+            else
+            {
+                acc = seed + k_Prime64v5;
+            }
+
+            acc += (ulong)len;
+            acc = processRemaining64(pInput, acc, remainingLen);
+
+
+            return avalanche64(acc);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static unsafe ulong processStripe64(
+            ref byte* pInput,
+            ref ulong acc1,
+            ref ulong acc2,
+            ref ulong acc3,
+            ref ulong acc4)
+        {
+            processLane64(ref acc1, ref pInput);
+            processLane64(ref acc2, ref pInput);
+            processLane64(ref acc3, ref pInput);
+            processLane64(ref acc4, ref pInput);
+
+            ulong acc = Bits.RotateLeft(acc1, 1)
+                        + Bits.RotateLeft(acc2, 7)
+                        + Bits.RotateLeft(acc3, 12)
+                        + Bits.RotateLeft(acc4, 18);
+
+            mergeAccumulator64(ref acc, acc1);
+            mergeAccumulator64(ref acc, acc2);
+            mergeAccumulator64(ref acc, acc3);
+            mergeAccumulator64(ref acc, acc4);
+            return acc;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static unsafe void processLane64(ref ulong accn, ref byte* pInput)
+        {
+            ulong lane = *(ulong*)pInput;
+            accn = round64(accn, lane);
+            pInput += 8;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static unsafe ulong processRemaining64(
+            byte* pInput,
+            ulong acc,
+            int remainingLen)
+        {
+            for (ulong lane; remainingLen >= 8; remainingLen -= 8, pInput += 8)
+            {
+                lane = *(ulong*)pInput;
+
+                acc ^= round64(0, lane);
+                acc = Bits.RotateLeft(acc, 27) * k_Prime64v1;
+                acc += k_Prime64v4;
+            }
+
+            for (uint lane32; remainingLen >= 4; remainingLen -= 4, pInput += 4)
+            {
+                lane32 = *(uint*)pInput;
+
+                acc ^= lane32 * k_Prime64v1;
+                acc = Bits.RotateLeft(acc, 23) * k_Prime64v2;
+                acc += k_Prime64v3;
+            }
+
+            for (byte lane8; remainingLen >= 1; remainingLen--, pInput++)
+            {
+                lane8 = *pInput;
+                acc ^= lane8 * k_Prime64v5;
+                acc = Bits.RotateLeft(acc, 11) * k_Prime64v1;
+            }
+
+            return acc;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static ulong avalanche64(ulong acc)
+        {
+            acc ^= acc >> 33;
+            acc *= k_Prime64v2;
+            acc ^= acc >> 29;
+            acc *= k_Prime64v3;
+            acc ^= acc >> 32;
+            return acc;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static ulong round64(ulong accn, ulong lane)
+        {
+            accn += lane * k_Prime64v2;
+            return Bits.RotateLeft(accn, 31) * k_Prime64v1;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static void mergeAccumulator64(ref ulong acc, ulong accn)
+        {
+            acc ^= round64(0, accn);
+            acc *= k_Prime64v1;
+            acc += k_Prime64v4;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static unsafe uint processStripe32(
+            ref byte* pInput,
+            ref uint acc1,
+            ref uint acc2,
+            ref uint acc3,
+            ref uint acc4)
+        {
+            processLane32(ref pInput, ref acc1);
+            processLane32(ref pInput, ref acc2);
+            processLane32(ref pInput, ref acc3);
+            processLane32(ref pInput, ref acc4);
+
+            return Bits.RotateLeft(acc1, 1)
+                   + Bits.RotateLeft(acc2, 7)
+                   + Bits.RotateLeft(acc3, 12)
+                   + Bits.RotateLeft(acc4, 18);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static unsafe void processLane32(ref byte* pInput, ref uint accn)
+        {
+            uint lane = *(uint*)pInput;
+            accn = round32(accn, lane);
+            pInput += 4;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static unsafe uint processRemaining32(
+            byte* pInput,
+            uint acc,
+            int remainingLen)
+        {
+            for (uint lane; remainingLen >= 4; remainingLen -= 4, pInput += 4)
+            {
+                lane = *(uint*)pInput;
+                acc += lane * k_Prime32v3;
+                acc = Bits.RotateLeft(acc, 17) * k_Prime32v4;
+            }
+
+            for (byte lane; remainingLen >= 1; remainingLen--, pInput++)
+            {
+                lane = *pInput;
+                acc += lane * k_Prime32v5;
+                acc = Bits.RotateLeft(acc, 11) * k_Prime32v1;
+            }
+
+            return acc;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static uint round32(uint accn, uint lane)
+        {
+            accn += lane * k_Prime32v2;
+            accn = Bits.RotateLeft(accn, 13);
+            accn *= k_Prime32v1;
+            return accn;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static uint avalanche32(uint acc)
+        {
+            acc ^= acc >> 15;
+            acc *= k_Prime32v2;
+            acc ^= acc >> 13;
+            acc *= k_Prime32v3;
+            acc ^= acc >> 16;
+            return acc;
+        }
+
+        /// <summary>
+        /// Bit operations.
+        /// </summary>
+        private static class Bits
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            internal static ulong RotateLeft(ulong value, int bits)
+            {
+                return (value << bits) | (value >> (64 - bits));
+            }
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            internal static uint RotateLeft(uint value, int bits)
+            {
+                return (value << bits) | (value >> (32 - bits));
+            }
+        }
+    }
+}

package/Runtime/Core/Math/XXHash.cs.meta

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

package/Runtime/Core/Math.meta

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

package/Runtime/Core/Model/Direction.cs

@@ -0,0 +1,26 @@
+namespace UnityHelpers.Core.Model
+{
+    using System;
+    using System.Runtime.Serialization;
+
+    [Flags]
+    [Serializable]
+    public enum Direction : short
+    {
+        [EnumMember] None = 0,
+        [EnumMember] North = 1,
+        [EnumMember] NorthEast = 2,
+        [EnumMember] East = 4,
+        [EnumMember] SouthEast = 8,
+        [EnumMember] South = 16,
+        [EnumMember] SouthWest = 32,
+        [EnumMember] West = 64,
+        [EnumMember] NorthWest = 128
+    }
+
+    public static class DirectionConstants
+    {
+        public const int NumDirections = 4;
+        public const int AllDirections = 8;
+    }
+}

package/Runtime/Core/Model/Direction.cs.meta

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