com.wallstop-studios.unity-helpers 1.0.0-rc8 → 1.0.1-rc01

package/Runtime/Utils/SpriteRendererSyncer.cs

@@ -0,0 +1,98 @@
+namespace UnityHelpers.Utils
+{
+    using System;
+    using Core.Attributes;
+    using UnityEngine;
+    using UnityEngine.Serialization;
+
+    [DisallowMultipleComponent]
+    public sealed class SpriteRendererSync : MonoBehaviour
+    {
+        public int? DynamicSortingOrderOverride { get; set; }
+
+        public SpriteRenderer DynamicToMatch
+        {
+            get => GetDynamicSpriteRenderer();
+            set => _cachedSpriteRenderer = value;
+        }
+
+        [FormerlySerializedAs("_toMatch")]
+        public SpriteRenderer toMatch;
+
+        [FormerlySerializedAs("_matchColor")]
+        public bool matchColor;
+
+        [FormerlySerializedAs("_matchMaterial")]
+        public bool matchMaterial;
+
+        public bool matchSortingLayer = true;
+
+        public bool matchOrderInLayer = true;
+
+        public Func<SpriteRenderer> dynamicToMatch;
+
+        [SerializeField]
+        [SiblingComponent]
+        private SpriteRenderer _spriteRenderer;
+
+        private SpriteRenderer _cachedSpriteRenderer;
+
+        private void Awake()
+        {
+            if (_spriteRenderer == null)
+            {
+                this.AssignSiblingComponents();
+            }
+        }
+
+        private void LateUpdate()
+        {
+            SpriteRenderer localToMatch = dynamicToMatch != null ? GetDynamicSpriteRenderer() : toMatch;
+            if (localToMatch == null)
+            {
+                _spriteRenderer.sprite = null;
+                return;
+            }
+
+            _spriteRenderer.sprite = localToMatch.sprite;
+            _spriteRenderer.enabled = localToMatch.enabled;
+            _spriteRenderer.flipX = localToMatch.flipX;
+            _spriteRenderer.flipY = localToMatch.flipY;
+            if (matchColor)
+            {
+                _spriteRenderer.color = localToMatch.color;
+            }
+
+            if (matchMaterial)
+            {
+                _spriteRenderer.material = localToMatch.material;
+            }
+
+            if (matchSortingLayer)
+            {
+                _spriteRenderer.sortingLayerName = localToMatch.sortingLayerName;
+            }
+
+            if (matchOrderInLayer)
+            {
+                _spriteRenderer.sortingOrder = DynamicSortingOrderOverride ?? localToMatch.sortingOrder;
+            }
+
+            _spriteRenderer.size = localToMatch.size;
+            _spriteRenderer.spriteSortPoint = localToMatch.spriteSortPoint;
+            _spriteRenderer.drawMode = localToMatch.drawMode;
+            _spriteRenderer.tileMode = localToMatch.tileMode;
+        }
+
+        private SpriteRenderer GetDynamicSpriteRenderer()
+        {
+            if (_cachedSpriteRenderer != null && _cachedSpriteRenderer.gameObject.activeSelf)
+            {
+                return _cachedSpriteRenderer;
+            }
+
+            _cachedSpriteRenderer = dynamicToMatch();
+            return _cachedSpriteRenderer;
+        }
+    }
+}

package/Runtime/Utils/SpriteRendererSyncer.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: ec3a379f59bc407f92daaab2a3d4e089
+timeCreated: 1720400998

package/Tests/Runtime/Extensions/StringExtensionTests.cs

