com.wallstop-studios.unity-helpers 2.0.3 → 2.1.0

package/Tests/Runtime/Tags/Helpers/RecordingEffectBehavior.cs

@@ -0,0 +1,89 @@
+namespace WallstopStudios.UnityHelpers.Tests.Tags.Helpers
+{
+    using System.Collections.Generic;
+    using WallstopStudios.UnityHelpers.Tags;
+
+    public sealed class RecordingEffectBehavior : EffectBehavior
+    {
+        private static readonly HashSet<int> InstanceIds = new();
+
+        public static List<EffectBehaviorContext> ApplyContexts { get; } = new();
+
+        public static List<EffectBehaviorContext> TickContexts { get; } = new();
+
+        public static List<PeriodicInvocation> PeriodicInvocations { get; } = new();
+
+        public static List<EffectBehaviorContext> RemoveContexts { get; } = new();
+
+        public static int ApplyCount { get; private set; }
+
+        public static int TickCount { get; private set; }
+
+        public static int PeriodicTickCount { get; private set; }
+
+        public static int RemoveCount { get; private set; }
+
+        public static int InstanceCount => InstanceIds.Count;
+
+        public static void Reset()
+        {
+            ApplyCount = 0;
+            TickCount = 0;
+            PeriodicTickCount = 0;
+            RemoveCount = 0;
+            InstanceIds.Clear();
+            ApplyContexts.Clear();
+            TickContexts.Clear();
+            PeriodicInvocations.Clear();
+            RemoveContexts.Clear();
+        }
+
+        private void OnEnable()
+        {
+            _ = InstanceIds.Add(GetInstanceID());
+        }
+
+        public override void OnApply(EffectBehaviorContext context)
+        {
+            ++ApplyCount;
+            ApplyContexts.Add(context);
+        }
+
+        public override void OnTick(EffectBehaviorContext context)
+        {
+            ++TickCount;
+            TickContexts.Add(context);
+        }
+
+        public override void OnPeriodicTick(
+            EffectBehaviorContext context,
+            PeriodicEffectTickContext tickContext
+        )
+        {
+            ++PeriodicTickCount;
+            PeriodicInvocations.Add(new PeriodicInvocation(context, tickContext));
+        }
+
+        public override void OnRemove(EffectBehaviorContext context)
+        {
+            ++RemoveCount;
+            RemoveContexts.Add(context);
+        }
+
+        public readonly struct PeriodicInvocation
+        {
+            public PeriodicInvocation(
+                EffectBehaviorContext context,
+                PeriodicEffectTickContext tickContext
+            )
+            {
+                Context = context;
+                TickContext = tickContext;
+            }
+
+            public EffectBehaviorContext Context { get; }
+
+            public PeriodicEffectTickContext TickContext { get; }
+        }
+    }
+}

package/Tests/Runtime/Tags/Helpers/RecordingEffectBehavior.cs.meta

@@ -0,0 +1,4 @@
+fileFormatVersion: 2
+guid: a6f0b0f43f73471ebadf08c3cfd5d72b
+timeCreated: 1759598400
+

package/Tests/Runtime/Tags/PeriodicEffectDefinitionSerializationTests.cs

