com.wallstop-studios.unity-helpers 2.0.0-rc76.4 → 2.0.0-rc76.6

package/Editor/Sprites/SpriteSheetAnimationCreator.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 55327b3f69ee4fde80aba6acb4e233b2
+timeCreated: 1748619699

package/Runtime/Core/DataStructure/CyclicBuffer.cs

@@ -3,7 +3,6 @@
     using System;
     using System.Collections;
     using System.Collections.Generic;
-    using System.Linq;
     using Extension;
     using Helper;
 
@@ -53,7 +52,6 @@
         public int Count { get; private set; }
 
         private readonly List<T> _buffer;
-        private readonly List<T> _cache;
         private int _position;
 
         public T this[int index]
@@ -81,7 +79,6 @@
             _position = 0;
             Count = 0;
             _buffer = new List<T>();
-            _cache = new List<T>();
             if (initialContents != null)
             {
                 foreach (T item in initialContents)
@@ -131,17 +128,26 @@
 
         public bool Remove(T element, IEqualityComparer<T> comparer = null)
         {
+            if (Count == 0)
+            {
+                return false;
+            }
+
+            int write = 0;
             bool removed = false;
-            _cache.Clear();
             comparer ??= EqualityComparer<T>.Default;
-            foreach (T item in this)
+            for (int i = 0; i < Count; ++i)
             {
+                int readIdx = AdjustedIndexFor(i);
+                T item = _buffer[readIdx];
+
                 if (!removed && comparer.Equals(item, element))
                 {
                     removed = true;
                     continue;
                 }
-                _cache.Add(item);
+
+                _buffer[write++] = item;
             }
 
             if (!removed)
@@ -149,27 +155,34 @@
                 return false;
             }
 
-            Clear();
-            foreach (T item in _cache)
-            {
-                Add(item);
-            }
+            _buffer.RemoveRange(write, _buffer.Count - write);
 
+            Count--;
+            _position = Count < Capacity ? Count : 0;
             return true;
         }
 
         public int RemoveAll(Func<T, bool> predicate)
         {
+            if (Count == 0)
+            {
+                return 0;
+            }
+
+            int write = 0;
             int removedCount = 0;
-            foreach (T item in this)
+
+            for (int i = 0; i < Count; ++i)
             {
+                int readIdx = AdjustedIndexFor(i);
+                T item = _buffer[readIdx];
                 if (predicate(item))
                 {
                     removedCount++;
                 }
                 else
                 {
-                    _cache.Add(item);
+                    _buffer[write++] = item;
                 }
             }
 
@@ -178,12 +191,9 @@
                 return 0;
             }
 
-            Clear();
-            foreach (T item in _cache)
-            {
-                Add(item);
-            }
-
+            _buffer.RemoveRange(write, _buffer.Count - write);
+            Count -= removedCount;
+            _position = Count < Capacity ? Count : 0;
             return removedCount;
         }
 

package/Runtime/Core/Extension/DictionaryExtensions.cs

