com.wallstop-studios.unity-helpers 1.0.0-rc4

package/Runtime/Core/Attributes/ParentComponent.cs

@@ -0,0 +1,85 @@
+namespace UnityHelpers.Core.Attributes
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Linq;
+    using System.Reflection;
+    using Extension;
+    using JetBrains.Annotations;
+    using UnityEngine;
+
+    [AttributeUsage(AttributeTargets.Field)]
+    [MeansImplicitUse]
+    public sealed class ParentComponentAttribute : Attribute
+    {
+        public bool optional = false;
+    }
+
+    public static class ParentComponentExtensions
+    {
+        private static readonly Dictionary<Type, List<FieldInfo>> FieldsByType = new();
+
+        public static void AssignParentComponents(this Component component)
+        {
+            Type componentType = component.GetType();
+            List<FieldInfo> fields = FieldsByType.GetOrAdd(componentType, type =>
+            {
+                FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
+                return fields
+                    .Where(prop => Attribute.IsDefined(prop, typeof(ParentComponentAttribute)))
+                    .ToList();
+            });
+
+            foreach (FieldInfo field in fields)
+            {
+                Type fieldType = field.FieldType;
+                bool isArray = fieldType.IsArray;
+                Type parentComponentType = isArray ? fieldType.GetElementType() : fieldType;
+
+                bool foundParent;
+                if (isArray)
+                {
+                    Component[] parentComponents = component.GetComponentsInParent(parentComponentType, true);
+                    foundParent = 0 < parentComponents.Length;
+ 
+                    Array correctTypedArray = Array.CreateInstance(parentComponentType, parentComponents.Length);
+                    Array.Copy(parentComponents, correctTypedArray, parentComponents.Length);
+                    field.SetValue(component, correctTypedArray);
+                }
+                else if (fieldType.IsGenericType && fieldType.GetGenericTypeDefinition() == typeof(List<>))
+                {
+                    parentComponentType = fieldType.GenericTypeArguments[0];
+                    Type constructedListType = typeof(List<>).MakeGenericType(parentComponentType);
+                    IList instance = (IList) Activator.CreateInstance(constructedListType);
+
+                    foundParent = false;
+                    foreach (Component parentComponent in component.GetComponentsInParent(parentComponentType, true))
+                    {
+                        instance.Add(parentComponent);
+                        foundParent = true;
+                    }
+
+                    field.SetValue(component, instance);
+                }
+                else
+                {
+                    Component childComponent = component.GetComponentInParent(parentComponentType, true);
+                    foundParent = childComponent != null;
+                    if (foundParent)
+                    {
+                        field.SetValue(component, childComponent);
+                    }
+                }
+
+                if (!foundParent)
+                {
+                    if (field.GetCustomAttributes(typeof(ParentComponentAttribute), false)[0] is ParentComponentAttribute { optional: false } _)
+                    {
+                        component.LogError($"Unable to find parent component of type {fieldType}");
+                    }
+                }
+            }
+        }
+    }
+}

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

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

package/Runtime/Core/Attributes/ReadOnlyAttribute.cs

@@ -0,0 +1,8 @@
+using PropertyAttribute = UnityEngine.PropertyAttribute;
+
+namespace UnityHelpers.Core.Attributes
+{
+    public sealed class ReadOnlyAttribute : PropertyAttribute
+    {
+    }
+}

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

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

package/Runtime/Core/Attributes/RelationalComponentExtensions.cs

@@ -0,0 +1,14 @@
+namespace UnityHelpers.Core.Attributes
+{
+    using UnityEngine;
+
+    public static class RelationalComponentExtensions
+    {
+        public static void AssignRelationalComponents(this Component component)
+        {
+            component.AssignParentComponents();
+            component.AssignSiblingComponents();
+            component.AssignChildComponents();
+        }
+    }
+}

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

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

package/Runtime/Core/Attributes/SiblingComponentAttribute.cs

