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

package/Runtime/Tags/AttributeEffect.cs

@@ -0,0 +1,276 @@
+namespace WallstopStudios.UnityHelpers.Tags
+{
+    using System;
+    using System.Collections.Generic;
+    using System.ComponentModel;
+    using System.Linq;
+    using System.Text;
+    using Core.Extension;
+    using Core.Helper;
+    using Newtonsoft.Json;
+    using Sirenix.OdinInspector;
+
+    [Serializable]
+    public sealed class AttributeEffect :
+#if ODIN_INSPECTOR
+        SerializedScriptableObject
+#else
+        ScriptableObject
+#endif
+            , IEquatable<AttributeEffect>
+    {
+        public string HumanReadableDescription => BuildDescription();
+
+        public readonly List<AttributeModification> modifications = new();
+
+        public ModifierDurationType durationType = ModifierDurationType.Duration;
+
+#if ODIN_INSPECTOR
+        [ShowIf("@durationType == ModifierDurationType.Duration")]
+#endif
+        public float duration;
+
+#if ODIN_INSPECTOR
+        [ShowIf("@durationType == ModifierDurationType.Duration")]
+#endif
+        public bool resetDurationOnReapplication;
+
+        public List<string> effectTags = new();
+
+        [JsonIgnore]
+        public readonly List<CosmeticEffectData> cosmeticEffects = new();
+
+        private List<string> CosmeticEffectsForJson =>
+            cosmeticEffects
+                ?.Select(cosmeticEffectData => cosmeticEffectData.name)
+                .ToList(cosmeticEffects.Count) ?? new List<string>(0);
+
+        public override string ToString()
+        {
+            return new
+            {
+                Description = HumanReadableDescription,
+                CosmeticEffects = CosmeticEffectsForJson,
+                modifications,
+                durationType,
+                duration,
+                tags = effectTags,
+            }.ToJson();
+        }
+
+        private string BuildDescription()
+        {
+            if (modifications == null)
+            {
+                return nameof(AttributeEffect);
+            }
+
+            StringBuilder descriptionBuilder = new();
+            for (int i = 0; i < modifications.Count; ++i)
+            {
+                AttributeModification modification = modifications[i];
+                switch (modification.action)
+                {
+                    case ModificationAction.Addition:
+                    {
+                        if (modification.value < 0)
+                        {
+                            _ = descriptionBuilder.Append(modification.value);
+                            _ = descriptionBuilder.Append(' ');
+                        }
+                        else if (modification.value == 0)
+                        {
+                            continue;
+                        }
+                        else
+                        {
+                            _ = descriptionBuilder.AppendFormat("+{0} ", modification.value);
+                        }
+
+                        break;
+                    }
+                    case ModificationAction.Multiplication:
+                    {
+                        if (modification.value < 1)
+                        {
+                            _ = descriptionBuilder.AppendFormat(
+                                "-{0}% ",
+                                (1 - modification.value) * 100
+                            );
+                        }
+                        // ReSharper disable once CompareOfFloatsByEqualityOperator
+                        else if (modification.value == 1)
+                        {
+                            continue;
+                        }
+                        else
+                        {
+                            _ = descriptionBuilder.AppendFormat(
+                                "+{0}% ",
+                                (modification.value - 1) * 100
+                            );
+                        }
+
+                        break;
+                    }
+                    case ModificationAction.Override:
+                    {
+                        _ = descriptionBuilder.AppendFormat("{0} ", modification.value);
+                        break;
+                    }
+                    default:
+                    {
+                        throw new InvalidEnumArgumentException(
+                            nameof(modification.value),
+                            (int)modification.value,
+                            typeof(ModificationAction)
+                        );
+                    }
+                }
+
+                _ = descriptionBuilder.Append(modification.attribute.ToPascalCase(" "));
+                if (i < modifications.Count - 1)
+                {
+                    _ = descriptionBuilder.Append(", ");
+                }
+            }
+
+            return descriptionBuilder.ToString();
+        }
+
+        // Needed now since most things are based on serialized attribute effects and each unserialization will be a new instance
+        public bool Equals(AttributeEffect other)
+        {
+            if (ReferenceEquals(this, other))
+            {
+                return true;
+            }
+
+            if (other == null)
+            {
+                return false;
+            }
+
+            if (!string.Equals(name, other.name))
+            {
+                return false;
+            }
+
+            if (durationType != other.durationType)
+            {
+                return false;
+            }
+
+            // ReSharper disable once CompareOfFloatsByEqualityOperator
+            if (duration != other.duration)
+            {
+                return false;
+            }
+
+            if (resetDurationOnReapplication != other.resetDurationOnReapplication)
+            {
+                return false;
+            }
+
+            if (modifications == null)
+            {
+                if (other.modifications != null)
+                {
+                    return false;
+                }
+            }
+            else if (other.modifications == null)
+            {
+                return false;
+            }
+            else
+            {
+                if (modifications.Count != other.modifications.Count)
+                {
+                    return false;
+                }
+
+                for (int i = 0; i < modifications.Count; ++i)
+                {
+                    if (modifications[i] != other.modifications[i])
+                    {
+                        return false;
+                    }
+                }
+            }
+
+            if (effectTags == null)
+            {
+                if (other.effectTags != null)
+                {
+                    return false;
+                }
+            }
+            else if (other.effectTags == null)
+            {
+                return false;
+            }
+            else
+            {
+                if (effectTags.Count != other.effectTags.Count)
+                {
+                    return false;
+                }
+
+                for (int i = 0; i < effectTags.Count; ++i)
+                {
+                    if (effectTags[i] != other.effectTags[i])
+                    {
+                        return false;
+                    }
+                }
+            }
+
+            if (cosmeticEffects == null)
+            {
+                if (other.cosmeticEffects != null)
+                {
+                    return false;
+                }
+            }
+            else if (other.cosmeticEffects == null)
+            {
+                return false;
+            }
+            else
+            {
+                if (cosmeticEffects.Count != other.cosmeticEffects.Count)
+                {
+                    return false;
+                }
+
+                for (int i = 0; i < cosmeticEffects.Count; ++i)
+                {
+                    if (!Equals(cosmeticEffects[i], other.cosmeticEffects[i]))
+                    {
+                        return false;
+                    }
+                }
+            }
+
+            return true;
+        }
+
+        public override bool Equals(object obj)
+        {
+            return ReferenceEquals(this, obj) || obj is AttributeEffect other && Equals(other);
+        }
+
+        public override int GetHashCode()
+        {
+            return Objects.HashCode(
+                modifications?.Count,
+                durationType,
+                duration,
+                resetDurationOnReapplication,
+                effectTags?.Count,
+                cosmeticEffects?.Count
+            );
+        }
+    }
+}

