com.wallstop-studios.unity-helpers 2.0.0-rc68 → 2.0.0-rc69

package/Runtime/Tags/AttributeUtilities.cs

@@ -0,0 +1,208 @@
+namespace WallstopStudios.UnityHelpers.Tags
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using System.Reflection;
+    using Core.Extension;
+    using Core.Helper;
+    using Object = UnityEngine.Object;
+
+    public static class AttributeUtilities
+    {
+        private static string[] AllAttributeNames;
+        private static readonly Dictionary<Type, Dictionary<string, FieldInfo>> AttributeFields =
+            new();
+
+        // TODO: Use TypeCache + serialize
+        public static string[] GetAllAttributeNames()
+        {
+            return AllAttributeNames ??= AppDomain
+                .CurrentDomain.GetAssemblies()
+                .SelectMany(assembly => assembly.GetTypes())
+                .Where(type => !type.IsAbstract)
+                .Where(type => type.IsSubclassOf(typeof(AttributesComponent)))
+                .SelectMany(type =>
+                    type.GetFields(
+                        BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic
+                    )
+                )
+                .Where(fieldInfo => fieldInfo.FieldType == typeof(Attribute))
+                .Select(fieldInfo => fieldInfo.Name)
+                .Distinct()
+                .Ordered()
+                .ToArray();
+        }
+
+        public static bool HasTag(this Object target, string effectTag)
+        {
+            if (target == null)
+            {
+                return false;
+            }
+
+            return target.TryGetComponent(out TagHandler tagHandler)
+                && tagHandler.HasTag(effectTag);
+        }
+
+        public static bool HasAnyTag(this Object target, IEnumerable<string> effectTags)
+        {
+            if (target == null)
+            {
+                return false;
+            }
+
+            return target.TryGetComponent(out TagHandler tagHandler)
+                && tagHandler.HasAnyTag(effectTags);
+        }
+
+        public static bool HasAnyTag(this Object target, IReadOnlyList<string> effectTags)
+        {
+            if (target == null)
+            {
+                return false;
+            }
+
+            return target.TryGetComponent(out TagHandler tagHandler)
+                && tagHandler.HasAnyTag(effectTags);
+        }
+
+        public static EffectHandle? ApplyEffect(this Object target, AttributeEffect attributeEffect)
+        {
+            if (target == null)
+            {
+                return null;
+            }
+
+            return target.TryGetComponent(out EffectHandler effectHandler)
+                ? effectHandler.ApplyEffect(attributeEffect)
+                : null;
+        }
+
+        public static void ApplyEffectsNoAlloc(
+            this Object target,
+            List<AttributeEffect> attributeEffects
+        )
+        {
+            if (attributeEffects is not { Count: > 0 })
+            {
+                return;
+            }
+
+            if (target == null || !target.TryGetComponent(out EffectHandler effectHandler))
+            {
+                return;
+            }
+
+            foreach (AttributeEffect attributeEffect in attributeEffects)
+            {
+                _ = effectHandler.ApplyEffect(attributeEffect);
+            }
+        }
+
+        public static void ApplyEffectsNoAlloc(
+            this Object target,
+            IEnumerable<AttributeEffect> attributeEffects
+        )
+        {
+            if (target == null || !target.TryGetComponent(out EffectHandler effectHandler))
+            {
+                return;
+            }
+
+            foreach (AttributeEffect attributeEffect in attributeEffects)
+            {
+                _ = effectHandler.ApplyEffect(attributeEffect);
+            }
+        }
+
+        public static void ApplyEffectsNoAlloc(
+            this Object target,
+            List<AttributeEffect> attributeEffects,
+            List<EffectHandle> effectHandles
+        )
+        {
+            if (target == null || !target.TryGetComponent(out EffectHandler effectHandler))
+            {
+                return;
+            }
+
+            foreach (AttributeEffect attributeEffect in attributeEffects)
+            {
+                EffectHandle? handle = effectHandler.ApplyEffect(attributeEffect);
+                if (handle.HasValue)
+                {
+                    effectHandles.Add(handle.Value);
+                }
+            }
+        }
+
+        public static List<EffectHandle> ApplyEffects(
+            this Object target,
+            List<AttributeEffect> attributeEffects
+        )
+        {
+            List<EffectHandle> handles = new(attributeEffects.Count);
+            ApplyEffectsNoAlloc(target, attributeEffects, handles);
+            return handles;
+        }
+
+        public static void RemoveEffect(this Object target, EffectHandle effectHandle)
+        {
+            if (target == null)
+            {
+                return;
+            }
+
+            if (target.TryGetComponent(out EffectHandler effectHandler))
+            {
+                effectHandler.RemoveEffect(effectHandle);
+            }
+        }
+
+        public static void RemoveEffects(this Object target, List<EffectHandle> effectHandles)
+        {
+            if (target == null || effectHandles.Count <= 0)
+            {
+                return;
+            }
+
+            if (target.TryGetComponent(out EffectHandler effectHandler))
+            {
+                foreach (EffectHandle effectHandle in effectHandles)
+                {
+                    effectHandler.RemoveEffect(effectHandle);
+                }
+            }
+        }
+
+        public static void RemoveAllEffects(this Object target)
+        {
+            if (target == null)
+            {
+                return;
+            }
+
+            if (target.TryGetComponent(out EffectHandler effectHandler))
+            {
+                effectHandler.RemoveAllEffects();
+            }
+        }
+
+        public static Dictionary<string, FieldInfo> GetAttributeFields(Type type)
+        {
+            return AttributeFields.GetOrAdd(
+                type,
+                inputType =>
+                {
+                    return inputType
+                        .GetFields(
+                            BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic
+                        )
+                        .Where(field => field.FieldType == typeof(Attribute))
+                        .ToDictionary(field => field.Name, StringComparer.Ordinal);
+                }
+            );
+        }
+    }
+}

