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

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

package/Runtime/Tags/EffectHandler.cs

@@ -0,0 +1,380 @@
+namespace WallstopStudios.UnityHelpers.Tags
+{
+    using System.Collections.Generic;
+    using System.Linq;
+    using Core.Attributes;
+    using Core.DataStructure.Adapters;
+    using Core.Extension;
+    using Core.Helper;
+    using UnityEngine;
+    using Utils;
+
+    [DisallowMultipleComponent]
+    [RequireComponent(typeof(TagHandler))]
+    public sealed class EffectHandler : MonoBehaviour
+    {
+        [SiblingComponent()]
+        private TagHandler _tagHandler;
+
+        [SiblingComponent(optional = true)]
+        private AttributesComponent[] _attributes;
+
+        // Stores instanced cosmetic effect data for associated effects.
+        private readonly Dictionary<
+            EffectHandle,
+            List<CosmeticEffectData>
+        > _instancedCosmeticEffects = new();
+
+        // Stores expiration time of duration effects (We store by Id because it's much cheaper to iterate Guids than it is EffectHandles
+        private readonly Dictionary<KGuid, float> _effectExpirations = new();
+        private readonly Dictionary<KGuid, EffectHandle> _effectHandlesById = new();
+
+        // Used only to save allocations in Update()
+        private readonly List<KGuid> _expiredEffectIds = new();
+        private readonly List<EffectHandle> _appliedEffects = new();
+
+        private bool _initialized;
+
+        private void Awake()
+        {
+            this.AssignRelationalComponents();
+            _initialized = true;
+        }
+
+        public EffectHandle? ApplyEffect(AttributeEffect effect)
+        {
+            EffectHandle? maybeHandle = null;
+
+            if (effect.durationType != ModifierDurationType.Instant)
+            {
+                if (effect.durationType == ModifierDurationType.Duration)
+                {
+                    foreach (EffectHandle appliedEffect in _appliedEffects)
+                    {
+                        if (appliedEffect.effect == null)
+                        {
+                            continue;
+                        }
+
+                        string serializableName = appliedEffect.effect.name;
+                        if (string.Equals(effect.name, serializableName))
+                        {
+                            maybeHandle = appliedEffect;
+                            break;
+                        }
+                    }
+                }
+
+                maybeHandle ??= EffectHandle.CreateInstance(effect);
+            }
+
+            if (maybeHandle.HasValue)
+            {
+                EffectHandle handle = maybeHandle.Value;
+                InternalApplyEffect(handle);
+                if (
+                    effect.durationType == ModifierDurationType.Duration
+                    && (effect.resetDurationOnReapplication || !_appliedEffects.Contains(handle))
+                )
+                {
+                    KGuid handleId = handle.id;
+                    _effectExpirations[handleId] = Time.time + effect.duration;
+                    _effectHandlesById[handleId] = handle;
+                }
+            }
+            else
+            {
+                InternalApplyEffect(effect);
+            }
+
+            return maybeHandle;
+        }
+
+        public void RemoveEffect(EffectHandle handle)
+        {
+            InternalRemoveEffect(handle);
+            _ = _appliedEffects.Remove(handle);
+        }
+
+        public void RemoveAllEffects()
+        {
+            foreach (EffectHandle handle in _appliedEffects.ToArray())
+            {
+                InternalRemoveEffect(handle);
+            }
+            _appliedEffects.Clear();
+        }
+
+        private void InternalRemoveEffect(EffectHandle handle)
+        {
+            foreach (AttributesComponent attributesComponent in _attributes)
+            {
+                attributesComponent.ForceRemoveAttributeModifications(handle);
+            }
+
+            if (!_initialized && _tagHandler == null)
+            {
+                this.AssignRelationalComponents();
+            }
+
+            // Then, tags are removed (so cosmetic components can look up if any tags are still applied)
+            if (_tagHandler != null)
+            {
+                _ = _tagHandler.ForceRemoveTags(handle);
+            }
+
+            KGuid handleId = handle.id;
+            _ = _effectExpirations.Remove(handleId);
+            _ = _effectHandlesById.Remove(handleId);
+            InternalRemoveCosmeticEffects(handle);
+        }
+
+        private void InternalApplyEffect(EffectHandle handle)
+        {
+            bool exists = _appliedEffects.Contains(handle);
+            if (!exists)
+            {
+                _appliedEffects.Add(handle);
+            }
+
+            AttributeEffect effect = handle.effect;
+            if (effect.durationType == ModifierDurationType.Duration)
+            {
+                if (effect.resetDurationOnReapplication || !exists)
+                {
+                    KGuid handleId = handle.id;
+                    _effectExpirations[handleId] = Time.time + effect.duration;
+                    _effectHandlesById[handleId] = handle;
+                }
+            }
+
+            if (!_initialized && _tagHandler == null)
+            {
+                this.AssignRelationalComponents();
+            }
+
+            if (_tagHandler != null && effect.effectTags is { Count: > 0 })
+            {
+                _tagHandler.ForceApplyTags(handle);
+            }
+
+            if (effect.cosmeticEffects is { Count: > 0 })
+            {
+                InternalApplyCosmeticEffects(handle);
+            }
+
+            if (effect.modifications is { Count: > 0 })
+            {
+                foreach (AttributesComponent attributesComponent in _attributes)
+                {
+                    attributesComponent.ForceApplyAttributeModifications(handle);
+                }
+            }
+        }
+
+        private void InternalApplyEffect(AttributeEffect effect)
+        {
+            if (!_initialized && _tagHandler == null)
+            {
+                this.AssignRelationalComponents();
+            }
+
+            if (_tagHandler != null && effect.effectTags is { Count: > 0 })
+            {
+                _tagHandler.ForceApplyEffect(effect);
+            }
+
+            if (effect.cosmeticEffects is { Count: > 0 })
+            {
+                InternalApplyCosmeticEffects(effect);
+            }
+
+            if (effect.modifications is { Count: > 0 })
+            {
+                foreach (AttributesComponent attributesComponent in _attributes)
+                {
+                    attributesComponent.ForceApplyAttributeModifications(effect);
+                }
+            }
+        }
+
+        private void InternalApplyCosmeticEffects(EffectHandle handle)
+        {
+            if (_instancedCosmeticEffects.ContainsKey(handle))
+            {
+                return;
+            }
+
+            List<CosmeticEffectData> instancedCosmeticData = null;
+
+            AttributeEffect effect = handle.effect;
+
+            foreach (CosmeticEffectData cosmeticEffectData in effect.cosmeticEffects)
+            {
+                CosmeticEffectData cosmeticEffect = cosmeticEffectData;
+                if (cosmeticEffect == null)
+                {
+                    this.LogError(
+                        $"CosmeticEffectData is null for effect {effect:json}, cannot determine instancing scheme."
+                    );
+                    continue;
+                }
+
+                if (cosmeticEffectData.RequiresInstancing)
+                {
+                    cosmeticEffect = Instantiate(
+                        cosmeticEffectData,
+                        transform.position,
+                        Quaternion.identity
+                    );
+                    cosmeticEffect.transform.SetParent(transform, true);
+                    (instancedCosmeticData ??= new List<CosmeticEffectData>()).Add(cosmeticEffect);
+                }
+
+                Buffers<CosmeticEffectComponent>.List.Clear();
+                cosmeticEffect.GetComponents(Buffers<CosmeticEffectComponent>.List);
+                foreach (
+                    CosmeticEffectComponent cosmeticComponent in Buffers<CosmeticEffectComponent>.List
+                )
+                {
+                    cosmeticComponent.OnApplyEffect(gameObject);
+                }
+            }
+
+            if (instancedCosmeticData != null)
+            {
+                _instancedCosmeticEffects.Add(handle, instancedCosmeticData);
+            }
+        }
+
+        private void InternalApplyCosmeticEffects(AttributeEffect attributeEffect)
+        {
+            foreach (CosmeticEffectData cosmeticEffectData in attributeEffect.cosmeticEffects)
+            {
+                CosmeticEffectData cosmeticEffect = cosmeticEffectData;
+                if (cosmeticEffect == null)
+                {
+                    this.LogError(
+                        $"CosmeticEffectData is null for effect {attributeEffect:json}, cannot determine instancing scheme."
+                    );
+                    continue;
+                }
+
+                if (cosmeticEffectData.RequiresInstancing)
+                {
+                    this.LogError(
+                        $"CosmeticEffectData requires instancing, but can't instance (no handle)."
+                    );
+                    continue;
+                }
+
+                Buffers<CosmeticEffectComponent>.List.Clear();
+                cosmeticEffect.GetComponents(Buffers<CosmeticEffectComponent>.List);
+                foreach (
+                    CosmeticEffectComponent cosmeticComponent in Buffers<CosmeticEffectComponent>.List
+                )
+                {
+                    cosmeticComponent.OnApplyEffect(gameObject);
+                }
+            }
+        }
+
+        private void InternalRemoveCosmeticEffects(EffectHandle handle)
+        {
+            if (
+                !_instancedCosmeticEffects.TryGetValue(
+                    handle,
+                    out List<CosmeticEffectData> cosmeticDatas
+                )
+            )
+            {
+                // If we don't have instanced cosmetic effects, then they were applied directly to the cosmetic data
+                foreach (
+                    CosmeticEffectData cosmeticEffectData in handle.effect.cosmeticEffects
+                        ?? Enumerable.Empty<CosmeticEffectData>()
+                )
+                {
+                    if (cosmeticEffectData.RequiresInstancing)
+                    {
+                        this.LogWarn(
+                            $"Double-deregistration detected for handle {handle:json}. Existing handles: [{(string.Join(",", _instancedCosmeticEffects.Keys))}]."
+                        );
+                        continue;
+                    }
+
+                    Buffers<CosmeticEffectComponent>.List.Clear();
+                    cosmeticEffectData.GetComponents(Buffers<CosmeticEffectComponent>.List);
+                    foreach (
+                        CosmeticEffectComponent cosmeticComponent in Buffers<CosmeticEffectComponent>.List
+                    )
+                    {
+                        cosmeticComponent.OnRemoveEffect(gameObject);
+                    }
+                }
+
+                return;
+            }
+
+            foreach (
+                CosmeticEffectComponent cosmeticComponent in cosmeticDatas.SelectMany(
+                    cosmeticData => cosmeticData.GetComponents<CosmeticEffectComponent>()
+                )
+            )
+            {
+                cosmeticComponent.OnRemoveEffect(gameObject);
+            }
+
+            foreach (CosmeticEffectData data in cosmeticDatas)
+            {
+                bool shouldDestroyGameObject = true;
+                Buffers<CosmeticEffectComponent>.List.Clear();
+                data.GetComponents(Buffers<CosmeticEffectComponent>.List);
+                foreach (
+                    CosmeticEffectComponent cosmeticEffect in Buffers<CosmeticEffectComponent>.List
+                )
+                {
+                    if (cosmeticEffect.CleansUpSelf)
+                    {
+                        shouldDestroyGameObject = false;
+                        continue;
+                    }
+
+                    cosmeticEffect.Destroy();
+                }
+
+                if (shouldDestroyGameObject)
+                {
+                    data.gameObject.Destroy();
+                }
+            }
+
+            _ = _instancedCosmeticEffects.Remove(handle);
+        }
+
+        private void Update()
+        {
+            if (_effectExpirations.Count <= 0)
+            {
+                return;
+            }
+
+            _expiredEffectIds.Clear();
+            float currentTime = Time.time;
+            foreach (KeyValuePair<KGuid, float> entry in _effectExpirations)
+            {
+                if (entry.Value < currentTime)
+                {
+                    _expiredEffectIds.Add(entry.Key);
+                }
+            }
+
+            foreach (KGuid expiredHandleId in _expiredEffectIds)
+            {
+                if (_effectHandlesById.TryGetValue(expiredHandleId, out EffectHandle expiredHandle))
+                {
+                    RemoveEffect(expiredHandle);
+                }
+            }
+        }
+    }
+}