@@ -0,0 +1,31 @@
+namespace UnityHelpers.Tests.Extensions
+{
+    using Core.Extension;
+    using NUnit.Framework;
+
+    public sealed class StringExtensionTests
+    {
+        [Test]
+        public void ToPascalCaseNominal()
+        {
+            Assert.AreEqual("PascalCase", "PascalCase".ToPascalCase());
+            Assert.AreEqual("PascalCase", "pascalCase".ToPascalCase());
+            Assert.AreEqual("PascalCase", "_pascalCase".ToPascalCase());
+            Assert.AreEqual("PascalCase", "_PascalCase".ToPascalCase());
+            Assert.AreEqual("PascalCase", "pascal case".ToPascalCase());
+            Assert.AreEqual("PascalCase", "  __Pascal____   ___Case__ ".ToPascalCase());
+        }
+
+        [Test]
+        public void ToPascalCaseCustomSeparator()
+        {
+            const string separator = ".";
+            Assert.AreEqual("Pascal.Case", "PascalCase".ToPascalCase(separator));
+            Assert.AreEqual("Pascal.Case", "pascalCase".ToPascalCase(separator));
+            Assert.AreEqual("Pascal.Case", "_pascalCase".ToPascalCase(separator));
+            Assert.AreEqual("Pascal.Case", "_PascalCase".ToPascalCase(separator));
+            Assert.AreEqual("Pascal.Case", "pascal case".ToPascalCase(separator));
+            Assert.AreEqual("Pascal.Case", "  __Pascal____   ___Case__ ".ToPascalCase(separator));
+        }
+    }
+}

package/Tests/Runtime/Extensions/StringExtensionTests.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 522329788bc543aab266b1d91a8e2b47
+timeCreated: 1720391633

package/Tests/Runtime/Extensions.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 3b57270da98c4ce8bb8714dfb1603ee0
+timeCreated: 1720391613

package/Tests/Runtime/Random/RandomTestBase.cs

@@ -2,7 +2,6 @@
 {
     using System;
     using System.Collections.Generic;
-    using System.Diagnostics;
     using System.Linq;
     using NUnit.Framework;
     using UnityHelpers.Core.Random;
@@ -11,7 +10,7 @@
     {
         protected const int SampleCount = 10_000_000;
 
-        protected int[] _samples = new int[1_000];
+        protected readonly int[] _samples = new int[1_000];
 
         protected abstract IRandom NewRandom();
 
@@ -48,19 +47,23 @@
         [Test]
         public void Byte()
         {
-            TestAndVerify(random => random.NextByte(0, (byte)(_samples.Length < byte.MaxValue ? _samples.Length : byte.MaxValue)), byte.MaxValue);
+            TestAndVerify(
+                random => random.NextByte(0, (byte)(_samples.Length < byte.MaxValue ? _samples.Length : byte.MaxValue)),
+                byte.MaxValue);
         }
 
         [Test]
         public void Float()
         {
-            TestAndVerify(random => (int)Math.Floor(random.NextFloat(0, _samples.Length)));
+            TestAndVerify(
+                random => Math.Clamp((int)Math.Floor(random.NextFloat(0, _samples.Length)), 0, _samples.Length - 1));
         }
 
         [Test]
         public void Double()
         {
-            TestAndVerify(random => (int)Math.Floor(random.NextDouble(0, _samples.Length)));
+            TestAndVerify(
+                random => Math.Clamp((int)Math.Floor(random.NextDouble(0, _samples.Length)), 0, _samples.Length - 1));
         }
 
         [Test]
@@ -110,8 +113,13 @@
                 }
             }
 
-            Assert.AreEqual(0, zeroCountIndexes.Count, "No samples at {0} indices: [{1}]", zeroCountIndexes.Count, string.Join(",", zeroCountIndexes));
-            Assert.AreEqual(0, outsideRange.Count, "{0} indexes outside of dev {1:0.00}. Expected: {2:0.00}. Found: [{3}]", outsideRange.Count, deviationAllowed, average, string.Join(",", outsideRange.Select(index => _samples[index])));
+            Assert.AreEqual(
+                0, zeroCountIndexes.Count, "No samples at {0} indices: [{1}]", zeroCountIndexes.Count,
+                string.Join(",", zeroCountIndexes));
+            Assert.AreEqual(
+                0, outsideRange.Count, "{0} indexes outside of dev {1:0.00}. Expected: {2:0.00}. Found: [{3}]",
+                outsideRange.Count, deviationAllowed, average,
+                string.Join(",", outsideRange.Select(index => _samples[index])));
         }
     }