package/Runtime/Tags/AttributeUtilities.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: dc4f3eedfcfd48ad845ce12e010b8234
+timeCreated: 1746411795

package/Runtime/Tags/AttributesComponent.cs

@@ -0,0 +1,163 @@
+namespace WallstopStudios.UnityHelpers.Tags
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Reflection;
+    using Core.Attributes;
+    using UnityEngine;
+
+    [RequireComponent(typeof(TagHandler))]
+    [RequireComponent(typeof(EffectHandler))]
+    public abstract class AttributesComponent : MonoBehaviour
+    {
+        public event Action<string, float, float> OnAttributeModified;
+
+        private readonly Dictionary<string, FieldInfo> _attributeFields;
+        private readonly HashSet<EffectHandle> _effectHandles;
+
+        [SiblingComponent]
+        protected TagHandler _tagHandler;
+
+        [SiblingComponent]
+        protected EffectHandler _effectHandler;
+
+        protected AttributesComponent()
+        {
+            _attributeFields = AttributeUtilities.GetAttributeFields(GetType());
+            _effectHandles = new HashSet<EffectHandle>();
+        }
+
+        protected virtual void Awake()
+        {
+            this.AssignSiblingComponents();
+        }
+
+        public void ApplyAttributeModifications(
+            IEnumerable<AttributeModification> attributeModifications,
+            EffectHandle? handle
+        )
+        {
+            if (handle.HasValue)
+            {
+                ForceApplyAttributeModifications(handle.Value);
+                return;
+            }
+
+            InternalApplyAttributeModifications(attributeModifications);
+        }
+
+        public void ForceRemoveAttributeModifications(EffectHandle handle)
+        {
+            InternalRemoveAttributeModifications(handle);
+        }
+
+        private void InternalApplyAttributeModifications(
+            IEnumerable<AttributeModification> attributeModifications
+        )
+        {
+            foreach (AttributeModification modification in attributeModifications)
+            {
+                if (!TryGetAttribute(modification.attribute, out Attribute attribute))
+                {
+                    continue;
+                }
+
+                float oldValue = attribute;
+                attribute.ApplyAttributeModification(modification);
+                float currentValue = attribute;
+
+                OnAttributeModified?.Invoke(modification.attribute, oldValue, currentValue);
+            }
+        }
+
+        public void ForceApplyAttributeModifications(EffectHandle handle)
+        {
+            AttributeEffect effect = handle.effect;
+            if (effect.modifications is not { Count: > 0 })
+            {
+                return;
+            }
+
+            bool isNewEffect = false;
+            foreach (AttributeModification modification in effect.modifications)
+            {
+                if (!TryGetAttribute(modification.attribute, out Attribute attribute))
+                {
+                    continue;
+                }
+
+                isNewEffect = isNewEffect || _effectHandles.Add(handle);
+                if (isNewEffect)
+                {
+                    float oldValue = attribute;
+                    attribute.ApplyAttributeModification(modification, handle);
+                    float currentValue = attribute;
+                    OnAttributeModified?.Invoke(modification.attribute, oldValue, currentValue);
+                }
+            }
+        }
+
+        public void ForceApplyAttributeModifications(AttributeEffect effect)
+        {
+            if (effect.modifications is not { Count: > 0 })
+            {
+                return;
+            }
+
+            foreach (AttributeModification modification in effect.modifications)
+            {
+                if (!TryGetAttribute(modification.attribute, out Attribute attribute))
+                {
+                    continue;
+                }
+
+                float oldValue = attribute;
+                attribute.ApplyAttributeModification(modification);
+                float currentValue = attribute;
+                OnAttributeModified?.Invoke(modification.attribute, oldValue, currentValue);
+            }
+        }
+
+        private void InternalRemoveAttributeModifications(EffectHandle handle)
+        {
+            AttributeEffect effect = handle.effect;
+            if (effect.modifications is not { Count: > 0 })
+            {
+                return;
+            }
+
+            foreach (AttributeModification modification in effect.modifications)
+            {
+                if (!TryGetAttribute(modification.attribute, out Attribute attribute))
+                {
+                    continue;
+                }
+
+                float oldValue = attribute;
+                _ = attribute.RemoveAttributeModification(handle);
+                float currentValue = attribute;
+                _ = _effectHandles.Remove(handle);
+                OnAttributeModified?.Invoke(modification.attribute, oldValue, currentValue);
+            }
+        }
+
+        private bool TryGetAttribute(string attributeName, out Attribute attribute)
+        {
+            if (!_attributeFields.TryGetValue(attributeName, out FieldInfo fieldInfo))
+            {
+                attribute = default;
+                return false;
+            }
+
+            object fieldValue = fieldInfo.GetValue(this);
+            if (fieldValue is Attribute fieldAttribute)
+            {
+                attribute = fieldAttribute;
+                return true;
+            }
+
+            attribute = default;
+            return false;
+        }
+    }
+}