@@ -0,0 +1,89 @@
+namespace UnityHelpers.Core.Attributes
+{
+    using Extension;
+    using JetBrains.Annotations;
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Linq;
+    using System.Reflection;
+    using UnityEngine;
+
+    [AttributeUsage(AttributeTargets.Field)]
+    [MeansImplicitUse]
+    public sealed class SiblingComponentAttribute : Attribute
+    {
+        public bool optional = false;
+    }
+
+    public static class SiblingComponentExtensions
+    {
+        private static readonly Dictionary<Type, List<FieldInfo>> FieldsByType = new();
+
+        public static void AssignSiblingComponents(this Component component)
+        {
+            Type componentType = component.GetType();
+            List<FieldInfo> fields = FieldsByType.GetOrAdd(componentType,
+                type =>
+                {
+                    FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
+                    return fields
+                        .Where(prop => Attribute.IsDefined(prop, typeof(SiblingComponentAttribute)))
+                        .ToList();
+                });
+
+            foreach (FieldInfo field in fields)
+            {
+                Type fieldType = field.FieldType;
+                bool isArray = fieldType.IsArray;
+                Type siblingComponentType = isArray ? fieldType.GetElementType() : fieldType;
+
+                bool foundSibling;
+                if (isArray)
+                {
+                    Component[] siblingComponents = component.GetComponents(siblingComponentType);
+                    foundSibling = 0 < siblingComponents.Length;
+
+                    Array correctTypedArray = Array.CreateInstance(siblingComponentType, siblingComponents.Length);
+                    Array.Copy(siblingComponents, correctTypedArray, siblingComponents.Length);
+                    field.SetValue(component, correctTypedArray);
+                }
+                else if (fieldType.IsGenericType && fieldType.GetGenericTypeDefinition() == typeof(List<>))
+                {
+                    siblingComponentType = fieldType.GenericTypeArguments[0];
+                    Type constructedListType = typeof(List<>).MakeGenericType(siblingComponentType);
+                    IList instance = (IList) Activator.CreateInstance(constructedListType);
+
+                    foundSibling = false;
+                    foreach (Component siblingComponent in component.GetComponents(siblingComponentType))
+                    {
+                        instance.Add(siblingComponent);
+                        foundSibling = true;
+                    }
+
+                    field.SetValue(component, instance);
+                }
+                else
+                {
+                    if (component.TryGetComponent(siblingComponentType, out Component siblingComponent))
+                    {
+                        foundSibling = true;
+                        field.SetValue(component, siblingComponent);
+                    }
+                    else
+                    {
+                        foundSibling = false;
+                    }
+                }
+
+                if (!foundSibling)
+                {
+                    if (field.GetCustomAttributes(typeof(SiblingComponentAttribute), false)[0] is SiblingComponentAttribute {optional: false} _)
+                    {
+                        component.LogError($"Unable to find sibling component of type {fieldType}");
+                    }
+                }
+            }
+        }
+    }
+}

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

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

package/Runtime/Core/Attributes/ValidateAssignmentAttribute.cs

@@ -0,0 +1,66 @@
+namespace UnityHelpers.Core.Attributes
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Linq;
+    using System.Reflection;
+    using Extension;
+    using Helper;
+    using JetBrains.Annotations;
+    using Object = UnityEngine.Object;
+
+    [AttributeUsage(AttributeTargets.Field)]
+    [MeansImplicitUse]
+    public sealed class ValidateAssignmentAttribute : Attribute
+    {
+    }
+
+    public static class ValidateAssignmentExtensions
+    {
+        private static readonly Dictionary<Type, List<FieldInfo>> FieldsByType = new();
+
+        public static void ValidateAssignments(this Object o)
+        {
+#if UNITY_EDITOR
+            Type objectType = o.GetType();
+            List<FieldInfo> fields = FieldsByType.GetOrAdd(objectType, type => type
+                .GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
+                .Where(prop => Attribute.IsDefined(prop, typeof(ValidateAssignmentAttribute))).ToList());
+
+            foreach (FieldInfo field in fields)
+            {
+                bool logNotAssigned = IsFieldInvalid(field, o);
+
+                if (logNotAssigned)
+                {
+                    o.LogNotAssigned(field.Name);
+                }
+            }
+#endif
+        }
+
+        public static bool AreAnyAssignmentsInvalid(this Object o)
+        {
+            Type objectType = o.GetType();
+            List<FieldInfo> fields = FieldsByType.GetOrAdd(objectType, type => type
+                .GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
+                .Where(prop => Attribute.IsDefined(prop, typeof(ValidateAssignmentAttribute))).ToList());
+
+            return fields.Any(field => IsFieldInvalid(field, o));
+        }
+
+        private static bool IsFieldInvalid(FieldInfo field, Object o)
+        {
+            object fieldValue = field.GetValue(o);
+            return fieldValue switch
+            {
+                IList list => list.Count <= 0,
+                ICollection collection => collection.Count <= 0,
+                Object unityObject => !unityObject,
+                string stringValue => string.IsNullOrWhiteSpace(stringValue),
+                _ => fieldValue == null
+            };
+        }
+    }
+}

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

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