-}
+}

package/Tests/Runtime/Utils/SpriteRendererMetadataTests.cs

@@ -0,0 +1,395 @@
+namespace UnityHelpers.Tests.Utils
+{
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Linq;
+    using Core.Helper;
+    using Core.Random;
+    using NUnit.Framework;
+    using UnityEngine;
+    using UnityEngine.TestTools;
+    using UnityHelpers.Utils;
+
+    public sealed class SpriteRendererMetadataTests
+    {
+        private readonly List<GameObject> _spawned = new();
+
+        [TearDown]
+        public void Cleanup()
+        {
+            foreach (GameObject spawned in _spawned)
+            {
+                if (spawned == null)
+                {
+                    continue;
+                }
+
+                Object.Destroy(spawned);
+            }
+
+            _spawned.Clear();
+        }
+
+        private SpriteRendererMetadata CreateMetadata()
+        {
+            GameObject go = new("TestSpriteRendererMetadata", typeof(SpriteRenderer), typeof(SpriteRendererMetadata));
+            _spawned.Add(go);
+            return go.GetComponent<SpriteRendererMetadata>();
+        }
+
+        private Material CreateMaterial()
+        {
+            return new Material(Shader.Find("Sprites/Default"));
+        }
+
+        private Color CreateColor()
+        {
+            IRandom random = PcgRandom.Instance;
+            Color color = new(random.NextFloat(), random.NextFloat(), random.NextFloat(), random.NextFloat());
+            return color;
+        }
+
+        [UnityTest]
+        public IEnumerator Initialization()
+        {
+            SpriteRendererMetadata metadata = CreateMetadata();
+            SpriteRenderer spriteRenderer = metadata.GetComponent<SpriteRenderer>();
+            Assert.AreEqual(spriteRenderer.color, metadata.CurrentColor);
+            Assert.AreEqual(spriteRenderer.material, metadata.CurrentMaterial);
+            Assert.AreEqual(metadata.OriginalColor, metadata.CurrentColor);
+            Assert.AreEqual(metadata.OriginalMaterial, metadata.CurrentMaterial);
+            Assert.AreEqual(1, metadata.Colors.Count());
+            Assert.IsTrue(metadata.Colors.Contains(metadata.OriginalColor));
+            Assert.AreEqual(1, metadata.Materials.Count());
+            Assert.IsTrue(metadata.Materials.Contains(metadata.OriginalMaterial));
+            yield break;
+        }
+
+        [UnityTest]
+        public IEnumerator PushColor()
+        {
+            SpriteRendererMetadata metadata = CreateMetadata();
+            Color originalColor = metadata.OriginalColor;
+            Color newColor = originalColor;
+            Material originalMaterial = metadata.OriginalMaterial;
+            do
+            {
+                newColor.r = PcgRandom.Instance.NextFloat();
+            }
+            while (newColor == originalColor);
+
+            SpriteRendererMetadata second = CreateMetadata();
+            SpriteRenderer spriteRenderer = metadata.GetComponent<SpriteRenderer>();
+            Assert.AreEqual(spriteRenderer.color, metadata.CurrentColor);
+            metadata.PushColor(second, newColor);
+            Assert.AreEqual(spriteRenderer.color, metadata.CurrentColor);
+            Assert.AreEqual(newColor, metadata.CurrentColor);
+            Assert.IsTrue(metadata.Colors.Contains(newColor));
+            Assert.AreEqual(originalColor, metadata.OriginalColor);
+            Assert.AreEqual(originalMaterial, metadata.CurrentMaterial);
+
+            Color updatedColor = newColor;
+            do
+            {
+                updatedColor.g = PcgRandom.Instance.NextFloat();
+            }
+            while (updatedColor == newColor);
+
+            metadata.PushColor(spriteRenderer, updatedColor);
+            Assert.AreEqual(spriteRenderer.color, metadata.CurrentColor);
+            Assert.AreEqual(updatedColor, metadata.CurrentColor);
+            Assert.AreEqual(3, metadata.Colors.Count());
+            Assert.IsTrue(metadata.Colors.Contains(originalColor));
+            Assert.IsTrue(metadata.Colors.Contains(newColor));
+            Assert.IsTrue(metadata.Colors.Contains(updatedColor));
+            Assert.AreEqual(originalColor, metadata.OriginalColor);
+            Assert.AreEqual(originalMaterial, metadata.CurrentMaterial);
+
+            Color latestColor = updatedColor;
+            do
+            {
+                latestColor.b = PcgRandom.Instance.NextFloat();
+            }
+            while (latestColor == updatedColor);
+
+            metadata.PushColor(second, latestColor);
+            Assert.AreEqual(spriteRenderer.color, metadata.CurrentColor);
+            Assert.AreEqual(latestColor, metadata.CurrentColor);
+            Assert.AreEqual(3, metadata.Colors.Count());
+            // Should be replaced
+            Assert.IsFalse(metadata.Colors.Contains(newColor));
+            do
+            {
+                newColor.a = PcgRandom.Instance.NextFloat();
+            }
+            while (newColor == latestColor);
+
+            metadata.PushColor(second, newColor);
+            Assert.AreEqual(spriteRenderer.color, metadata.CurrentColor);
+            Assert.AreEqual(newColor, metadata.CurrentColor);
+            Assert.AreEqual(3, metadata.Colors.Count());
+            Assert.IsTrue(metadata.Colors.Contains(originalColor));
+            Assert.IsTrue(metadata.Colors.Contains(newColor));
+            Assert.IsTrue(metadata.Colors.Contains(updatedColor));
+
+            metadata.PushColor(second, newColor);
+            Assert.AreEqual(spriteRenderer.color, metadata.CurrentColor);
+            Assert.AreEqual(newColor, metadata.CurrentColor);
+            Assert.AreEqual(3, metadata.Colors.Count());
+            Assert.IsTrue(metadata.Colors.Contains(originalColor));
+            Assert.IsTrue(metadata.Colors.Contains(newColor));
+            Assert.IsTrue(metadata.Colors.Contains(updatedColor));
+            yield break;
+        }
+
+        [UnityTest]
+        public IEnumerator PushColorIdempotent()
+        {
+            SpriteRendererMetadata metadata = CreateMetadata();
+            SpriteRenderer spriteRenderer = metadata.GetComponent<SpriteRenderer>();
+            Color color = CreateColor();
+
+            void Verify()
+            {
+                metadata.PushColor(spriteRenderer, color);
+                Assert.AreEqual(spriteRenderer.color, color);
+                Assert.AreEqual(color, metadata.CurrentColor);
+                Assert.AreEqual(2, metadata.Colors.Count());
+            }
+
+            for (int i = 0; i < 100; ++i)
+            {
+                Verify();
+            }
+
+            yield break;
+        }
+
+        [UnityTest]
+        public IEnumerator PushMaterialIdempotent()
+        {
+            SpriteRendererMetadata metadata = CreateMetadata();
+            SpriteRenderer spriteRenderer = metadata.GetComponent<SpriteRenderer>();
+            Material material = CreateMaterial();
+
+            void Verify()
+            {
+                metadata.PushMaterial(spriteRenderer, material);
+                Assert.AreEqual(spriteRenderer.material, metadata.CurrentMaterial);
+                Assert.AreEqual(2, metadata.Materials.Count());
+                Assert.IsTrue(metadata.Materials.Contains(spriteRenderer.material));
+                Assert.IsTrue(metadata.Materials.Contains(metadata.OriginalMaterial));
+            }
+
+            for (int i = 0; i < 100; ++i)
+            {
+                Verify();
+            }
+
+            yield break;
+        }
+
+
+        [UnityTest]
+        public IEnumerator PopColorIdempotent()
+        {
+            SpriteRendererMetadata metadata = CreateMetadata();
+            SpriteRenderer spriteRenderer = metadata.GetComponent<SpriteRenderer>();
+            Color originalColor = spriteRenderer.color;
+            Color color = CreateColor();
+            metadata.PushColor(spriteRenderer, color);
+
+            void Verify()
+            {
+                metadata.PopColor(spriteRenderer);
+                Assert.AreEqual(spriteRenderer.color, metadata.CurrentColor);
+                Assert.AreEqual(originalColor, metadata.CurrentColor);
+                Assert.AreEqual(1, metadata.Colors.Count());
+            }
+
+            for (int i = 0; i < 100; ++i)
+            {
+                Verify();
+            }
+
+            yield break;
+        }
+
+        [UnityTest]
+        public IEnumerator PopMaterialIdempotent()
+        {
+            SpriteRendererMetadata metadata = CreateMetadata();
+            SpriteRenderer spriteRenderer = metadata.GetComponent<SpriteRenderer>();
+            Material material = CreateMaterial();
+
+            metadata.PushMaterial(spriteRenderer, material);
+
+            void Verify()
+            {
+                metadata.PopMaterial(spriteRenderer);
+                Assert.AreEqual(spriteRenderer.material, metadata.CurrentMaterial);
+                Assert.AreEqual(1, metadata.Materials.Count());
+                Assert.IsTrue(metadata.Materials.Contains(spriteRenderer.material));
+            }
+
+            for (int i = 0; i < 100; ++i)
+            {
+                Verify();
+            }
+
+            yield break;
+        }
+
+        [UnityTest]
+        public IEnumerator CannotSelfPushColor()
+        {
+            SpriteRendererMetadata metadata = CreateMetadata();
+            SpriteRenderer spriteRenderer = metadata.GetComponent<SpriteRenderer>();
+            Color color = CreateColor();
+            Color originalColor = metadata.OriginalColor;
+            metadata.PushColor(metadata, color);
+            Assert.AreEqual(originalColor, metadata.CurrentColor);
+            Assert.AreEqual(originalColor, spriteRenderer.color);
+            Assert.AreEqual(1, metadata.Colors.Count());
+            yield break;
+        }
+
+        [UnityTest]
+        public IEnumerator CannotSelfPopColor()
+        {
+            SpriteRendererMetadata metadata = CreateMetadata();
+            SpriteRenderer spriteRenderer = metadata.GetComponent<SpriteRenderer>();
+            Color originalColor = metadata.OriginalColor;
+            metadata.PopColor(metadata);
+            Assert.AreEqual(originalColor, metadata.CurrentColor);
+            Assert.AreEqual(originalColor, spriteRenderer.color);
+            Assert.AreEqual(1, metadata.Colors.Count());
+            yield break;
+        }
+
+        [UnityTest]
+        public IEnumerator CannotSelfPopMaterial()
+        {
+            SpriteRendererMetadata metadata = CreateMetadata();
+            SpriteRenderer spriteRenderer = metadata.GetComponent<SpriteRenderer>();
+            Material originalMaterial = metadata.OriginalMaterial;
+            metadata.PopMaterial(metadata);
+            Assert.AreEqual(originalMaterial, metadata.CurrentMaterial);
+            Assert.AreEqual(originalMaterial, spriteRenderer.material);
+            Assert.AreEqual(1, metadata.Materials.Count());
+            yield break;
+        }
+
+        [UnityTest]
+        public IEnumerator CannotSelfPushMaterial()
+        {
+            SpriteRendererMetadata metadata = CreateMetadata();
+            SpriteRenderer spriteRenderer = metadata.GetComponent<SpriteRenderer>();
+            Material material = CreateMaterial();
+            Material originalMaterial = metadata.OriginalMaterial;
+            metadata.PushMaterial(metadata, material);
+            Assert.AreEqual(originalMaterial, metadata.CurrentMaterial);
+            Assert.AreEqual(originalMaterial, spriteRenderer.material);
+            Assert.AreNotEqual(material, spriteRenderer.material);
+            Assert.AreEqual(1, metadata.Materials.Count());
+            yield break;
+        }
+
+        [UnityTest]
+        public IEnumerator EnableDisableColor()
+        {
+            SpriteRendererMetadata metadata = CreateMetadata();
+            SpriteRenderer spriteRenderer = metadata.GetComponent<SpriteRenderer>();
+            Color color = CreateColor();
+            metadata.PushColor(spriteRenderer, color);
+            Assert.AreEqual(color, metadata.CurrentColor);
+            Assert.AreEqual(spriteRenderer.color, metadata.CurrentColor);
+            Assert.AreEqual(2, metadata.Colors.Count());
+
+            metadata.enabled = false;
+            Assert.AreEqual(metadata.OriginalColor, metadata.CurrentColor);
+            Assert.AreEqual(spriteRenderer.color, metadata.CurrentColor);
+            Assert.AreEqual(1, metadata.Colors.Count());
+
+            metadata.enabled = true;
+            Assert.AreEqual(color, metadata.CurrentColor);
+            Assert.AreEqual(spriteRenderer.color, metadata.CurrentColor);
+            Assert.AreEqual(2, metadata.Colors.Count());
+            yield break;
+        }
+
+        [UnityTest]
+        public IEnumerator EnableDisableMaterial()
+        {
+            SpriteRendererMetadata metadata = CreateMetadata();
+            SpriteRenderer spriteRenderer = metadata.GetComponent<SpriteRenderer>();
+            Material material = CreateMaterial();
+            metadata.PushMaterial(spriteRenderer, material);
+            Assert.AreEqual(spriteRenderer.material, metadata.CurrentMaterial);
+            Assert.AreEqual(2, metadata.Materials.Count());
+
+            metadata.enabled = false;
+            Assert.AreEqual(metadata.OriginalMaterial, metadata.CurrentMaterial);
+            Assert.AreEqual(1, metadata.Materials.Count());
+
+            metadata.enabled = true;
+            Assert.AreEqual(spriteRenderer.material, metadata.CurrentMaterial);
+            Assert.AreEqual(2, metadata.Materials.Count());
+            yield break;
+        }
+
+        [UnityTest]
+        public IEnumerator EnableDisableWithRemoveColor()
+        {
+            SpriteRendererMetadata metadata = CreateMetadata();
+            SpriteRenderer spriteRenderer = metadata.GetComponent<SpriteRenderer>();
+            Color color = CreateColor();
+            metadata.PushColor(spriteRenderer, color);
+            Assert.AreEqual(color, metadata.CurrentColor);
+            Assert.AreEqual(spriteRenderer.color, metadata.CurrentColor);
+            Assert.AreEqual(2, metadata.Colors.Count());
+
+            metadata.enabled = false;
+            Assert.AreEqual(metadata.OriginalColor, metadata.CurrentColor);
+            Assert.AreEqual(spriteRenderer.color, metadata.CurrentColor);
+            Assert.AreEqual(1, metadata.Colors.Count());
+
+            metadata.PopColor(spriteRenderer);
+
+            Assert.AreEqual(metadata.OriginalColor, metadata.CurrentColor);
+            Assert.AreEqual(spriteRenderer.color, metadata.CurrentColor);
+            Assert.AreEqual(1, metadata.Colors.Count());
+
+            metadata.enabled = true;
+            Assert.AreEqual(metadata.OriginalColor, metadata.CurrentColor);
+            Assert.AreEqual(spriteRenderer.color, metadata.CurrentColor);
+            Assert.AreEqual(1, metadata.Colors.Count());
+            yield break;
+        }
+
+        [UnityTest]
+        public IEnumerator EnableDisableWithRemoveMaterial()
+        {
+            SpriteRendererMetadata metadata = CreateMetadata();
+            SpriteRenderer spriteRenderer = metadata.GetComponent<SpriteRenderer>();
+            Material material = CreateMaterial();
+            metadata.PushMaterial(spriteRenderer, material);
+            Assert.AreEqual(spriteRenderer.material, metadata.CurrentMaterial);
+            Assert.AreEqual(2, metadata.Materials.Count());
+
+            metadata.enabled = false;
+            Assert.AreEqual(metadata.OriginalMaterial, metadata.CurrentMaterial);
+            Assert.AreEqual(1, metadata.Materials.Count());
+
+            metadata.PopMaterial(spriteRenderer);
+
+            Assert.AreEqual(metadata.OriginalMaterial, metadata.CurrentMaterial);
+            Assert.AreEqual(1, metadata.Materials.Count());
+
+            metadata.enabled = true;
+            Assert.AreEqual(metadata.OriginalMaterial, metadata.CurrentMaterial);
+            Assert.AreEqual(1, metadata.Materials.Count());
+            yield break;
+        }
+    }
+}