package/Runtime/Tags/AttributesComponent.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: e159649b48764561acc18f759a259bc4
+timeCreated: 1746412114

package/Runtime/Tags/CosmeticEffectComponent.cs

@@ -0,0 +1,50 @@
+namespace WallstopStudios.UnityHelpers.Tags
+{
+    using System.Collections.Generic;
+    using Core.Extension;
+    using UnityEngine;
+
+    [RequireComponent(typeof(CosmeticEffectData))]
+    public abstract class CosmeticEffectComponent : MonoBehaviour
+    {
+        public virtual bool RequiresInstance => false;
+
+        public virtual bool CleansUpSelf => false;
+
+        protected readonly List<GameObject> _appliedTargets = new();
+
+        protected virtual void OnDestroy()
+        {
+            if (_appliedTargets.Count <= 0)
+            {
+                return;
+            }
+
+            foreach (GameObject appliedTarget in _appliedTargets.ToArray())
+            {
+                if (appliedTarget == null)
+                {
+                    continue;
+                }
+
+                OnRemoveEffect(appliedTarget);
+            }
+        }
+
+        // Executed when the associated effect is applied.
+        public virtual void OnApplyEffect(GameObject target)
+        {
+            _appliedTargets.Add(target);
+        }
+
+        // Executed when the associated effect is non-instant and removed.
+        public virtual void OnRemoveEffect(GameObject target)
+        {
+            int appliedIndex = _appliedTargets.IndexOf(target);
+            if (0 <= appliedIndex)
+            {
+                _appliedTargets.RemoveAtSwapBack(appliedIndex);
+            }
+        }
+    }
+}

