com.wallstop-studios.unity-helpers 2.0.0-rc26 → 2.0.0-rc30

package/Runtime/Core/Math/Line.cs

@@ -1,55 +1,55 @@
-namespace UnityHelpers.Core.Math
-{
-    using System;
-    using System.Runtime.Serialization;
-    using Extension;
-    using UnityEngine;
-
-    // https://pastebin.com/iQDhQTFN
-    [Serializable]
-    [DataContract]
-    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;
-        }
-    }
-}
+namespace UnityHelpers.Core.Math
+{
+    using System;
+    using System.Runtime.Serialization;
+    using Extension;
+    using UnityEngine;
+
+    // https://pastebin.com/iQDhQTFN
+    [Serializable]
+    [DataContract]
+    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/Parabola.cs

@@ -1,47 +1,47 @@
-namespace UnityHelpers.Core.Math
-{
-    using System;
-    using System.Runtime.Serialization;
-
-    [DataContract]
-    [Serializable]
-    public readonly struct 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;
-        }
-    }
-}
+namespace UnityHelpers.Core.Math
+{
+    using System;
+    using System.Runtime.Serialization;
+
+    [DataContract]
+    [Serializable]
+    public readonly struct 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/PointPolygonCheck.cs

@@ -1,36 +1,36 @@
-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;
-        }
-    }
-}
+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

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

package/Runtime/Core/Math/Range.cs

@@ -1,92 +1,92 @@
-namespace UnityHelpers.Core.Math
-{
-    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>
-    {
-        [DataMember]
-        [JsonInclude]
-        public T min;
-
-        [DataMember]
-        [JsonInclude]
-        public T max;
-
-        [DataMember]
-        [JsonInclude]
-        public bool startInclusive;
-
-        [DataMember]
-        [JsonInclude]
-        public bool endInclusive;
-
-        [JsonConstructor]
-        public Range(T min, T max, bool startInclusive = true, bool endInclusive = true)
-        {
-            this.min = min;
-            this.max = max;
-            this.startInclusive = startInclusive;
-            this.endInclusive = endInclusive;
-        }
-
-        public bool Equals(Range<T> other)
-        {
-            return min.Equals(other.min)
-                && max.Equals(other.max)
-                && startInclusive == other.startInclusive
-                && endInclusive == other.endInclusive;
-        }
-
-        public override bool Equals(object obj)
-        {
-            return obj is Range<T> other && Equals(other);
-        }
-
-        public override int GetHashCode()
-        {
-            return Objects.HashCode(min, max, startInclusive, endInclusive);
-        }
-
-        public override string ToString()
-        {
-            return this.ToJson();
-        }
-
-        public bool WithinRange(T value)
-        {
-            int comparison = value.CompareTo(min);
-            if (comparison < 0)
-            {
-                return false;
-            }
-
-            if (!startInclusive && comparison == 0)
-            {
-                return false;
-            }
-
-            comparison = value.CompareTo(max);
-            if (0 < comparison)
-            {
-                return false;
-            }
-
-            if (!endInclusive && comparison == 0)
-            {
-                return false;
-            }
-
-            return true;
-        }
-    }
-}
+namespace UnityHelpers.Core.Math
+{
+    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>
+    {
+        [DataMember]
+        [JsonInclude]
+        public T min;
+
+        [DataMember]
+        [JsonInclude]
+        public T max;
+
+        [DataMember]
+        [JsonInclude]
+        public bool startInclusive;
+
+        [DataMember]
+        [JsonInclude]
+        public bool endInclusive;
+
+        [JsonConstructor]
+        public Range(T min, T max, bool startInclusive = true, bool endInclusive = true)
+        {
+            this.min = min;
+            this.max = max;
+            this.startInclusive = startInclusive;
+            this.endInclusive = endInclusive;
+        }
+
+        public bool Equals(Range<T> other)
+        {
+            return min.Equals(other.min)
+                && max.Equals(other.max)
+                && startInclusive == other.startInclusive
+                && endInclusive == other.endInclusive;
+        }
+
+        public override bool Equals(object obj)
+        {
+            return obj is Range<T> other && Equals(other);
+        }
+
+        public override int GetHashCode()
+        {
+            return Objects.HashCode(min, max, startInclusive, endInclusive);
+        }
+
+        public override string ToString()
+        {
+            return this.ToJson();
+        }
+
+        public bool WithinRange(T value)
+        {
+            int comparison = value.CompareTo(min);
+            if (comparison < 0)
+            {
+                return false;
+            }
+
+            if (!startInclusive && comparison == 0)
+            {
+                return false;
+            }
+
+            comparison = value.CompareTo(max);
+            if (0 < comparison)
+            {
+                return false;
+            }
+
+            if (!endInclusive && comparison == 0)
+            {
+                return false;
+            }
+
+            return true;
+        }
+    }
+}