@@ -144,10 +144,11 @@
 
         public static Dictionary<K, V> Merge<K, V>(
             this IReadOnlyDictionary<K, V> lhs,
-            IReadOnlyDictionary<K, V> rhs
+            IReadOnlyDictionary<K, V> rhs,
+            Func<Dictionary<K, V>> creator = null
         )
         {
-            Dictionary<K, V> result = new();
+            Dictionary<K, V> result = creator?.Invoke() ?? new Dictionary<K, V>();
             if (0 < lhs.Count)
             {
                 foreach (KeyValuePair<K, V> kvp in lhs)
@@ -176,10 +177,11 @@
         /// <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
+            IReadOnlyDictionary<K, V> rhs,
+            Func<Dictionary<K, V>> creator = null
         )
         {
-            Dictionary<K, V> result = new(rhs.Count);
+            Dictionary<K, V> result = creator?.Invoke() ?? new Dictionary<K, V>(rhs.Count);
             foreach (KeyValuePair<K, V> kvp in rhs)
             {
                 K key = kvp.Key;
@@ -194,9 +196,12 @@
             return result;
         }
 
-        public static Dictionary<V, K> Reverse<K, V>(this IReadOnlyDictionary<K, V> dictionary)
+        public static Dictionary<V, K> Reverse<K, V>(
+            this IReadOnlyDictionary<K, V> dictionary,
+            Func<Dictionary<V, K>> creator = null
+        )
         {
-            Dictionary<V, K> output = new(dictionary.Count);
+            Dictionary<V, K> output = creator?.Invoke() ?? new Dictionary<V, K>(dictionary.Count);
             foreach (KeyValuePair<K, V> entry in dictionary)
             {
                 output[entry.Value] = entry.Key;
@@ -264,10 +269,25 @@
                 return false;
             }
 
-            return dictionary.Count == other.Count
-                && dictionary.All(kvp =>
-                    other.TryGetValue(kvp.Key, out V value) && kvp.Value.Equals(value)
-                );
+            if (dictionary.Count != other.Count)
+            {
+                return false;
+            }
+
+            if (dictionary.Count == 0)
+            {
+                return true;
+            }
+
+            foreach (KeyValuePair<K, V> entry in dictionary)
+            {
+                if (!other.TryGetValue(entry.Key, out V value) || !entry.Value.Equals(value))
+                {
+                    return false;
+                }
+            }
+
+            return true;
         }
 
         public static void Deconstruct<K, V>(this KeyValuePair<K, V> kvp, out K key, out V value)

package/Runtime/Core/Extension/IEnumerableExtensions.cs

@@ -33,13 +33,13 @@
             FuncBasedComparer<T> comparerObject =
                 (FuncBasedComparer<T>)
                     ComparerCache.GetOrAdd(comparer, () => new FuncBasedComparer<T>(comparer));
-            return enumeration.OrderBy(_ => _, comparerObject);
+            return enumeration.OrderBy(x => x, comparerObject);
         }
 
         public static IEnumerable<T> Ordered<T>(this IEnumerable<T> enumerable)
             where T : IComparable
         {
-            return enumerable.OrderBy(_ => _);
+            return enumerable.OrderBy(x => x);
         }
 
         public static IEnumerable<T> Shuffled<T>(
@@ -47,7 +47,7 @@
             IRandom random = null
         )
         {
-            random = random ?? ThreadLocalRandom<PcgRandom>.Instance;
+            random ??= ThreadLocalRandom<PcgRandom>.Instance;
             return enumerable.OrderBy(_ => random.Next());
         }
 
@@ -81,6 +81,13 @@
             using IEnumerator<T> enumerator = items.GetEnumerator();
             bool hasNext = enumerator.MoveNext();
 
+            while (hasNext)
+            {
+                yield return NextPartitionOf().ToList();
+            }
+
+            yield break;
+
             IEnumerable<T> NextPartitionOf()
             {
                 int remainingCountForPartition = size;
@@ -90,11 +97,6 @@
                     hasNext = enumerator.MoveNext();
                 }
             }
-
-            while (hasNext)
-            {
-                yield return NextPartitionOf().ToList();
-            }
         }
 
         public static List<T> ToList<T>(this IEnumerable<T> enumerable, int count)
@@ -113,9 +115,9 @@
                 _comparer = comparer ?? throw new ArgumentNullException(nameof(comparer));
             }
 
-            public int Compare(T lhs, T rhs)
+            public int Compare(T x, T y)
             {
-                return _comparer(lhs, rhs);
+                return _comparer(x, y);
             }
         }
     }

package/Runtime/Core/Extension/IListExtensions.cs