package/Runtime/Tags/EffectHandler.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 71af441977c84ab89137ea71d50f9711
+timeCreated: 1746412073

package/Runtime/Tags/ModificationAction.cs

@@ -0,0 +1,9 @@
+namespace WallstopStudios.UnityHelpers.Tags
+{
+    public enum ModificationAction
+    {
+        Addition = 0,
+        Multiplication = 1,
+        Override = 2,
+    }
+}

package/Runtime/Tags/ModificationAction.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 9bb8be0f5a12424ebeb7a85407acb829
+timeCreated: 1746412003

package/Runtime/Tags/ModifierDurationType.cs

@@ -0,0 +1,13 @@
+namespace WallstopStudios.UnityHelpers.Tags
+{
+    using System;
+
+    public enum ModifierDurationType
+    {
+        [Obsolete("Please use a valid value.")]
+        None = 0,
+        Instant = 1,
+        Duration = 2,
+        Infinite = 3,
+    }
+}

package/Runtime/Tags/ModifierDurationType.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: a9634fe2d4e84180a4743b759e45ae07
+timeCreated: 1746411840

package/Runtime/{Utils → Tags}/TagHandler.cs

@@ -1,21 +1,23 @@
-namespace WallstopStudios.UnityHelpers.Utils
+namespace WallstopStudios.UnityHelpers.Tags
 {
     using System;
     using System.Collections.Generic;
+    using Core.DataStructure.Adapters;
     using Core.Extension;
     using UnityEngine;
 
     [DisallowMultipleComponent]
-    public class TagHandler : MonoBehaviour
+    public sealed class TagHandler : MonoBehaviour
     {
         public IReadOnlyCollection<string> Tags => _tagCount.Keys;
 
         [SerializeField]
-        protected List<string> _initialEffectTags = new();
+        private List<string> _initialEffectTags = new();
 
-        protected readonly Dictionary<string, uint> _tagCount = new(StringComparer.Ordinal);
+        private readonly Dictionary<string, uint> _tagCount = new(StringComparer.Ordinal);
+        private readonly Dictionary<KGuid, EffectHandle> _effectHandles = new();
 
-        protected virtual void Awake()
+        private void Awake()
         {
             if (_initialEffectTags is { Count: > 0 })
             {
@@ -74,6 +76,41 @@
             InternalRemoveTag(effectTag);
         }
 
+        public void ForceApplyTags(EffectHandle handle)
+        {
+            KGuid id = handle.id;
+            if (!_effectHandles.TryAdd(id, handle))
+            {
+                return;
+            }
+
+            ForceApplyEffect(handle.effect);
+        }
+
+        public void ForceApplyEffect(AttributeEffect effect)
+        {
+            foreach (string effectTag in effect.effectTags)
+            {
+                InternalApplyTag(effectTag);
+            }
+        }
+
+        public bool ForceRemoveTags(EffectHandle handle)
+        {
+            KGuid id = handle.id;
+            if (!_effectHandles.Remove(id, out EffectHandle appliedHandle))
+            {
+                return false;
+            }
+
+            foreach (string effectTag in appliedHandle.effect.effectTags)
+            {
+                InternalRemoveTag(effectTag);
+            }
+
+            return true;
+        }
+
         private void InternalApplyTag(string effectTag)
         {
             _ = _tagCount.AddOrUpdate(effectTag, _ => 1U, (_, existing) => existing + 1);

package/Runtime/Tags.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 2f6f239e36294f98b1e6dcc2d0a1c45c
+timeCreated: 1746411527