@@ -0,0 +1,92 @@
+namespace WallstopStudios.UnityHelpers.Tests.Tags
+{
+    using System.Collections.Generic;
+    using NUnit.Framework;
+    using WallstopStudios.UnityHelpers.Tags;
+    using Serializer = WallstopStudios.UnityHelpers.Core.Serialization.Serializer;
+
+    [TestFixture]
+    public sealed class PeriodicEffectDefinitionSerializationTests
+    {
+        [Test]
+        public void JsonRoundtripPreservesFieldValues()
+        {
+            PeriodicEffectDefinition definition = CreateDefinition();
+
+            string json = Serializer.JsonStringify(definition);
+            PeriodicEffectDefinition deserialized =
+                Serializer.JsonDeserialize<PeriodicEffectDefinition>(json);
+
+            AssertEquivalent(definition, deserialized);
+        }
+
+        [Test]
+        public void ProtoRoundtripPreservesFieldValues()
+        {
+            PeriodicEffectDefinition definition = CreateDefinition();
+
+            byte[] serialized = Serializer.ProtoSerialize(definition);
+            Assert.IsNotNull(serialized);
+            Assert.Greater(serialized.Length, 0);
+
+            PeriodicEffectDefinition deserialized =
+                Serializer.ProtoDeserialize<PeriodicEffectDefinition>(serialized);
+
+            AssertEquivalent(definition, deserialized);
+        }
+
+        private static PeriodicEffectDefinition CreateDefinition()
+        {
+            PeriodicEffectDefinition definition = new()
+            {
+                name = "Damage Pulse",
+                initialDelay = 0.35f,
+                interval = 0.8f,
+                maxTicks = 6,
+                modifications = new List<AttributeModification>
+                {
+                    new AttributeModification
+                    {
+                        attribute = "health",
+                        action = ModificationAction.Addition,
+                        value = -7.5f,
+                    },
+                    new AttributeModification
+                    {
+                        attribute = "armor",
+                        action = ModificationAction.Multiplication,
+                        value = 0.85f,
+                    },
+                },
+            };
+
+            return definition;
+        }
+
+        private static void AssertEquivalent(
+            PeriodicEffectDefinition expected,
+            PeriodicEffectDefinition actual
+        )
+        {
+            Assert.IsNotNull(actual);
+            Assert.AreNotSame(expected, actual);
+            Assert.AreEqual(expected.name, actual.name);
+            Assert.AreEqual(expected.initialDelay, actual.initialDelay);
+            Assert.AreEqual(expected.interval, actual.interval);
+            Assert.AreEqual(expected.maxTicks, actual.maxTicks);
+
+            Assert.IsNotNull(actual.modifications);
+            Assert.AreNotSame(expected.modifications, actual.modifications);
+            Assert.AreEqual(expected.modifications.Count, actual.modifications.Count);
+
+            for (int i = 0; i < expected.modifications.Count; ++i)
+            {
+                AttributeModification expectedModification = expected.modifications[i];
+                AttributeModification actualModification = actual.modifications[i];
+                Assert.AreEqual(expectedModification.attribute, actualModification.attribute);
+                Assert.AreEqual(expectedModification.action, actualModification.action);
+                Assert.AreEqual(expectedModification.value, actualModification.value);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 1941617e59df425a8e8f76c34af56789
+timeCreated: 1761255628

package/Tests/Runtime/Tags/TagHandlerTests.cs

@@ -33,18 +33,19 @@ namespace WallstopStudios.UnityHelpers.Tests.Tags
 
             handler.ApplyTag("Buff");
             handler.ApplyTag("Buff");
-            handler.RemoveTag("Buff", allInstances: false);
-            handler.RemoveTag("Buff", allInstances: false);
+            handler.ApplyTag("Buff");
+            handler.RemoveTag("Buff");
 
             Assert.AreEqual(new[] { "Buff" }, added);
+            Assert.AreEqual(2, changed.Count);
             Assert.AreEqual(("Buff", 2U), changed[0]);
-            Assert.AreEqual(("Buff", 1U), changed[1]);
+            Assert.AreEqual(("Buff", 3U), changed[1]);
             Assert.AreEqual(new[] { "Buff" }, removed);
             yield return null;
         }
 
         [UnityTest]
-        public IEnumerator RemoveTagAllInstancesClearsWithoutEvents()
+        public IEnumerator RemoveTagAllInstancesClearsWithEvents()
         {
             GameObject entity = CreateTrackedGameObject("Tags", typeof(TagHandler));
             TagHandler handler = entity.GetComponent<TagHandler>();
@@ -53,10 +54,10 @@ namespace WallstopStudios.UnityHelpers.Tests.Tags
             handler.OnTagRemoved += _ => ++removedCount;
 
             handler.ApplyTag("Buff");
-            handler.RemoveTag("Buff", allInstances: true);
+            handler.RemoveTag("Buff");
 
             Assert.IsFalse(handler.HasTag("Buff"));
-            Assert.AreEqual(0, removedCount);
+            Assert.AreEqual(1, removedCount);
             yield return null;
         }
 
@@ -104,5 +105,128 @@ namespace WallstopStudios.UnityHelpers.Tests.Tags
             Assert.IsFalse(handler.ForceRemoveTags(handle));
             yield return null;
         }
+
+        [UnityTest]
+        public IEnumerator HasAllTagsAndHasNoneTagSupport()
+        {
+            GameObject entity = CreateTrackedGameObject("Tags", typeof(TagHandler));
+            TagHandler handler = entity.GetComponent<TagHandler>();
+
+            handler.ApplyTag("Buff");
+            handler.ApplyTag("Shield");
+
+            Assert.IsTrue(handler.HasAllTags(new[] { "Buff" }));
+            List<string> required = new() { "Buff", "Shield" };
+            Assert.IsTrue(handler.HasAllTags(required));
+            Assert.IsFalse(handler.HasAllTags(new[] { "Buff", "Missing" }));
+
+            List<string> none = new() { "Missing", "Other" };
+            Assert.IsTrue(handler.HasNoneOfTags(none));
+            none[1] = "Buff";
+            Assert.IsFalse(handler.HasNoneOfTags(none));
+            yield return null;
+        }
+
+        [UnityTest]
+        public IEnumerator TryGetTagCountAndActiveTagsPopulateBuffer()
+        {
+            GameObject entity = CreateTrackedGameObject("Tags", typeof(TagHandler));
+            TagHandler handler = entity.GetComponent<TagHandler>();
+
+            handler.ApplyTag("Buff");
+            handler.ApplyTag("Buff");
+            handler.ApplyTag("Shield");
+
+            Assert.IsTrue(handler.TryGetTagCount("Buff", out int buffCount));
+            Assert.AreEqual(2, buffCount);
+            Assert.IsFalse(handler.TryGetTagCount("Missing", out int missingCount));
+            Assert.AreEqual(0, missingCount);
+
+            List<string> active = new();
+            handler.GetActiveTags(active);
+            CollectionAssert.AreEquivalent(new[] { "Buff", "Shield" }, active);
+            yield return null;
+        }
+
+        [UnityTest]
+        public IEnumerator GetHandlesWithTagTracksHandleLifecycle()
+        {
+            GameObject entity = CreateTrackedGameObject("Entity", typeof(TestAttributesComponent));
+            TagHandler handler = entity.GetComponent<TagHandler>();
+            EffectHandler effectHandler = entity.GetComponent<EffectHandler>();
+
+            AttributeEffect effect = CreateEffect(
+                "Buff",
+                e =>
+                {
+                    e.effectTags.Add("Buff");
+                }
+            );
+            EffectHandle handle = effectHandler.ApplyEffect(effect).Value;
+
+            List<EffectHandle> handles = new();
+            Assert.AreNotEqual(0, handler.GetHandlesWithTag("Buff", handles).Count);
+            Assert.AreEqual(1, handles.Count);
+            Assert.AreEqual(handle, handles[0]);
+
+            handles.Clear();
+            handler.RemoveTag("Buff");
+            Assert.AreEqual(0, handler.GetHandlesWithTag("Buff", handles).Count);
+
+            handles.Clear();
+            effectHandler.RemoveEffect(handle);
+            Assert.AreEqual(0, handler.GetHandlesWithTag("Buff", handles).Count);
+            yield return null;
+        }
+
+        [UnityTest]
+        public IEnumerator GetActiveTagsReturnsNewBufferWhenNeeded()
+        {
+            GameObject entity = CreateTrackedGameObject("Tags", typeof(TagHandler));
+            TagHandler handler = entity.GetComponent<TagHandler>();
+
+            handler.ApplyTag("Buff");
+            handler.ApplyTag("Shield");
+
+            List<string> firstCall = handler.GetActiveTags();
+            Assert.IsNotNull(firstCall);
+            CollectionAssert.AreEquivalent(new[] { "Buff", "Shield" }, firstCall);
+
+            List<string> reusable = new() { "Sentinel" };
+            List<string> secondCall = handler.GetActiveTags(reusable);
+            Assert.AreSame(reusable, secondCall);
+            CollectionAssert.AreEquivalent(new[] { "Buff", "Shield" }, secondCall);
+            Assert.IsFalse(secondCall.Contains("Sentinel"));
+            yield return null;
+        }
+
+        [UnityTest]
+        public IEnumerator RemoveTagReturnsContributingHandles()
+        {
+            GameObject entity = CreateTrackedGameObject("Entity", typeof(TestAttributesComponent));
+            yield return null;
+            TagHandler handler = entity.GetComponent<TagHandler>();
+            EffectHandler effectHandler = entity.GetComponent<EffectHandler>();
+
+            AttributeEffect effect = CreateEffect(
+                "Buff",
+                e =>
+                {
+                    e.effectTags.Add("Buff");
+                }
+            );
+            EffectHandle handle = effectHandler.ApplyEffect(effect).Value;
+
+            List<EffectHandle> removed = handler.RemoveTag("Buff");
+            Assert.AreEqual(1, removed.Count);
+            Assert.AreEqual(handle, removed[0]);
+            Assert.IsFalse(handler.HasTag("Buff"));
+            Assert.AreEqual(0, handler.GetHandlesWithTag("Buff").Count);
+
+            List<EffectHandle> empty = handler.RemoveTag("Missing");
+            Assert.IsNotNull(empty);
+            Assert.AreEqual(0, empty.Count);
+            yield return null;
+        }
     }
 }