@@ -110,14 +110,20 @@
             switch (inputList)
             {
                 case T[] array:
+                {
                     Array.Sort(array, UnityObjectNameComparer<T>.Instance);
                     return;
+                }
                 case List<T> list:
+                {
                     list.Sort(UnityObjectNameComparer<T>.Instance);
                     return;
+                }
                 default:
+                {
                     inputList.InsertionSort(UnityObjectNameComparer<T>.Instance);
                     break;
+                }
             }
         }
 

package/Runtime/Core/Extension/UnityExtensions.cs

@@ -1603,5 +1603,73 @@
             }
         }
 #endif
+
+        public static bool IsDontDestroyOnLoad(this GameObject gameObjectToCheck)
+        {
+            if (gameObjectToCheck == null)
+            {
+                return false;
+            }
+
+            return string.Equals(
+                gameObjectToCheck.scene.name,
+                "DontDestroyOnLoad",
+                StringComparison.Ordinal
+            );
+        }
+
+        public static bool IsCircleFullyContained(
+            this Collider2D targetCollider,
+            Vector2 center,
+            float radius,
+            int sampleCount = 16
+        )
+        {
+            for (int i = 0; i < sampleCount; ++i)
+            {
+                float angle = 2 * Mathf.PI / sampleCount * i;
+                Vector2 pointOnCircle =
+                    center + new Vector2(Mathf.Cos(angle), Mathf.Sin(angle)) * radius;
+
+                if (!targetCollider.OverlapPoint(pointOnCircle))
+                {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        public static void Invert(this PolygonCollider2D col, Rect outerRect)
+        {
+            int originalCount = col.pathCount;
+            if (originalCount == 0)
+            {
+                return;
+            }
+
+            Vector2[][] originals = new Vector2[originalCount][];
+            for (int i = 0; i < originalCount; i++)
+            {
+                originals[i] = col.GetPath(i).ToArray();
+            }
+
+            Vector2[] outerPath =
+            {
+                new Vector2(outerRect.xMin, outerRect.yMin),
+                new Vector2(outerRect.xMin, outerRect.yMax),
+                new Vector2(outerRect.xMax, outerRect.yMax),
+                new Vector2(outerRect.xMax, outerRect.yMin),
+            };
+
+            col.pathCount = originalCount + 1;
+            col.SetPath(0, outerPath);
+
+            for (int i = 0; i < originalCount; ++i)
+            {
+                Vector2[] hole = originals[i];
+                Array.Reverse(hole);
+                col.SetPath(i + 1, hole);
+            }
+        }
     }
 }

package/Runtime/Core/Helper/Helpers.cs

@@ -13,6 +13,9 @@
     using Object = UnityEngine.Object;
 #if UNITY_EDITOR
     using UnityEditor;
+    using UnityEditorInternal;
+#else
+    using System;
 #endif
 
     public static partial class Helpers
@@ -24,6 +27,15 @@
             StringComparer.Ordinal
         );
 
