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

package/Runtime/Core/Attributes/ValidateAssignmentAttribute.cs

@@ -6,7 +6,7 @@
     using System.Linq;
     using System.Reflection;
     using Extension;
-    using Helper.Partials;
+    using Helper;
     using JetBrains.Annotations;
     using Object = UnityEngine.Object;
 

package/Runtime/Core/Helper/Helpers.cs

@@ -20,7 +20,7 @@
     {
         private static readonly WaitForEndOfFrame WaitForEndOfFrame = new();
         private static readonly Dictionary<Type, MethodInfo> AwakeMethodsByType = new();
-        private static readonly Object LogObject = new() { name = "Wallstop Log Helper" };
+        private static readonly Object LogObject = new();
         private static readonly Dictionary<string, Object> ObjectsByTag = new(
             StringComparer.Ordinal
         );

package/Runtime/Core/Helper/Partials/LogHelpers.cs

@@ -1,4 +1,4 @@
-namespace WallstopStudios.UnityHelpers.Core.Helper.Partials
+namespace WallstopStudios.UnityHelpers.Core.Helper
 {
     using Extension;
     using UnityEngine;

package/Runtime/Core/Helper/Partials/MathHelpers.cs

@@ -1,4 +1,4 @@
-namespace WallstopStudios.UnityHelpers.Core.Helper.Partials
+namespace WallstopStudios.UnityHelpers.Core.Helper
 {
     using UnityEngine;
 

package/Runtime/Core/Helper/Partials/ObjectHelpers.cs

@@ -2,13 +2,12 @@
 {
     using System;
     using Extension;
+    using UnityEditor;
+    using UnityEditor.SceneManagement;
     using UnityEngine;
     using UnityEngine.SceneManagement;
     using Object = UnityEngine.Object;
-#if UNITY_EDITOR
-    using UnityEditor;
-    using UnityEditor.SceneManagement;
-#endif
+
     public static partial class Helpers
     {
         public static T Find<T>(this Object component, string tag, bool log = true)

package/Runtime/Tags/Attribute.cs

@@ -0,0 +1,205 @@
+namespace WallstopStudios.UnityHelpers.Tags
+{
+    using System;
+    using System.Collections.Generic;
+    using System.ComponentModel;
+    using System.Globalization;
+    using System.Linq;
+    using System.Runtime.Serialization;
+    using System.Text.Json.Serialization;
+    using Core.Extension;
+    using ProtoBuf;
+    using UnityEngine;
+
+    [Serializable]
+    [ProtoContract]
+    public sealed class Attribute : IEquatable<Attribute>, IEquatable<float>
+    {
+        public float CurrentValue
+        {
+            get
+            {
+#if UNITY_EDITOR
+                /*
+                    For some reason, there's a bug with loot tables where
+                    _currentValueCalculated will be true but the current
+                    value is not calculated, so ignore the flag if we're
+                    in editor mode, where this happens
+                 */
+                if (Application.isPlaying)
+#endif
+                {
+                    if (_currentValueCalculated)
+                    {
+                        return _currentValue;
+                    }
+                }
+
+                CalculateCurrentValue();
+                return _currentValue;
+            }
+        }
+
+        public float BaseValue => _baseValue;
+
+        [SerializeField]
+        internal float _baseValue;
+
+        [SerializeField]
+        private float _currentValue;
+
+        private bool _currentValueCalculated;
+
+        internal void CalculateCurrentValue()
+        {
+            float calculatedValue = _baseValue;
+            foreach (
+                AttributeModification attributeModification in _modifications
+                    .SelectMany(kvp => kvp.Value)
+                    .OrderBy(mod => mod.action)
+            )
+            {
+                ApplyAttributeModification(attributeModification, ref calculatedValue);
+            }
+
+            _currentValue = calculatedValue;
+            _currentValueCalculated = true;
+        }
+
+        private readonly Dictionary<EffectHandle, List<AttributeModification>> _modifications =
+            new();
+
+        public static implicit operator float(Attribute attribute) => attribute.CurrentValue;
+
+        public static implicit operator Attribute(float value) => new(value);
+
+        public Attribute()
+            : this(0) { }
+
+        public Attribute(float value)
+        {
+            _baseValue = value;
+            _currentValueCalculated = false;
+        }
+
+        [JsonConstructor]
+        public Attribute(float baseValue, float currentValue)
+        {
+            _baseValue = baseValue;
+            _currentValue = currentValue;
+            _currentValueCalculated = true;
+        }
+
+        public void ClearCache()
+        {
+            _currentValueCalculated = false;
+        }
+
+        public void ApplyAttributeModification(
+            AttributeModification attributeModification,
+            EffectHandle? handle = null
+        )
+        {
+            // If we don't have a handle, then this is an instant effect, apply it to the base value.
+            if (!handle.HasValue)
+            {
+                ApplyAttributeModification(attributeModification, ref _baseValue);
+            }
+            else
+            {
+                _modifications.GetOrAdd(handle.Value).Add(attributeModification);
+            }
+
+            CalculateCurrentValue();
+        }
+
+        public bool RemoveAttributeModification(EffectHandle handle)
+        {
+            bool removed = _modifications.Remove(handle);
+            if (removed)
+            {
+                CalculateCurrentValue();
+            }
+
+            return removed;
+        }
+
+        [OnDeserialized]
+        private void AfterDeserialize(StreamingContext streamingContext)
+        {
+            ClearCache();
+        }
+
+        [ProtoAfterDeserialization]
+        private void AfterProtoDeserialized()
+        {
+            ClearCache();
+        }
+
+        private static void ApplyAttributeModification(
+            AttributeModification attributeModification,
+            ref float value
+        )
+        {
+            switch (attributeModification.action)
+            {
+                case ModificationAction.Addition:
+                    value += attributeModification.value;
+                    break;
+                case ModificationAction.Multiplication:
+                    value *= attributeModification.value;
+                    break;
+                case ModificationAction.Override:
+                    value = attributeModification.value;
+                    break;
+                default:
+                    throw new InvalidEnumArgumentException(
+                        nameof(attributeModification.action),
+                        (int)attributeModification.action,
+                        typeof(ModificationAction)
+                    );
+            }
+        }
+
+        public bool Equals(Attribute other)
+        {
+            if (ReferenceEquals(this, other))
+            {
+                return true;
+            }
+
+            return other != null && CurrentValue.Equals(other.CurrentValue);
+        }
+
+        public override bool Equals(object other)
+        {
+            switch (other)
+            {
+                case Attribute attribute:
+                    return Equals(attribute);
+                case float attribute:
+                    return Equals(attribute);
+                case double attribute:
+                    return Equals((float)attribute);
+                default:
+                    return false;
+            }
+        }
+
+        public bool Equals(float other)
+        {
+            return CurrentValue.Equals(other);
+        }
+
+        public override int GetHashCode()
+        {
+            // ReSharper disable once BaseObjectGetHashCodeCallInGetHashCode
+            return base.GetHashCode();
+        }
+
+        public override string ToString()
+        {
+            return ((float)this).ToString(CultureInfo.InvariantCulture);
+        }
+    }
+}

package/Runtime/Tags/Attribute.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 7209237176394eaf99a875c53950e2d0
+timeCreated: 1746412136

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