package/Runtime/Tags/AttributeEffect.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 000e706d0ccd45d8a776c1a9b9d4928b
+timeCreated: 1746411716

package/Runtime/Tags/AttributeModification.cs

@@ -0,0 +1,51 @@
+namespace WallstopStudios.UnityHelpers.Tags
+{
+    using System;
+    using Core.Extension;
+    using Core.Helper;
+
+    [Serializable]
+    public struct AttributeModification : IEquatable<AttributeModification>
+    {
+        [StringInList(typeof(AttributeUtilities), nameof(AttributeUtilities.GetAllAttributeNames))]
+        public string attribute;
+
+        public ModificationAction action;
+        public float value;
+
+        public override string ToString()
+        {
+            return this.ToJson();
+        }
+
+        public static bool operator !=(AttributeModification lhs, AttributeModification rhs)
+        {
+            return !(lhs == rhs);
+        }
+
+        public static bool operator ==(AttributeModification lhs, AttributeModification rhs)
+        {
+            // ReSharper disable once CompareOfFloatsByEqualityOperator
+            return string.Equals(lhs.attribute, rhs.attribute)
+                && lhs.action == rhs.action
+                && lhs.value == rhs.value;
+        }
+
+        public override bool Equals(object obj)
+        {
+            return obj is AttributeModification other && Equals(other);
+        }
+
+        public override int GetHashCode()
+        {
+            return Objects.HashCode(attribute, action, value);
+        }
+
+        public bool Equals(AttributeModification other)
+        {
+            return string.Equals(attribute, other.attribute, StringComparison.Ordinal)
+                && action == other.action
+                && value.Equals(other.value);
+        }
+    }
+}

package/Runtime/Tags/AttributeModification.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: aa8638bb1ef14228b7496f0d7b12262d
+timeCreated: 1746411774

package/Runtime/Tags/AttributeUtilities.cs

@@ -0,0 +1,209 @@
+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;
+            }
+
+            EffectHandler effectHandler = target.GetGameObject().GetOrAddComponent<EffectHandler>();
+            return effectHandler.ApplyEffect(attributeEffect);
+        }
+
+        public static void ApplyEffectsNoAlloc(
+            this Object target,
+            List<AttributeEffect> attributeEffects
+        )
+        {
+            if (attributeEffects is not { Count: > 0 })
+            {
+                return;
+            }
+
+            if (target == null)
+            {
+                return;
+            }
+            EffectHandler effectHandler = target.GetGameObject().GetOrAddComponent<EffectHandler>();
+            foreach (AttributeEffect attributeEffect in attributeEffects)
+            {
+                _ = effectHandler.ApplyEffect(attributeEffect);
+            }
+        }
+
+        public static void ApplyEffectsNoAlloc(
+            this Object target,
+            IEnumerable<AttributeEffect> attributeEffects
+        )
+        {
+            if (target == null)
+            {
+                return;
+            }
+
+            EffectHandler effectHandler = target.GetGameObject().GetOrAddComponent<EffectHandler>();
+            foreach (AttributeEffect attributeEffect in attributeEffects)
+            {
+                _ = effectHandler.ApplyEffect(attributeEffect);
+            }
+        }
+
+        public static void ApplyEffectsNoAlloc(
+            this Object target,
+            List<AttributeEffect> attributeEffects,
+            List<EffectHandle> effectHandles
+        )
+        {
+            if (target == null)
+            {
+                return;
+            }
+
+            EffectHandler effectHandler = target.GetGameObject().GetOrAddComponent<EffectHandler>();
+            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;
+        }
+    }
+}