+        public static string[] GetAllLayerNames()
+        {
+#if UNITY_EDITOR
+            return InternalEditorUtility.layers;
+#else
+            return Array.Empty<string>();
+#endif
+        }
+
         // https://gamedevelopment.tutsplus.com/tutorials/unity-solution-for-hitting-moving-targets--cms-29633
         public static Vector2 PredictCurrentTarget(
             this GameObject currentTarget,

package/Runtime/Core/Helper/LineHelper.cs

@@ -0,0 +1,194 @@
+namespace WallstopStudios.UnityHelpers.Core.Helper
+{
+    using System.Collections.Generic;
+    using System.Linq;
+    using UnityEngine;
+
+    public static class LineHelper
+    {
+        private static float PerpendicularDistance(
+            Vector2 point,
+            Vector2 lineStart,
+            Vector2 lineEnd
+        )
+        {
+            float xDistance = lineEnd.x - lineStart.x;
+            float yDistance = lineEnd.y - lineStart.y;
+
+            if (Mathf.Approximately(xDistance, 0) && Mathf.Approximately(yDistance, 0))
+            {
+                return Vector2.Distance(point, lineStart);
+            }
+
+            float t =
+                ((point.x - lineStart.x) * xDistance + (point.y - lineStart.y) * yDistance)
+                / (xDistance * xDistance + yDistance * yDistance);
+
+            Vector2 closestPoint = t switch
+            {
+                < 0 => lineStart,
+                > 1 => lineEnd,
+                _ => new Vector2(lineStart.x + t * xDistance, lineStart.y + t * yDistance),
+            };
+
+            return Vector2.Distance(point, closestPoint);
+        }
+
+        // c# implementation of the Ramer-Douglas-Peucker-Algorithm by Craig Selbert slightly adapted for Unity Vector Types
+        //http://www.codeproject.com/Articles/18936/A-Csharp-Implementation-of-Douglas-Peucker-Line-Ap
+        public static List<Vector2> SimplifyPrecise(List<Vector2> points, double tolerance)
+        {
+            if (points == null || points.Count < 3)
+            {
+                return points;
+            }
+
+            int firstPoint = 0;
+            int lastPoint = points.Count - 1;
+
+            //Add the first and last index to the keepers
+            List<int> pointIndexsToKeep = new() { firstPoint, lastPoint };
+
+            //The first and the last point cannot be the same
+            while (points[firstPoint] == points[lastPoint])
+            {
+                lastPoint--;
+            }
+
+            DouglasPeuckerReductionRecursive(
+                points,
+                firstPoint,
+                lastPoint,
+                tolerance,
+                ref pointIndexsToKeep
+            );
+
+            List<Vector2> returnPoints = new();
+            pointIndexsToKeep.Sort();
+            foreach (int index in pointIndexsToKeep)
+            {
+                returnPoints.Add(points[index]);
+            }
+
+            return returnPoints;
+        }
+
+        private static void DouglasPeuckerReductionRecursive(
+            List<Vector2> points,
+            int firstPoint,
+            int lastPoint,
+            double tolerance,
+            ref List<int> pointIndexesToKeep
+        )
+        {
+            while (true)
+            {
+                double maxDistance = 0;
+                int indexFarthest = 0;
+
+                for (int index = firstPoint; index < lastPoint; index++)
+                {
+                    double distance = InternalPerpendicularDistance(
+                        points[firstPoint],
+                        points[lastPoint],
+                        points[index]
+                    );
+                    if (distance > maxDistance)
+                    {
+                        maxDistance = distance;
+                        indexFarthest = index;
+                    }
+                }
+
+                if (maxDistance > tolerance && indexFarthest != 0)
+                {
+                    //Add the largest point that exceeds the tolerance
+                    pointIndexesToKeep.Add(indexFarthest);
+
+                    DouglasPeuckerReductionRecursive(
+                        points,
+                        firstPoint,
+                        indexFarthest,
+                        tolerance,
+                        ref pointIndexesToKeep
+                    );
+
+                    firstPoint = indexFarthest;
+                    continue;
+                }
+
+                break;
+            }
+
+            return;
+
+            static double InternalPerpendicularDistance(
+                Vector2 point1,
+                Vector2 point2,
+                Vector2 point
+            )
+            {
+                double area = System.Math.Abs(
+                    .5f
+                        * (
+                            point1.x * point2.y
+                            + point2.x * point.y
+                            + point.x * point1.y
+                            - point2.x * point1.y
+                            - point.x * point2.y
+                            - point1.x * point.y
+                        )
+                );
+                double bottom = System.Math.Sqrt(
+                    System.Math.Pow(point1.x - point2.x, 2.0)
+                        + System.Math.Pow(point1.y - point2.y, 2.0)
+                );
+                double height = area / bottom * 2.0;
+                return height;
+            }
+        }
+
+        public static List<Vector2> Simplify(List<Vector2> points, float epsilon)
+        {
+            if (points == null || points.Count < 3 || epsilon <= 0)
+            {
+                return new List<Vector2>(points ?? Enumerable.Empty<Vector2>());
+            }
+
+            float maxDistance = 0;
+            int index = 0;
+            int end = points.Count - 1;
+
+            for (int i = 1; i < end; ++i)
+            {
+                float distance = PerpendicularDistance(points[i], points[0], points[end]);
+                if (distance > maxDistance)
+                {
+                    index = i;
+                    maxDistance = distance;
+                }
+            }
+
+            List<Vector2> result = new();
+
+            if (maxDistance > epsilon)
+            {
+                List<Vector2> recResults1 = Simplify(points.GetRange(0, index + 1), epsilon);
+                List<Vector2> recResults2 = Simplify(
+                    points.GetRange(index, points.Count - index),
+                    epsilon
+                );
+
+                result.AddRange(recResults1.Take(recResults1.Count - 1));
+                result.AddRange(recResults2);
+            }
+            else
+            {
+                result.Add(points[0]);
+                result.Add(points[end]);
+            }
+
+            return result;
+        }
+    }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 0b74d35d6b084ca2802d2955ff5a4365
+timeCreated: 1748562665

package/Runtime/Tags/CollisionSenses.cs

@@ -0,0 +1,91 @@
+namespace WallstopStudios.UnityHelpers.Tags
+{
+    using System;
+    using System.Collections.Generic;
+    using Core.Attributes;
+    using UnityEngine;
+
+    [DisallowMultipleComponent]
+    [RequireComponent(typeof(TagHandler))]
+    public sealed class CollisionSenses : MonoBehaviour
+    {
+        public const string CollisionDisabledTag = nameof(CollisionDisabledTag);
+
+        [SiblingComponent]
+        private TagHandler _tagHandler;
+
+        private readonly List<Collider2D> _managedColliders = new();
+
+        private void Awake()
+        {
+            this.AssignRelationalComponents();
+        }
+
+        private void OnEnable()
+        {
+            if (_tagHandler.HasTag(CollisionDisabledTag))
+            {
+                StartManagingColliders();
+            }
+
+            _tagHandler.OnTagAdded += CheckForTagAddition;
+            _tagHandler.OnTagRemoved += CheckForTagRemoval;
+        }
+
+        private void OnDisable()
+        {
+            _tagHandler.OnTagAdded -= CheckForTagAddition;
+            _tagHandler.OnTagRemoved -= CheckForTagRemoval;
+            StopManagingColliders();
+        }
+
+        private void CheckForTagAddition(string addedTag)
+        {
+            if (!isActiveAndEnabled)
+            {
+                return;
+            }
+
+            if (string.Equals(addedTag, CollisionDisabledTag, StringComparison.Ordinal))
+            {
+                StartManagingColliders();
+            }
+        }
+
+        private void CheckForTagRemoval(string removedTag)
+        {
+            if (!isActiveAndEnabled)
+            {
+                return;
+            }
+
+            if (string.Equals(removedTag, CollisionDisabledTag, StringComparison.Ordinal))
+            {
+                StopManagingColliders();
+            }
+        }
+
+        private void StopManagingColliders()
+        {
+            foreach (Collider2D managedCollider in _managedColliders)
+            {
+                if (managedCollider != null)
+                {
+                    managedCollider.enabled = true;
+                }
+            }
+
+            _managedColliders.Clear();
+        }
+
+        private void StartManagingColliders()
+        {
+            GetComponentsInChildren(_managedColliders);
+            _managedColliders.RemoveAll(managed => !managed.enabled);
+            foreach (Collider2D managedCollider in _managedColliders)
+            {
+                managedCollider.enabled = false;
+            }
+        }
+    }
+}

package/Runtime/Tags/CollisionSenses.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 4157eb60e7a64fcda98a72acb17bf2c3
+timeCreated: 1748569172