package/Tests/Runtime/Utils/SpriteRendererMetadataTests.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 5cbbc68f2b7c4c7d8b2fc2324a429130
+timeCreated: 1720397409

package/Tests/Runtime/Utils.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 07d3ff4fdf554c119ebd3f49fcaa09a3
+timeCreated: 1720397402

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "com.wallstop-studios.unity-helpers",
-  "version": "1.0.0-rc8",
+  "version": "1.0.1-rc01",
   "displayName": "Unity Helpers",
   "description": "Various Unity Helper Library",
   "dependencies": {
@@ -16,6 +16,7 @@
     "random",
     "pcg random",
     "protobuf",
+    "pascal",
     "rtree",
     "r tree",
     "kd tree",

package/Runtime/Core/Attributes/AutomaticallyFindAttribute.cs

@@ -1,43 +0,0 @@
-namespace UnityHelpers.Core.Attributes
-{
-    using System;
-    using System.Linq;
-    using System.Reflection;
-    using JetBrains.Annotations;
-    using UnityEngine;
-
-    [AttributeUsage(AttributeTargets.Field)]
-    [MeansImplicitUse]
-    public sealed class AutomaticallyFindAttribute : Attribute
-    {
-        public readonly string Tag = string.Empty;
-    }
-
-    public static class AutomaticallyFindExtensions
-    {
-        public static void AutomaticallyFind(this Component component)
-        {
-            var properties = component
-                .GetType()
-                .GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
-                .Where(prop => Attribute.IsDefined(prop, typeof(AutomaticallyFindAttribute)));
-
-            foreach (FieldInfo field in properties)
-            {
-                Type fieldType = field.FieldType;
-                Type type = fieldType.IsArray ? fieldType.GetElementType() : fieldType;
-
-                if (type == typeof(GameObject))
-                {
-                    var attribute = field.GetCustomAttributes(typeof(AutomaticallyFindAttribute), false)[0] as AutomaticallyFindAttribute;
-                    GameObject gameObject = GameObject.FindWithTag(attribute.Tag);
-                    field.SetValue(component, gameObject);
-                    return;
-                }
-
-                object foundObject = type.GetMethod("Find", BindingFlags.Public | BindingFlags.Static).Invoke(null, null);
-                field.SetValue(component, foundObject);
-            }
-        }
-    }
-}

package/Runtime/Core/Attributes/AutomaticallyFindAttribute.cs.meta

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