com.wallstop-studios.unity-helpers 2.0.0-rc76.2 → 2.0.0-rc76.5

package/Editor/CustomDrawers/WShowIfPropertyDrawer.cs

@@ -2,6 +2,7 @@
 {
 #if UNITY_EDITOR
     using System.Reflection;
+    using Extensions;
     using UnityEditor;
     using UnityEngine;
     using WallstopStudios.UnityHelpers.Core.Attributes;

package/Editor/CustomEditors/PolygonCollider2DOptimizerEditor.cs

@@ -0,0 +1,40 @@
+namespace WallstopStudios.UnityHelpers.Editor.CustomEditors
+{
+#if UNITY_EDITOR
+    using UnityEditor;
+    using UnityEngine;
+    using UnityHelpers.Utils;
+
+    [CustomEditor(typeof(PolygonCollider2DOptimizer))]
+    public sealed class PolygonCollider2DOptimizerEditor : Editor
+    {
+        private SerializedProperty _tolerance;
+
+        private void OnEnable()
+        {
+            _tolerance = serializedObject.FindProperty(
+                nameof(PolygonCollider2DOptimizer.tolerance)
+            );
+        }
+
+        public override void OnInspectorGUI()
+        {
+            serializedObject.Update();
+            if (EditorGUILayout.PropertyField(_tolerance))
+            {
+                serializedObject.ApplyModifiedProperties();
+            }
+
+            if (GUILayout.Button("Optimize"))
+            {
+                PolygonCollider2DOptimizer optimizer = target as PolygonCollider2DOptimizer;
+                if (optimizer != null)
+                {
+                    optimizer.Refresh();
+                }
+                serializedObject.ApplyModifiedProperties();
+            }
+        }
+    }
+#endif
+}

package/Editor/CustomEditors/PolygonCollider2DOptimizerEditor.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: df2a6833fa1643b1abb304382b3ab03b
+timeCreated: 1748568224

package/{Runtime/Core/Extension → Editor/Extensions}/SerializedPropertyExtensions.cs

@@ -1,4 +1,4 @@
-namespace WallstopStudios.UnityHelpers.Core.Extension
+namespace WallstopStudios.UnityHelpers.Editor.Extensions
 {
 #if UNITY_EDITOR
     using System;

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/EnumExtensions.cs

@@ -16,8 +16,8 @@ namespace WallstopStudios.UnityHelpers.Core.Extension
 
         private static readonly bool UseDensePacking;
         private static readonly int Min;
-        private static readonly string[]? DenseNames;
-        private static readonly Dictionary<int, string>? SparseNames;
+        private static readonly string[] DenseNames;
+        private static readonly Dictionary<int, string> SparseNames;
 
         static EnumNameCache()
         {
@@ -85,8 +85,8 @@ namespace WallstopStudios.UnityHelpers.Core.Extension
 
         private static readonly bool UseDensePacking;
         private static readonly int Min;
-        private static readonly string[]? DenseNames;
-        private static readonly Dictionary<int, string>? SparseNames;
+        private static readonly string[] DenseNames;
+        private static readonly Dictionary<int, string> SparseNames;
 
         static EnumDisplayNameCache()
         {

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/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

package/Runtime/Utils/ChildSpawner.cs

@@ -0,0 +1,100 @@
+namespace WallstopStudios.UnityHelpers.Utils
+{
+    using System.Collections.Generic;
+    using System.Linq;
+    using Core.Extension;
+    using UnityEngine;
+
+    [DisallowMultipleComponent]
+    public sealed class ChildSpawner : MonoBehaviour
+    {
+        private static readonly HashSet<GameObject> SpawnedPrefabs = new();
+
+        [SerializeField]
+        private GameObject[] _prefabs;
+
+        [SerializeField]
+        private GameObject[] _editorOnlyPrefabs;
+
+        [SerializeField]
+        private GameObject[] _developmentOnlyPrefabs;
+
+        private void Start()
+        {
+            if (
+                _prefabs
+                    .Concat(_editorOnlyPrefabs)
+                    .Concat(_developmentOnlyPrefabs)
+                    .Distinct()
+                    .Count()
+                != (_prefabs.Length + _editorOnlyPrefabs.Length + _developmentOnlyPrefabs.Length)
+            )
+            {
+                IEnumerable<string> duplicateChildNames = _prefabs
+                    .Concat(_editorOnlyPrefabs)
+                    .Concat(_developmentOnlyPrefabs)
+                    .GroupBy(x => x)
+                    .Where(group => group.Count() > 1)
+                    .Select(group => group.Key != null ? group.Key.name : "null");
+                this.LogError(
+                    $"Duplicate child prefab detected: {string.Join(",", duplicateChildNames)}"
+                );
+            }
+
+            int count = 0;
+            foreach (GameObject prefab in _prefabs)
+            {
+                GameObject child = Spawn(prefab);
+                if (child != null)
+                {
+                    child.name = $"{child.name} ({count++:00})";
+                }
+            }
+
+            if (Application.isEditor)
+            {
+                foreach (GameObject prefab in _editorOnlyPrefabs)
+                {
+                    GameObject child = Spawn(prefab);
+                    if (child != null)
+                    {
+                        child.name = $"{child.name} (EDITOR-ONLY {count++:00})";
+                    }
+                }
+            }
+
+            if (Application.isEditor || Debug.isDebugBuild)
+            {
+                foreach (GameObject prefab in _developmentOnlyPrefabs)
+                {
+                    GameObject child = Spawn(prefab);
+                    if (child != null)
+                    {
+                        child.name = $"{child.name} (DEVELOPMENT-ONLY {count++:00})";
+                    }
+                }
+            }
+        }
+
+        private static void CleanName(GameObject child)
+        {
+            child.name = child.name.Replace("(Clone)", string.Empty);
+        }
+
+        private GameObject Spawn(GameObject prefab)
+        {
+            if (SpawnedPrefabs.Contains(prefab))
+            {
+                return null;
+            }
+
+            GameObject child = Instantiate(prefab, transform);
+            CleanName(child);
+            if (child.IsDontDestroyOnLoad() || gameObject.IsDontDestroyOnLoad())
+            {
+                SpawnedPrefabs.Add(prefab);
+            }
+            return child;
+        }
+    }
+}

package/Runtime/Utils/ChildSpawner.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 2b3c4b1f5ea74914be632464d47b345b
+timeCreated: 1748569304

package/Runtime/Utils/CollisionProxy.cs

@@ -0,0 +1,48 @@
+namespace WallstopStudios.UnityHelpers.Utils
+{
+    using System;
+    using UnityEngine;
+
+    [DisallowMultipleComponent]
+    [RequireComponent(typeof(Collider2D))]
+    public sealed class CollisionProxy : MonoBehaviour
+    {
+        public event Action<Collision2D> OnCollisionEnter = _ => { };
+        public event Action<Collision2D> OnCollisionStay = _ => { };
+        public event Action<Collision2D> OnCollisionExit = _ => { };
+
+        public event Action<Collider2D> OnTriggerEnter = _ => { };
+        public event Action<Collider2D> OnTriggerStay = _ => { };
+        public event Action<Collider2D> OnTriggerExit = _ => { };
+
+        private void OnTriggerEnter2D(Collider2D other)
+        {
+            OnTriggerEnter?.Invoke(other);
+        }
+
+        private void OnTriggerStay2D(Collider2D other)
+        {
+            OnTriggerStay?.Invoke(other);
+        }
+
+        private void OnTriggerExit2D(Collider2D other)
+        {
+            OnTriggerExit?.Invoke(other);
+        }
+
+        private void OnCollisionEnter2D(Collision2D other)
+        {
+            OnCollisionEnter?.Invoke(other);
+        }
+
+        private void OnCollisionStay2D(Collision2D other)
+        {
+            OnCollisionStay?.Invoke(other);
+        }
+
+        private void OnCollisionExit2D(Collision2D other)
+        {
+            OnCollisionExit?.Invoke(other);
+        }
+    }
+}

package/Runtime/Utils/CollisionProxy.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 9d8886d28ef545d8967a436999bea13e
+timeCreated: 1748569245

package/Runtime/Utils/PolygonCollider2DOptimizer.cs

@@ -0,0 +1,83 @@
+namespace WallstopStudios.UnityHelpers.Utils
+{
+    using System;
+    using System.Collections.Generic;
+    using Core.Attributes;
+    using Core.Helper;
+    using UnityEngine;
+
+    /// <summary>
+    /// Polygon collider optimizer. Removes points from the collider polygon with
+    /// the given reduction Tolerance
+    /// </summary>
+    [AddComponentMenu("2D Collider Optimization/ Polygon Collider Optimizer")]
+    [RequireComponent(typeof(PolygonCollider2D))]
+    public sealed class PolygonCollider2DOptimizer : MonoBehaviour
+    {
+        [Serializable]
+        private sealed class Path
+        {
+            public List<Vector2> points = new();
+
+            public Path() { }
+
+            public Path(IEnumerable<Vector2> points)
+            {
+                this.points.AddRange(points);
+            }
+        }
+
+        public double tolerance;
+
+        [SiblingComponent]
+        private PolygonCollider2D _collider;
+
+        [SerializeField]
+        private List<Path> _originalPaths = new();
+
+        public void Refresh()
+        {
+            OnValidate();
+        }
+
+        private void OnValidate()
+        {
+            if (_collider == null)
+            {
+                this.AssignRelationalComponents();
+            }
+
+            /*
+                When first getting a reference to the collider save the paths
+                so that the optimization is re-doable (by performing it on the original path
+                every time)
+             */
+            if (_originalPaths.Count == 0)
+            {
+                for (int i = 0; i < _collider.pathCount; ++i)
+                {
+                    List<Vector2> points = new(_collider.GetPath(i));
+                    Path path = new(points);
+                    _originalPaths.Add(path);
+                }
+            }
+
+            //Reset the original paths
+            if (tolerance <= 0)
+            {
+                for (int i = 0; i < _originalPaths.Count; ++i)
+                {
+                    _collider.SetPath(i, _originalPaths[i].points.ToArray());
+                }
+                return;
+            }
+
+            for (int i = 0; i < _originalPaths.Count; ++i)
+            {
+                List<Vector2> path = _originalPaths[i].points;
+                List<Vector2> updatedPath = LineHelper.SimplifyPrecise(path, tolerance);
+                _collider.SetPath(i, updatedPath.ToArray());
+            }
+        }
+    }
+}

package/Runtime/Utils/PolygonCollider2DOptimizer.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 9363f4728d254b8bae1afb829777d9d3
+timeCreated: 1748566207

package/Runtime/Utils/SerializedStringComparer.cs

@@ -0,0 +1,107 @@
+namespace WallstopStudios.UnityHelpers.Utils
+{
+    using System;
+    using System.Collections.Generic;
+    using System.ComponentModel;
+
+    [Serializable]
+    public sealed class SerializedStringComparer : IEqualityComparer<string>
+    {
+        public enum StringCompareMode
+        {
+            Ordinal = 0,
+            OrdinalIgnoreCase = 1,
+            CurrentCulture = 2,
+            CurrentCultureIgnoreCase = 3,
+            InvariantCulture = 4,
+            InvariantCultureIgnoreCase = 5,
+        }
+
+        public StringCompareMode compareMode = StringCompareMode.Ordinal;
+
+        public SerializedStringComparer() { }
+
+        public SerializedStringComparer(StringCompareMode compareMode)
+        {
+            this.compareMode = compareMode;
+        }
+
+        public bool Equals(string x, string y)
+        {
+            switch (compareMode)
+            {
+                case StringCompareMode.Ordinal:
+                {
+                    return StringComparer.Ordinal.Equals(x, y);
+                }
+                case StringCompareMode.OrdinalIgnoreCase:
+                {
+                    return StringComparer.OrdinalIgnoreCase.Equals(x, y);
+                }
+                case StringCompareMode.CurrentCulture:
+                {
+                    return StringComparer.CurrentCulture.Equals(x, y);
+                }
+                case StringCompareMode.CurrentCultureIgnoreCase:
+                {
+                    return StringComparer.CurrentCultureIgnoreCase.Equals(x, y);
+                }
+                case StringCompareMode.InvariantCulture:
+                {
+                    return StringComparer.InvariantCulture.Equals(x, y);
+                }
+                case StringCompareMode.InvariantCultureIgnoreCase:
+                {
+                    return StringComparer.InvariantCultureIgnoreCase.Equals(x, y);
+                }
+                default:
+                {
+                    throw new InvalidEnumArgumentException(
+                        nameof(compareMode),
+                        (int)compareMode,
+                        typeof(StringCompareMode)
+                    );
+                }
+            }
+        }
+
+        public int GetHashCode(string obj)
+        {
+            switch (compareMode)
+            {
+                case StringCompareMode.Ordinal:
+                {
+                    return StringComparer.Ordinal.GetHashCode(obj);
+                }
+                case StringCompareMode.OrdinalIgnoreCase:
+                {
+                    return StringComparer.OrdinalIgnoreCase.GetHashCode(obj);
+                }
+                case StringCompareMode.CurrentCulture:
+                {
+                    return StringComparer.CurrentCulture.GetHashCode(obj);
+                }
+                case StringCompareMode.CurrentCultureIgnoreCase:
+                {
+                    return StringComparer.CurrentCultureIgnoreCase.GetHashCode(obj);
+                }
+                case StringCompareMode.InvariantCulture:
+                {
+                    return StringComparer.InvariantCulture.GetHashCode(obj);
+                }
+                case StringCompareMode.InvariantCultureIgnoreCase:
+                {
+                    return StringComparer.InvariantCultureIgnoreCase.GetHashCode(obj);
+                }
+                default:
+                {
+                    throw new InvalidEnumArgumentException(
+                        nameof(compareMode),
+                        (int)compareMode,
+                        typeof(StringCompareMode)
+                    );
+                }
+            }
+        }
+    }
+}

package/Runtime/Utils/SerializedStringComparer.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 2f66e3a62c374ef9a285d5e9e10f9fb2
+timeCreated: 1748568941

package/Tests/Runtime/DataStructures/CyclicBufferTests.cs

@@ -19,8 +19,8 @@
             Assert.Throws<ArgumentException>(() => new CyclicBuffer<int>(int.MinValue));
             for (int i = 0; i < NumTries; i++)
             {
-                Assert.Throws<ArgumentException>(
-                    () => new CyclicBuffer<int>(PRNG.Instance.Next(int.MinValue, -1))
+                Assert.Throws<ArgumentException>(() =>
+                    new CyclicBuffer<int>(PRNG.Instance.Next(int.MinValue, -1))
                 );
             }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "com.wallstop-studios.unity-helpers",
-  "version": "2.0.0-rc76.2",
+  "version": "2.0.0-rc76.5",
   "displayName": "Unity Helpers",
   "description": "Various Unity Helper Library",
   "dependencies": {},
@@ -74,6 +74,9 @@
 
 
 
+
+
+
 
 
 

package/Editor/UI.meta

@@ -1,3 +0,0 @@
-fileFormatVersion: 2
-guid: 6b8ee675c4ab4498bbf073237de1d78b
-timeCreated: 1748371749