package/Runtime/Core/Attributes.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 139606485fde4f4ea168e7a8cf721a8a
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Core/DataStructure/Adapters/FastVector2Int.cs

@@ -0,0 +1,91 @@
+namespace UnityHelpers.Core.DataStructure.Adapters
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using Helper;
+    using ProtoBuf;
+    using UnityEngine;
+
+    [Serializable]
+    [ProtoContract]
+    public struct FastVector2Int : IEquatable<FastVector2Int>
+    {
+        [ProtoMember(1)]
+        public int x;
+        [ProtoMember(2)]
+        public int y;
+
+        private int _hash;
+
+        public FastVector2Int(int x, int y)
+        {
+            this.x = x;
+            this.y = y;
+
+            _hash = Objects.ValueTypeHashCode(x, y);
+        }
+
+        public static implicit operator Vector2Int(FastVector2Int vector)
+        {
+            return new Vector2Int(vector.x, vector.y);
+        }
+
+        public static implicit operator FastVector2Int(FastVector3Int vector)
+        {
+            return new FastVector2Int(vector.x, vector.y);
+        }
+
+        public static implicit operator FastVector2Int(Vector2Int vector)
+        {
+            return new FastVector2Int(vector.x, vector.y);
+        }
+
+        public static FastVector2Int operator +(FastVector2Int lhs, FastVector2Int rhs)
+        {
+            return new FastVector2Int(lhs.x + rhs.x, lhs.y + rhs.y);
+        }
+
+        public static FastVector2Int operator -(FastVector2Int lhs, FastVector2Int rhs)
+        {
+            return new FastVector2Int(lhs.x - rhs.x, lhs.y - rhs.y);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool Equals(FastVector2Int other)
+        {
+            return GetHashCode() == other.GetHashCode() && x == other.x && y == other.y;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override bool Equals(object obj)
+        {
+            return obj is FastVector2Int other && Equals(other);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override int GetHashCode()
+        {
+            if (_hash == 0)
+            {
+                _hash = Objects.ValueTypeHashCode(x, y);
+            }
+            return _hash;
+        }
+
+        public override string ToString()
+        {
+            return $"({x}, {y})";
+        }
+
+        [ProtoAfterDeserialization]
+        private void AfterDeserialize()
+        {
+            _hash = Objects.ValueTypeHashCode(x, y);
+        }
+
+        public readonly FastVector3Int AsFastVector3Int()
+        {
+            return new FastVector3Int(x, y);
+        }
+    }
+}

package/Runtime/Core/DataStructure/Adapters/FastVector2Int.cs.meta

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

package/Runtime/Core/DataStructure/Adapters/FastVector3Int.cs

@@ -0,0 +1,180 @@
+namespace UnityHelpers.Core.DataStructure.Adapters
+{
+    using System;
+    using System.Runtime.CompilerServices;
+    using Helper;
+    using ProtoBuf;
+    using UnityEngine;
+
+    [Serializable]
+    [ProtoContract]
+    public struct FastVector3Int : IEquatable<FastVector3Int>, IComparable<FastVector3Int>, IComparable
+    {
+        public static readonly FastVector3Int zero = new(0, 0, 0);
+
+        [ProtoMember(1)]
+        public int x;
+        [ProtoMember(2)]
+        public int y;
+        [ProtoMember(3)]
+        public int z;
+
+        private int _hash;
+
+        public FastVector3Int(int x, int y, int z)
+        {
+            this.x = x;
+            this.y = y;
+            this.z = z;
+            _hash = Objects.ValueTypeHashCode(x, y, z);
+        }
+
+        public FastVector3Int(Vector3Int vector)
+            : this(vector.x, vector.y, vector.z)
+        {
+        }
+
+        public FastVector3Int(int x, int y) : this(x, y, 0)
+        {
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool operator ==(FastVector3Int lhs, FastVector3Int rhs)
+        {
+            return lhs.Equals(rhs);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool operator !=(FastVector3Int lhs, FastVector3Int rhs)
+        {
+            return !lhs.Equals(rhs);
+        }
+
+        public static FastVector3Int operator +(FastVector3Int lhs, FastVector3Int rhs)
+        {
+            return new FastVector3Int(lhs.x + rhs.x, lhs.y + rhs.y, lhs.z + rhs.z);
+        }
+
+        public static FastVector3Int operator +(FastVector3Int lhs, Vector3Int rhs)
+        {
+            return new FastVector3Int(lhs.x + rhs.x, lhs.y + rhs.y, lhs.z + rhs.z);
+        }
+
+        public static FastVector3Int operator +(FastVector3Int lhs, Vector2Int rhs)
+        {
+            return new FastVector3Int(lhs.x + rhs.x, lhs.y + rhs.y, lhs.z);
+        }
+
+        public static FastVector3Int operator +(FastVector3Int lhs, FastVector2Int rhs)
+        {
+            return new FastVector3Int(lhs.x + rhs.x, lhs.y + rhs.y, lhs.z);
+        }
+
+        public static FastVector3Int operator -(FastVector3Int lhs, FastVector3Int rhs)
+        {
+            return new FastVector3Int(lhs.x - rhs.x, lhs.y - rhs.y, lhs.z - rhs.z);
+        }
+
+        public static FastVector3Int operator -(FastVector3Int lhs, Vector3Int rhs)
+        {
+            return new FastVector3Int(lhs.x - rhs.x, lhs.y - rhs.y, lhs.z - rhs.z);
+        }
+
+        public static FastVector3Int operator -(FastVector3Int lhs, FastVector2Int rhs)
+        {
+            return new FastVector3Int(lhs.x - rhs.x, lhs.y - rhs.y, lhs.z);
+        }
+
+        public static FastVector3Int operator -(FastVector3Int lhs, Vector2Int rhs)
+        {
+            return new FastVector3Int(lhs.x - rhs.x, lhs.y - rhs.y, lhs.z);
+        }
+
+        public static implicit operator Vector3Int(FastVector3Int vector)
+        {
+            return new Vector3Int(vector.x, vector.y, vector.z);
+        }
+
+        public static implicit operator FastVector3Int(Vector3Int vector)
+        {
+            return new FastVector3Int(vector.x, vector.y, vector.z);
+        }
+
+        public static implicit operator Vector2Int(FastVector3Int vector)
+        {
+            return new Vector2Int(vector.x, vector.y);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override int GetHashCode()
+        {
+            if (_hash == 0)
+            {
+                _hash = Objects.ValueTypeHashCode(x, y, z);
+            }
+            return _hash;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override bool Equals(object obj)
+        {
+            return obj is FastVector3Int other && Equals(other);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool Equals(FastVector3Int other)
+        {
+            return GetHashCode() == other.GetHashCode() && x == other.x && y == other.y && z == other.z;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public int CompareTo(FastVector3Int other)
+        {
+            int comparison = x.CompareTo(other.x);
+            if (comparison != 0)
+            {
+                return comparison;
+            }
+
+            comparison = y.CompareTo(other.y);
+            if (comparison != 0)
+            {
+                return comparison;
+            }
+
+            return z.CompareTo(other.z);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public int CompareTo(object other)
+        {
+            if (other is FastVector3Int vector)
+            {
+                return CompareTo(vector);
+            }
+
+            return -1;
+        }
+
+        public override string ToString()
+        {
+            return $"({x}, {y}, {z})";
+        }
+
+        [ProtoAfterDeserialization]
+        private void AfterDeserialize()
+        {
+            _hash = Objects.ValueTypeHashCode(x, y, z);
+        }
+
+        public readonly Vector2 AsVector2()
+        {
+            return new Vector2(x, y);
+        }
+
+        public readonly Vector3 AsVector3()
+        {
+            return new Vector3(x, y, z);
+        }
+    }
+}

package/Runtime/Core/DataStructure/Adapters/FastVector3Int.cs.meta

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