com.wallstop-studios.unity-helpers 2.0.4 → 2.1.1

package/Tests/Runtime/Random/FlurryBurstRandomTests.cs

@@ -0,0 +1,12 @@
+namespace WallstopStudios.UnityHelpers.Tests.Random
+{
+    using WallstopStudios.UnityHelpers.Core.Random;
+
+    public sealed class FlurryBurstRandomTests : RandomTestBase
+    {
+        protected override IRandom NewRandom()
+        {
+            return new FlurryBurstRandom();
+        }
+    }
+}

package/Tests/Runtime/Random/FlurryBurstRandomTests.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: a8708ba817fc4d00a3ef31b68f550aba
+timeCreated: 1761435962

package/Tests/Runtime/Random/PhotonSpinRandomTests.cs

@@ -0,0 +1,12 @@
+namespace WallstopStudios.UnityHelpers.Tests.Random
+{
+    using WallstopStudios.UnityHelpers.Core.Random;
+
+    public sealed class PhotonSpinRandomTests : RandomTestBase
+    {
+        protected override IRandom NewRandom()
+        {
+            return new PhotonSpinRandom();
+        }
+    }
+}

package/Tests/Runtime/Random/PhotonSpinRandomTests.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: d55cf2508f694064a195df1829686813
+timeCreated: 1761435962

package/Tests/Runtime/Random/RandomProtoSerializationTests.cs

@@ -171,6 +171,20 @@ namespace WallstopStudios.UnityHelpers.Tests.Random
             Assert.AreEqual(random.InternalState.State2, deserialized.InternalState.State2);
         }
 
