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

package/Runtime/Tags/EffectHandler.cs

@@ -0,0 +1,379 @@
+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]
+    public sealed class EffectHandler : MonoBehaviour
+    {
+        [SiblingComponent(optional = true)]
+        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

package/Tests/Runtime/DataStructures/SpatialTreeTests.cs

@@ -2,8 +2,8 @@
 {
     using System.Collections.Generic;
     using System.Linq;
+    using Core.DataStructure;
     using NUnit.Framework;
-    using WallstopStudios.UnityHelpers.Core.DataStructure;
     using WallstopStudios.UnityHelpers.Core.Helper;
     using WallstopStudios.UnityHelpers.Core.Random;
     using Vector2 = UnityEngine.Vector2;

package/Tests/Runtime/Helper/ObjectHelperTests.cs

@@ -2,6 +2,7 @@
 {
     using System.Collections;
     using Core.Helper;
+    using Core.Helper.Partials;
     using JetBrains.Annotations;
     using NUnit.Framework;
     using UnityEngine;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "com.wallstop-studios.unity-helpers",
-  "version": "2.0.0-rc67",
+  "version": "2.0.0-rc69",
   "displayName": "Unity Helpers",
   "description": "Various Unity Helper Library",
   "dependencies": {},