package/Runtime/Tags/CosmeticEffectComponent.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 5f516b2dba5a4ff89d811a493f54aeb8
+timeCreated: 1746411911

package/Runtime/Tags/CosmeticEffectData.cs

@@ -0,0 +1,63 @@
+namespace WallstopStudios.UnityHelpers.Tags
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using Core.Helper;
+    using UnityEngine;
+
+    [DisallowMultipleComponent]
+    public sealed class CosmeticEffectData : MonoBehaviour, IEquatable<CosmeticEffectData>
+    {
+        // Is an instanced version of this gameObject created when applied.
+        public bool RequiresInstancing =>
+            _cosmetics.Value.Any(cosmeticEffect => cosmeticEffect.RequiresInstance);
+
+        [NonSerialized]
+        private readonly Lazy<CosmeticEffectComponent[]> _cosmetics;
+
+        [NonSerialized]
+        private readonly Lazy<HashSet<Type>> _cosmeticTypes;
+
+        public CosmeticEffectData()
+        {
+            _cosmetics = new Lazy<CosmeticEffectComponent[]>(
+                GetComponents<CosmeticEffectComponent>
+            );
+            _cosmeticTypes = new Lazy<HashSet<Type>>(
+                () => _cosmetics.Value.Select(cosmetic => cosmetic.GetType()).ToHashSet()
+            );
+        }
+
+        public override bool Equals(object other)
+        {
+            return other is CosmeticEffectData cosmeticEffectData && Equals(cosmeticEffectData);
+        }
+
+        public bool Equals(CosmeticEffectData other)
+        {
+            if (ReferenceEquals(this, other))
+            {
+                return true;
+            }
+
+            if (other == null || GetHashCode() != other.GetHashCode())
+            {
+                return false;
+            }
+
+            bool componentTypeEquals = _cosmeticTypes.Value.SetEquals(other._cosmeticTypes.Value);
+            if (!componentTypeEquals)
+            {
+                return false;
+            }
+
+            return Helpers.NameEquals(this, other);
+        }
+
+        public override int GetHashCode()
+        {
+            return _cosmeticTypes.Value.Count.GetHashCode();
+        }
+    }
+}

package/Runtime/Tags/CosmeticEffectData.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 2488ba4d39ca49d9ab5df6d17db6c1ec
+timeCreated: 1746411879

package/Runtime/Tags/EffectHandle.cs

@@ -0,0 +1,63 @@
+namespace WallstopStudios.UnityHelpers.Tags
+{
+    using System;
+    using Core.DataStructure.Adapters;
+    using Core.Extension;
+
+    [Serializable]
+    public readonly struct EffectHandle
+        : IEquatable<EffectHandle>,
+            IComparable<EffectHandle>,
+            IComparable
+    {
+        public readonly AttributeEffect effect;
+
+        public readonly KGuid id;
+
+        public static EffectHandle CreateInstance(AttributeEffect effect)
+        {
+            return new EffectHandle(Guid.NewGuid(), effect);
+        }
+
+        private EffectHandle(KGuid id, AttributeEffect effect)
+        {
+            this.id = id;
+            this.effect = effect;
+        }
+
+        public int CompareTo(EffectHandle other)
+        {
+            return id.CompareTo(other.id);
+        }
+
+        public int CompareTo(object obj)
+        {
+            if (obj is EffectHandle other)
+            {
+                return CompareTo(other);
+            }
+
+            return -1;
+        }
+
+        public override bool Equals(object obj)
+        {
+            return obj is EffectHandle other && Equals(other);
+        }
+
+        public bool Equals(EffectHandle other)
+        {
+            return id == other.id;
+        }
+
+        public override int GetHashCode()
+        {
+            return id.GetHashCode();
+        }
+
+        public override string ToString()
+        {
+            return this.ToJson();
+        }
+    }
+}

package/Runtime/Tags/EffectHandle.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 03e83359d25d4e778ea39698c68bceb4
+timeCreated: 1746412025