package/package.json

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

package/scripts/lint-doc-links.ps1

@@ -3,6 +3,7 @@ Param(
 )
 
 $ErrorActionPreference = 'Stop'
+$repoRoot = (Resolve-Path -LiteralPath '.').Path
 
 function Write-Violation {
     param(
@@ -19,11 +20,110 @@ function Write-Violation {
     }
 }
 
+$schemePattern = [regex]'^[a-zA-Z][a-zA-Z0-9+\.-]*:'
+
+function Get-MarkdownLinkTarget {
+    param([string]$RawTarget)
+
+    if ([string]::IsNullOrWhiteSpace($RawTarget)) {
+        return $null
+    }
+
+    $trimmed = $RawTarget.Trim()
+
+    if ($trimmed.StartsWith('<') -and $trimmed.Contains('>')) {
+        $closingIndex = $trimmed.IndexOf('>')
+        if ($closingIndex -gt 1) {
+            $trimmed = $trimmed.Substring(1, $closingIndex - 1)
+        }
+    }
+
+    $spaceIndex = $trimmed.IndexOfAny(@(' ', "`t"))
+    if ($spaceIndex -ge 0) {
+        $trimmed = $trimmed.Substring(0, $spaceIndex)
+    }
+
+    if ([string]::IsNullOrWhiteSpace($trimmed)) {
+        return $null
+    }
+
+    return $trimmed
+}
+
+function Is-LocalImageTarget {
+    param([string]$Target)
+
+    if ([string]::IsNullOrWhiteSpace($Target)) {
+        return $false
+    }
+
+    $trimmed = $Target.Trim()
+    if ($schemePattern.IsMatch($trimmed)) {
+        return $false
+    }
+
+    if ($trimmed.StartsWith('#') -or $trimmed.StartsWith('//')) {
+        return $false
+    }
+
+    return $true
+}
+
+function Resolve-ImagePath {
+    param(
+        [string]$SourceFile,
+        [string]$Target,
+        [string]$RepoRoot
+    )
+
+    if ([string]::IsNullOrWhiteSpace($Target)) {
+        return $null
+    }
+
+    $normalized = $Target.Trim() -replace '\\', '/'
+    $cutIndex = $normalized.IndexOfAny(@('#', '?'))
+    if ($cutIndex -ge 0) {
+        $normalized = $normalized.Substring(0, $cutIndex)
+    }
+
+    while ($normalized.StartsWith('./')) {
+        $normalized = $normalized.Substring(2)
+    }
+
+    $normalized = $normalized.Trim()
+    if ([string]::IsNullOrWhiteSpace($normalized)) {
+        return $null
+    }
+
+    $separator = [System.IO.Path]::DirectorySeparatorChar
+    $normalized = $normalized.Replace('/', $separator).Replace('\', $separator)
+
+    $sourceDirectory = Split-Path -Path $SourceFile -Parent
+    $candidate = [System.IO.Path]::GetFullPath([System.IO.Path]::Combine($sourceDirectory, $normalized))
+
+    if (Test-Path -LiteralPath $candidate) {
+        return $candidate
+    }
+
+    if ($normalized.Length -gt 0 -and $normalized[0] -ne '.') {
+        $rootRelative = $normalized.TrimStart($separator)
+        $candidateFromRoot = [System.IO.Path]::GetFullPath([System.IO.Path]::Combine($RepoRoot, $rootRelative))
+        if (Test-Path -LiteralPath $candidateFromRoot) {
+            return $candidateFromRoot
+        }
+    }
+
+    return $null
+}
+
 $mdPattern = [regex]'[A-Za-z0-9._/\-]+\.md(?:#[A-Za-z0-9_\-]+)?'
 $linkPattern = [regex]'\[[^\]]+\]\([^)]+\)'
 $anglePattern = [regex]'<[^>]+>'
 $filenameTextLinkPattern = [regex]'\[(?<text>[^\]]+?\.md(?:#[^\]]+)?)\]\((?<target>[^)]+?\.md(?:#[^)]+)?)\)'
 $inlineCodeMdPattern = [regex]'`[^`\n]*?\.md[^`\n]*?`'
+$imagePattern = [regex]'!\[[^\]]*\]\((?<target>[^)]+)\)'
+$imageReferencePattern = [regex]'!\[[^\]]*\]\[(?<label>[^\]]+)\]'
+$definitionPattern = [regex]'^\s*\[(?<label>[^\]]+)\]:\s*(?<rest>.+)$'
 
 $violationCount = 0
 
@@ -31,44 +131,88 @@ Get-ChildItem -Path . -Recurse -Include *.md -File |
     Where-Object { $_.FullName -notmatch '(?i)[\\/](node_modules)[\\/]' } |
     ForEach-Object {
     $file = $_.FullName
+    $lines = Get-Content -LiteralPath $file
+    $lineCount = $lines.Length
+    $linkDefinitions = New-Object 'System.Collections.Generic.Dictionary[string,string]' ([System.StringComparer]::OrdinalIgnoreCase)
+    $inFence = $false
+
+    for ($index = 0; $index -lt $lineCount; $index++) {
+        $line = $lines[$index]
+        if ($line -match '^\s*```' -or $line -match '^\s*~~~') {
+            $inFence = -not $inFence
+            continue
+        }
+        if ($inFence) { continue }
+
+        $definitionMatch = $definitionPattern.Match($line)
+        if ($definitionMatch.Success) {
+            $label = $definitionMatch.Groups['label'].Value.Trim()
+            $rest = $definitionMatch.Groups['rest'].Value
+            $target = Get-MarkdownLinkTarget $rest
+            if ($label -and $target) {
+                $linkDefinitions[$label] = $target
+            }
+        }
+    }
+
     $inFence = $false
-    $lineNo = 0
-    Get-Content -LiteralPath $file | ForEach-Object {
-        $line = $_
-        $lineNo++
+    for ($index = 0; $index -lt $lineCount; $index++) {
+        $line = $lines[$index]
+        $lineNo = $index + 1
 
-        # Track fenced code blocks (``` or ~~~)
         if ($line -match '^\s*```' -or $line -match '^\s*~~~') {
             $inFence = -not $inFence
+            continue
         }
-        if ($inFence) { return }
+        if ($inFence) { continue }
 
-        # 1) Flag inline code mentions of .md
         if ($inlineCodeMdPattern.IsMatch($line)) {
             $violationCount++
             Write-Violation -File $file -LineNumber $lineNo -Message "Inline code mentions .md; use a human-readable link instead" -Line $line
         }
 
-        # Strip markdown links and angle-bracket autolinks before scanning for bare mentions
         $stripped = $linkPattern.Replace($line, '')
         $stripped = $anglePattern.Replace($stripped, '')
 
-        # 2) Bare .md mention outside links
         if ($mdPattern.IsMatch($stripped)) {
             $violationCount++
             Write-Violation -File $file -LineNumber $lineNo -Message "Bare .md mention; convert to [Readable Text](file.md)" -Line $line
         }
 
-        # 3) Links whose visible text is still a filename
         foreach ($m in $filenameTextLinkPattern.Matches($line)) {
             $text = $m.Groups['text'].Value
             $target = $m.Groups['target'].Value
-            # Ignore if the text already contains spaces (unlikely for filename.md); otherwise flag
             if ($text -match '\.md') {
                 $violationCount++
                 Write-Violation -File $file -LineNumber $lineNo -Message "Link text is a filename; use human-readable text for $target" -Line $line
             }
         }
+
+        foreach ($match in $imagePattern.Matches($line)) {
+            $rawTarget = $match.Groups['target'].Value
+            $resolvedTarget = Get-MarkdownLinkTarget $rawTarget
+            if ($resolvedTarget -and (Is-LocalImageTarget $resolvedTarget)) {
+                $imagePath = Resolve-ImagePath -SourceFile $file -Target $resolvedTarget -RepoRoot $repoRoot
+                if (-not $imagePath) {
+                    $violationCount++
+                    Write-Violation -File $file -LineNumber $lineNo -Message "Image target '$resolvedTarget' does not resolve to a file" -Line $line
+                }
+            }
+        }
+
+        foreach ($match in $imageReferencePattern.Matches($line)) {
+            $label = $match.Groups['label'].Value.Trim()
+            if ($linkDefinitions.ContainsKey($label)) {
+                $resolvedTarget = $linkDefinitions[$label]
+                if ($resolvedTarget -and (Is-LocalImageTarget $resolvedTarget)) {
+                    $imagePath = Resolve-ImagePath -SourceFile $file -Target $resolvedTarget -RepoRoot $repoRoot
+                    if (-not $imagePath) {
+                        $violationCount++
+                        Write-Violation -File $file -LineNumber $lineNo -Message "Image reference '$label' points to '$resolvedTarget' which does not resolve" -Line $line
+                    }
+                }
+            }
+        }
     }
 }
 
@@ -78,3 +222,4 @@ if ($violationCount -gt 0) {
 } else {
     Write-Host "Markdown link lint passed: no issues found." -ForegroundColor Green
 }
+