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

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/Runtime/Utils/UnityObjectNameComparer.cs

@@ -2,6 +2,7 @@
 {
     using System;
     using System.Collections.Generic;
+    using System.Text.RegularExpressions;
 #if UNITY_EDITOR
     using UnityEditor;
 #endif
@@ -9,6 +10,10 @@
     public sealed class UnityObjectNameComparer<T> : IComparer<T>
         where T : UnityEngine.Object
     {
+        private static readonly Regex TrailingNumberRegex = new(
+            @"^(.*?)(\d+)$",
+            RegexOptions.Compiled
+        );
         public static readonly UnityObjectNameComparer<T> Instance = new();
 
         private UnityObjectNameComparer() { }
@@ -30,7 +35,7 @@
                 return -1;
             }
 
-            int comparison = string.Compare(x.name, y.name, StringComparison.OrdinalIgnoreCase);
+            int comparison = CompareNatural(x.name, y.name);
             if (comparison != 0)
             {
                 return comparison;
@@ -50,5 +55,45 @@
 
             return comparison;
         }
+
+        private static int CompareNatural(string nameA, string nameB)
+        {
+            Match mA = TrailingNumberRegex.Match(nameA);
+            Match mB = TrailingNumberRegex.Match(nameB);
+
+            bool hasNumberA = mA.Success;
+            bool hasNumberB = mB.Success;
+
+            // If both have trailing numbers, compare prefix then numeric
+            if (hasNumberA && hasNumberB)
+            {
+                string prefixA = mA.Groups[1].Value;
+                string prefixB = mB.Groups[1].Value;
+
+                int prefixCompare = StringComparer.OrdinalIgnoreCase.Compare(prefixA, prefixB);
+                if (prefixCompare != 0)
+                {
+                    return prefixCompare;
+                }
+
+                // same prefix → compare parsed integers
+                int numA = int.Parse(mA.Groups[2].Value);
+                int numB = int.Parse(mB.Groups[2].Value);
+                return numA.CompareTo(numB);
+            }
+            // If only one has a trailing number, treat the one without number as coming first
+
+            if (hasNumberA)
+            {
+                return 1; // B (no number) comes before A
+            }
+
+            if (hasNumberB)
+            {
+                return -1; // A (no number) comes before B
+            }
+            // Neither has a trailing number → pure string compare
+            return StringComparer.OrdinalIgnoreCase.Compare(nameA, nameB);
+        }
     }
 }

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.4",
+  "version": "2.0.0-rc76.6",
   "displayName": "Unity Helpers",
   "description": "Various Unity Helper Library",
   "dependencies": {},
@@ -77,6 +77,8 @@
 
 
 
+
+