+        [Test]
+        public void PhotonSpinRandomSerializesAndDeserializes()
+        {
+            PhotonSpinRandom random = new(Guid.Parse("0AF7CF4F-44F6-421E-B7DC-1ADEF9F27E19"));
+            VerifySerializationAndGeneration(random);
+        }
+
+        [Test]
+        public void StormDropRandomSerializesAndDeserializes()
+        {
+            StormDropRandom random = new(987654321u);
+            VerifySerializationAndGeneration(random);
+        }
+
         [Test]
         public void UnityRandomSerializesAndDeserializes()
         {

package/Tests/Runtime/Random/RandomTestBase.cs

@@ -514,19 +514,54 @@ namespace WallstopStudios.UnityHelpers.Tests.Random
 
         [Test]
         [Parallelizable]
-        public void Json()
+        public void JsonSerialization()
         {
             IRandom random = NewRandom();
             string json = random.ToJson();
             IRandom deserialized = Serializer.JsonDeserialize<IRandom>(json, random.GetType());
             Assert.AreEqual(random.InternalState, deserialized.InternalState);
 
-            if (NewRandom() is not UnityRandom)
+            if (random is not UnityRandom)
             {
                 for (int i = 0; i < NumGeneratorChecks; ++i)
                 {
-                    Assert.AreEqual(random.Next(), deserialized.Next());
-                    Assert.AreEqual(random.InternalState, deserialized.InternalState);
+                    Assert.AreEqual(random.Next(), deserialized.Next(), "Iteration: " + i);
+                    Assert.AreEqual(
+                        random.InternalState,
+                        deserialized.InternalState,
+                        "Iteration: " + i
+                    );
+                }
+            }
+        }
+
+        [Test]
+        [Parallelizable]
+        public void JsonSerializationWithMix()
+        {
+            for (int preMix = 1; preMix < 10; ++preMix)
+            {
+                IRandom random = NewRandom();
+                for (int j = 0; j < preMix; ++j)
+                {
+                    _ = random.Next();
+                }
+
+                string json = random.ToJson();
+                IRandom deserialized = Serializer.JsonDeserialize<IRandom>(json, random.GetType());
+                Assert.AreEqual(random.InternalState, deserialized.InternalState);
+
+                if (random is not UnityRandom)
+                {
+                    for (int i = 0; i < NumGeneratorChecks; ++i)
+                    {
+                        Assert.AreEqual(random.Next(), deserialized.Next(), "Iteration: " + i);
+                        Assert.AreEqual(
+                            random.InternalState,
+                            deserialized.InternalState,
+                            "Iteration: " + i
+                        );
+                    }
                 }
             }
         }

package/Tests/Runtime/Random/StormDropRandomTests.cs

@@ -0,0 +1,12 @@
+namespace WallstopStudios.UnityHelpers.Tests.Random
+{
+    using WallstopStudios.UnityHelpers.Core.Random;
+
+    public sealed class StormDropRandomTests : RandomTestBase
+    {
+        protected override IRandom NewRandom()
+        {
+            return new StormDropRandom();
+        }
+    }
+}

package/Tests/Runtime/Random/StormDropRandomTests.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: a1b35b62f8104abf94ed3a48e79d303f
+timeCreated: 1761441026

package/Tests/Runtime/Serialization/JsonSerializationTest.cs

@@ -4,6 +4,7 @@ namespace WallstopStudios.UnityHelpers.Tests.Serialization
     using System.Collections.Generic;
     using System.Linq;
     using System.Runtime.Serialization;
+    using System.Text.Json;
     using System.Text.Json.Serialization;
     using NUnit.Framework;
     using UnityEngine;
@@ -42,9 +43,9 @@ namespace WallstopStudios.UnityHelpers.Tests.Serialization
             using System.Text.Json.JsonDocument doc = System.Text.Json.JsonDocument.Parse(json);
             System.Text.Json.JsonElement root = doc.RootElement;
             Assert.AreEqual(System.Text.Json.JsonValueKind.Object, root.ValueKind);
-            Assert.True(root.TryGetProperty("name", out var name));
-            Assert.True(root.TryGetProperty("type", out var type));
-            Assert.True(root.TryGetProperty("instanceId", out var id));
+            Assert.True(root.TryGetProperty("name", out JsonElement name));
+            Assert.True(root.TryGetProperty("type", out JsonElement type));
+            Assert.True(root.TryGetProperty("instanceId", out JsonElement id));
             Assert.AreEqual("Test GameObject", name.GetString());
             StringAssert.Contains("UnityEngine.GameObject", type.GetString());
             Assert.AreEqual(expectedId, id.GetInt32());

package/Tests/Runtime/Serialization/ProtoInterfaceResolutionEdgeTests.cs

@@ -23,7 +23,7 @@ namespace WallstopStudios.UnityHelpers.Tests.Serialization
         public void SingleImplementationRequiresRegistration()
         {
             IWidget original = new Widget { Id = 3, Label = "ok" };
-            byte[] data = Serializer.ProtoSerialize<IWidget>(original);
+            byte[] data = Serializer.ProtoSerialize(original);
 
             Assert.Throws<ProtoException>(
                 () => Serializer.ProtoDeserialize<IWidget>(data),
@@ -65,7 +65,7 @@ namespace WallstopStudios.UnityHelpers.Tests.Serialization
         public void AbstractBaseWithoutRegistrationThrows()
         {
             AbstractBase original = new DerivedA { Common = 9, ExtraA = "x" };
-            byte[] data = Serializer.ProtoSerialize<AbstractBase>(original, forceRuntimeType: true);
+            byte[] data = Serializer.ProtoSerialize(original, forceRuntimeType: true);
 
             Assert.Throws<ProtoException>(
                 () => Serializer.ProtoDeserialize<AbstractBase>(data),

package/Tests/Runtime/Serialization/ProtoRootRegistrationTests.cs

@@ -37,7 +37,7 @@ namespace WallstopStudios.UnityHelpers.Tests.Serialization
         {
             IAnimal original = new Dog { Age = 5, Name = "Rex" };
 
-            byte[] data = Serializer.ProtoSerialize<IAnimal>(original);
+            byte[] data = Serializer.ProtoSerialize(original);
             Serializer.RegisterProtobufRoot<IAnimal, Dog>();
 
             IAnimal round = Serializer.ProtoDeserialize<IAnimal>(data);

package/Tests/Runtime/Serialization/ProtoSerializeBehaviorTests.cs

@@ -51,7 +51,7 @@ namespace WallstopStudios.UnityHelpers.Tests.Serialization
         public void ObjectDeclaredUsesRuntimeTypeByDefault()
         {
             object original = new DerivedMsg { A = 42, B = "obj" };
-            byte[] data = Serializer.ProtoSerialize<object>(original);
+            byte[] data = Serializer.ProtoSerialize(original);
             DerivedMsg round = Serializer.ProtoDeserialize<DerivedMsg>(data);
 
             Assert.IsNotNull(round, "Deserialized instance should not be null");

package/Tests/Runtime/Tags/AttributeEffectTests.cs

@@ -0,0 +1,135 @@
+namespace WallstopStudios.UnityHelpers.Tests.Tags
+{
+    using System.Text.Json;
+    using NUnit.Framework;
+    using UnityEngine;
+    using WallstopStudios.UnityHelpers.Tags;
+
+    [TestFixture]
+    public sealed class AttributeEffectTests : AttributeTagsTestBase
+    {
+        [Test]
+        public void HumanReadableDescriptionFormatsAllModificationTypes()
+        {
+            AttributeEffect effect = Track(ScriptableObject.CreateInstance<AttributeEffect>());
+            effect.name = "Composite";
+            effect.modifications.Add(
+                new AttributeModification
+                {
+                    attribute = "health",
+                    action = ModificationAction.Addition,
+                    value = 5f,
+                }
+            );
+            effect.modifications.Add(
+                new AttributeModification
+                {
+                    attribute = "attack_speed",
+                    action = ModificationAction.Multiplication,
+                    value = 1.5f,
+                }
+            );
+            effect.modifications.Add(
+                new AttributeModification
+                {
+                    attribute = "armor",
+                    action = ModificationAction.Override,
+                    value = 10f,
+                }
+            );
+
+            string description = effect.HumanReadableDescription;
+            Assert.AreEqual("+5 Health, +50% Attack Speed, 10 Armor", description);
+        }
+
+        [Test]
+        public void HumanReadableDescriptionSkipsNeutralModifications()
+        {
+            AttributeEffect effect = Track(ScriptableObject.CreateInstance<AttributeEffect>());
+            effect.modifications.Add(
+                new AttributeModification
+                {
+                    attribute = "health",
+                    action = ModificationAction.Addition,
+                    value = 0f,
+                }
+            );
+            effect.modifications.Add(
+                new AttributeModification
+                {
+                    attribute = "speed",
+                    action = ModificationAction.Multiplication,
+                    value = 1f,
+                }
+            );
+
+            Assert.IsEmpty(effect.HumanReadableDescription);
+        }
+
+        [Test]
+        public void ToStringSerializesSummaryAndCollections()
+        {
+            AttributeEffect effect = Track(ScriptableObject.CreateInstance<AttributeEffect>());
+            effect.name = "JsonEffect";
+            effect.durationType = ModifierDurationType.Duration;
+            effect.duration = 3.25f;
+            effect.resetDurationOnReapplication = true;
+            effect.modifications.Add(
+                new AttributeModification
+                {
+                    attribute = "health",
+                    action = ModificationAction.Addition,
+                    value = 10f,
+                }
+            );
+            effect.effectTags.Add("Buff");
+
+            GameObject cosmeticHolder = Track(new GameObject("Glow", typeof(CosmeticEffectData)));
+            CosmeticEffectData cosmeticData = cosmeticHolder.GetComponent<CosmeticEffectData>();
+            effect.cosmeticEffects.Add(cosmeticData);
+
+            using JsonDocument document = JsonDocument.Parse(effect.ToString());
+            JsonElement root = document.RootElement;
+            Assert.AreEqual(
+                effect.HumanReadableDescription,
+                root.GetProperty("Description").GetString()
+            );
+            Assert.AreEqual("Duration", root.GetProperty("durationType").GetString());
+            Assert.AreEqual(3.25f, root.GetProperty("duration").GetSingle());
+            Assert.AreEqual("Buff", root.GetProperty("tags")[0].GetString());
+            Assert.AreEqual("Glow", root.GetProperty("CosmeticEffects")[0].GetString());
+            Assert.AreEqual(1, root.GetProperty("modifications").GetArrayLength());
+        }
+
+        [Test]
+        public void EqualsRequiresMatchingState()
+        {
+            AttributeEffect left = Track(ScriptableObject.CreateInstance<AttributeEffect>());
+            AttributeEffect right = Track(ScriptableObject.CreateInstance<AttributeEffect>());
+            left.name = right.name = "Stack";
+            left.durationType = right.durationType = ModifierDurationType.Duration;
+            left.duration = right.duration = 2f;
+            left.resetDurationOnReapplication = right.resetDurationOnReapplication = false;
+
+            AttributeModification modification = new()
+            {
+                attribute = "health",
+                action = ModificationAction.Addition,
+                value = 5f,
+            };
+
+            left.modifications.Add(modification);
+            right.modifications.Add(modification);
+            Assert.IsTrue(left.Equals(right));
+
+            right.modifications[0] = new AttributeModification
+            {
+                attribute = "health",
+                action = ModificationAction.Addition,
+                value = 10f,
+            };
+
+            Assert.IsFalse(left.Equals(right));
+        }
+    }
+}

package/Tests/Runtime/Tags/AttributeEffectTests.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: f9cf8158bca5461c9fba12c31ab373b6
+timeCreated: 1761249361

package/Tests/Runtime/Tags/AttributeModificationTests.cs

@@ -0,0 +1,137 @@
+namespace WallstopStudios.UnityHelpers.Tests.Tags
+{
+    using System;
+    using System.Text.Json;
+    using NUnit.Framework;
+    using WallstopStudios.UnityHelpers.Core.Serialization;
+    using WallstopStudios.UnityHelpers.Tags;
+    using WallstopStudios.UnityHelpers.Tests.TestUtils;
+
+    public abstract class AttributeTagsTestBase : CommonTestBase
+    {
+        protected static void ResetEffectHandleId(long value = 0)
+        {
+            EffectHandle.Id = value;
+        }
+    }
+
+    [TestFixture]
+    public sealed class AttributeModificationTests
+    {
+        [Test]
+        public void EqualityOperatorsRespectFields()
+        {
+            AttributeModification baseline = new()
+            {
+                attribute = "health",
+                action = ModificationAction.Multiplication,
+                value = 1.5f,
+            };
+
+            AttributeModification clone = baseline;
+            Assert.IsTrue(baseline == clone);
+            Assert.IsFalse(baseline != clone);
+            Assert.AreEqual(baseline, clone);
+            Assert.AreEqual(baseline.GetHashCode(), clone.GetHashCode());
+
+            AttributeModification differentAttribute = baseline;
+            differentAttribute.attribute = "armor";
+            Assert.IsFalse(baseline == differentAttribute);
+            Assert.IsTrue(baseline != differentAttribute);
+
+            AttributeModification differentAction = baseline;
+            differentAction.action = ModificationAction.Addition;
+            Assert.IsFalse(baseline.Equals(differentAction));
+
+            AttributeModification differentValue = baseline;
+            differentValue.value = 2f;
+            Assert.IsFalse(baseline.Equals(differentValue));
+        }
+
+        [Test]
+        public void ToStringSerializesAllFields()
+        {
+            AttributeModification modification = new()
+            {
+                attribute = "health",
+                action = ModificationAction.Override,
+                value = 42.5f,
+            };
+
+            using JsonDocument document = JsonDocument.Parse(modification.ToString());
+            JsonElement root = document.RootElement;
+            Assert.AreEqual(
+                "health",
+                root.GetProperty(nameof(AttributeModification.attribute)).GetString()
+            );
+            Assert.AreEqual(
+                "Override",
+                root.GetProperty(nameof(AttributeModification.action)).GetString()
+            );
+            Assert.AreEqual(
+                42.5f,
+                root.GetProperty(nameof(AttributeModification.value)).GetSingle()
+            );
+        }
+
+        [Test]
+        public void SystemTextJsonRoundtripPreservesFields()
+        {
+            AttributeModification modification = new(
+                "armor",
+                ModificationAction.Multiplication,
+                1.25f
+            );
+            string json = Serializer.JsonStringify(modification);
+            AttributeModification clone = Serializer.JsonDeserialize<AttributeModification>(json);
+
+            Assert.AreEqual(modification, clone);
+        }
+
+        [Test]
+        public void ProtoBufRoundtripPreservesFields()
+        {
+            AttributeModification modification = new("speed", ModificationAction.Addition, -3f);
+            byte[] payload = Serializer.ProtoSerialize(modification);
+            AttributeModification clone = Serializer.ProtoDeserialize<AttributeModification>(
+                payload
+            );
+            Assert.AreEqual(modification, clone);
+        }
+
+        [Test]
+        public void CompareToOrdersBasedOnAction()
+        {
+            AttributeModification addition = new("health", ModificationAction.Addition, 10f);
+            AttributeModification multiplication = new(
+                "health",
+                ModificationAction.Multiplication,
+                2f
+            );
+            AttributeModification overrideValue = new("health", ModificationAction.Override, 0f);
+
+            AttributeModification[] unsorted = { overrideValue, multiplication, addition };
+
+            Array.Sort(unsorted);
+
+            Assert.AreEqual(addition, unsorted[0], "Addition should be applied first when sorted.");
+            Assert.AreEqual(
+                multiplication,
+                unsorted[1],
+                "Multiplication should appear after additions when sorted."
+            );
+            Assert.AreEqual(
+                overrideValue,
+                unsorted[2],
+                "Override should be processed last when sorted."
+            );
+        }
+
+        [Test]
+        public void CompareToObjectReturnsMinusOneForNonAttributeModification()
+        {
+            AttributeModification addition = new("health", ModificationAction.Addition, 5f);
+            Assert.AreEqual(-1, addition.CompareTo("not a modification"));
+        }
+    }
+}

package/Tests/Runtime/Tags/AttributeTests.cs

@@ -0,0 +1,192 @@
+namespace WallstopStudios.UnityHelpers.Tests.Tags
+{
+    using System;
+    using NUnit.Framework;
+    using UnityEngine;
+    using WallstopStudios.UnityHelpers.Tags;
+    using Attribute = WallstopStudios.UnityHelpers.Tags.Attribute;
+
+    [TestFixture]
+    public sealed class AttributeTests : AttributeTagsTestBase
+    {
+        [SetUp]
+        public void SetUp()
+        {
+            ResetEffectHandleId();
+        }
+
+        [Test]
+        public void CurrentValueReflectsBaseValueWhenUnmodified()
+        {
+            Attribute attribute = new(12f);
+            Assert.AreEqual(12f, attribute.CurrentValue);
+            Assert.AreEqual(12f, attribute.BaseValue);
+        }
+
+        [Test]
+        public void ApplyAttributeModificationWithoutHandleMutatesBase()
+        {
+            Attribute attribute = new(10f);
+            AttributeModification modification = new()
+            {
+                attribute = "health",
+                action = ModificationAction.Addition,
+                value = 5f,
+            };
+
+            attribute.ApplyAttributeModification(modification);
+            Assert.AreEqual(15f, attribute.BaseValue);
+            Assert.AreEqual(15f, attribute.CurrentValue);
+        }
+
+        [Test]
+        public void ApplyAndRemoveAttributeModificationWithHandleRecalculates()
+        {
+            Attribute attribute = new(100f);
+            AttributeModification addition = new()
+            {
+                attribute = "health",
+                action = ModificationAction.Addition,
+                value = 25f,
+            };
+
+            AttributeEffect effect = Track(ScriptableObject.CreateInstance<AttributeEffect>());
+            effect.name = "Buff";
+            EffectHandle handle = EffectHandle.CreateInstance(effect);
+
+            attribute.ApplyAttributeModification(addition, handle);
+            Assert.AreEqual(125f, attribute.CurrentValue);
+            Assert.AreEqual(100f, attribute.BaseValue);
+
+            bool removed = attribute.RemoveAttributeModification(handle);
+            Assert.IsTrue(removed);
+            Assert.AreEqual(100f, attribute.CurrentValue);
+        }
+
+        [Test]
+        public void ApplyAttributeModificationWithMultiplicationExecutesInOrder()
+        {
+            Attribute attribute = new(10f);
+            AttributeEffect effect = Track(ScriptableObject.CreateInstance<AttributeEffect>());
+            effect.name = "Stacking";
+            EffectHandle handle = EffectHandle.CreateInstance(effect);
+
+            attribute.ApplyAttributeModification(
+                new AttributeModification
+                {
+                    attribute = "health",
+                    action = ModificationAction.Addition,
+                    value = 5f,
+                },
+                handle
+            );
+            attribute.ApplyAttributeModification(
+                new AttributeModification
+                {
+                    attribute = "health",
+                    action = ModificationAction.Multiplication,
+                    value = 2f,
+                },
+                handle
+            );
+
+            Assert.AreEqual(30f, attribute.CurrentValue);
+        }
+
+        [Test]
+        public void AttributeEqualsSupportsFloatComparisons()
+        {
+            Attribute attribute = new(7.25f);
+            Assert.IsTrue(attribute.Equals(7.25f));
+            Assert.IsTrue(attribute.Equals((double)7.25f));
+            Assert.IsFalse(attribute.Equals(7.5f));
+            Assert.AreEqual("7.25", attribute.ToString());
+        }
+
+        [Test]
+        public void ClearCacheForcesRecalculation()
+        {
+            Attribute attribute = new(10f);
+            AttributeModification addition = new()
+            {
+                attribute = "health",
+                action = ModificationAction.Addition,
+                value = 5f,
+            };
+
+            attribute.ApplyAttributeModification(addition);
+            Assert.AreEqual(15f, attribute.CurrentValue);
+
+            attribute.ClearCache();
+            Assert.AreEqual(15f, attribute.CurrentValue);
+        }
+
+        [Test]
+        public void AddProducesHandleAndAppliesAddition()
+        {
+            Attribute attribute = new(10f);
+
+            EffectHandle handle = attribute.Add(5f);
+            Assert.AreEqual(15f, attribute.CurrentValue);
+            Assert.AreEqual(1L, handle.id);
+
+            bool removed = attribute.RemoveAttributeModification(handle);
+            Assert.IsTrue(removed);
+            Assert.AreEqual(10f, attribute.CurrentValue);
+        }
+
+        [Test]
+        public void SubtractStacksAsNegativeAddition()
+        {
+            Attribute attribute = new(20f);
+
+            EffectHandle addition = attribute.Add(5f);
+            EffectHandle subtraction = attribute.Subtract(8f);
+            EffectHandle multiplier = attribute.Multiply(2f);
+
+            Assert.AreEqual(34f, attribute.CurrentValue);
+
+            bool subtractionRemoved = attribute.RemoveAttributeModification(subtraction);
+            Assert.IsTrue(subtractionRemoved);
+            Assert.AreEqual(50f, attribute.CurrentValue);
+
+            attribute.RemoveAttributeModification(addition);
+            attribute.RemoveAttributeModification(multiplier);
+        }
+
+        [Test]
+        public void DivideAppliesReciprocalMultiplication()
+        {
+            Attribute attribute = new(12f);
+
+            EffectHandle addition = attribute.Add(6f);
+            EffectHandle division = attribute.Divide(3f);
+
+            Assert.AreEqual(6f, attribute.CurrentValue);
+
+            bool divisionRemoved = attribute.RemoveAttributeModification(division);
+            Assert.IsTrue(divisionRemoved);
+            Assert.AreEqual(18f, attribute.CurrentValue);
+
+            attribute.RemoveAttributeModification(addition);
+        }
+
+        [Test]
+        public void DivideThrowsWhenValueIsZero()
+        {
+            Attribute attribute = new(10f);
+            Assert.Throws<ArgumentException>(() => attribute.Divide(0f));
+        }
+
+        [Test]
+        public void ArithmeticHelpersThrowWhenValueIsNotFinite()
+        {
+            Attribute attribute = new(5f);
+
+            Assert.Throws<ArgumentException>(() => attribute.Add(float.NaN));
+            Assert.Throws<ArgumentException>(() => attribute.Subtract(float.PositiveInfinity));
+            Assert.Throws<ArgumentException>(() => attribute.Multiply(float.NegativeInfinity));
+            Assert.Throws<ArgumentException>(() => attribute.Divide(float.PositiveInfinity));
+        }
+    }
+}

package/Tests/Runtime/Tags/AttributeTests.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 6cef49ba760748098e3c1fc18a7b1142
+timeCreated: 1761249381