add friendly NPCs to party state

BossMod/Data/Actor.cs

@@ -114,6 +114,7 @@ public sealed class Actor(ulong instanceID, uint oid, int spawnIndex, string nam
     public Angle Rotation => PosRot.W.Radians();
     public bool Omnidirectional => Utils.CharacterIsOmnidirectional(OID);
     public bool IsDeadOrDestroyed => IsDead || IsDestroyed;
+    public bool IsFriendlyNPC => Type == ActorType.Enemy && IsAlly && IsTargetable;
 
     public ActorStatus? FindStatus(uint sid)
     {

BossMod/Data/PartyState.cs

@@ -7,12 +7,16 @@
 // if player does not exist in world, party is always empty; otherwise player is always in slot 0
 // in alliance, two 'other' groups use slots 8-15 and 16-23; alliance members don't have content-ID, but always have actor-ID
 // in trust, buddies are considered party members with content-id 0 (but non-zero actor id, they are always in world)
+// slots 24-63 are occupied by friendly NPCs, i.e. actors with type = Enemy who have the IsAlly and IsTargetable flags set
+// certain modules need to treat NPCs as regular party members for the purpose of mechanic resolution
+// we limit to 64 slots to facilitate a bitmask for the entire "party" state fitting inside one ulong
 // party slot is considered 'empty' if both ids are 0
 public sealed class PartyState
 {
     public const int PlayerSlot = 0;
     public const int MaxPartySize = 8;
     public const int MaxAllianceSize = 24;
+    public const int MaxAllies = 64;
 
     public record struct Member(ulong ContentId, ulong InstanceId, bool InCutscene, string Name)
     {
@@ -21,8 +25,8 @@ public record struct Member(ulong ContentId, ulong InstanceId, bool InCutscene,
     }
     public static readonly Member EmptySlot = new(0, 0, false, "");
 
-    public readonly Member[] Members = Utils.MakeArray(MaxAllianceSize, EmptySlot);
-    private readonly Actor?[] _actors = new Actor?[MaxAllianceSize]; // transient
+    public readonly Member[] Members = Utils.MakeArray(MaxAllies, EmptySlot);
+    private readonly Actor?[] _actors = new Actor?[MaxAllies]; // transient
 
     public Actor? this[int slot] => (slot >= 0 && slot < _actors.Length) ? _actors[slot] : null; // bounds-checking accessor
     public Actor? Player() => this[PlayerSlot];
@@ -56,6 +60,15 @@ public IEnumerable<Actor> WithoutSlot(bool includeDead = false, bool partyOnly =
                 continue;
             yield return player;
         }
+        for (int i = MaxAllianceSize; i < MaxAllies; ++i)
+        {
+            var player = _actors[i];
+            if (player == null)
+                continue;
+            if (player.IsDead && !includeDead)
+                continue;
+            yield return player;
+        }
     }
 
     public IEnumerable<(int, Actor)> WithSlot(bool includeDead = false, bool partyOnly = false)
@@ -69,6 +82,15 @@ public IEnumerable<Actor> WithoutSlot(bool includeDead = false, bool partyOnly =
                 continue;
             yield return (i, player);
         }
+        for (int i = MaxAllianceSize; i < MaxAllies; ++i)
+        {
+            var player = _actors[i];
+            if (player == null)
+                continue;
+            if (player.IsDead && !includeDead)
+                continue;
+            yield return (i, player);
+        }
     }
 
     // find a slot index containing specified player (by instance ID); returns -1 if not found

BossMod/Framework/WorldStateGameSync.cs

@@ -383,6 +383,7 @@ private unsafe void UpdateParty()
         var playerMember = UpdatePartyPlayer(replay, group);
         UpdatePartyNormal(group, playerMember);
         UpdatePartyAlliance(group);
+        UpdatePartyNPCs();
 
         // update limit break
         var lb = LimitBreakController.Instance();
@@ -501,6 +502,33 @@ private unsafe void UpdatePartyAlliance(GroupManager.Group* group)
         }
     }
 
+    private unsafe void UpdatePartyNPCs()
+    {
+        for (int i = PartyState.MaxAllianceSize; i < PartyState.MaxAllies; ++i)
+        {
+            ref var m = ref _ws.Party.Members[i];
+            if (m.InstanceId != 0)
+            {
+                var actor = _ws.Actors.Find(m.InstanceId);
+                if (!(actor?.IsFriendlyNPC ?? false))
+                    UpdatePartySlot(i, PartyState.EmptySlot);
+            }
+        }
+        foreach (var actor in _ws.Actors)
+        {
+            if (!actor.IsFriendlyNPC)
+                continue;
+            if (_ws.Party.FindSlot(actor.InstanceID) == -1)
+            {
+                var slot = FindFreeNPCAllySlot();
+                if (slot > 0)
+                    UpdatePartySlot(slot, new PartyState.Member(0, actor.InstanceID, false, actor.Name));
+                else
+                    Service.Log($"[WorldState] Failed to find empty slot for allied NPC {actor.InstanceID:X}");
+            }
+        }
+    }
+
     private unsafe bool HasBuddy(ulong instanceID)
     {
         var ui = UIState.Instance();
@@ -518,6 +546,14 @@ private int FindFreePartySlot()
         return -1;
     }
 
+    private int FindFreeNPCAllySlot()
+    {
+        for (int i = PartyState.MaxAllianceSize; i < PartyState.MaxAllies; ++i)
+            if (!_ws.Party.Members[i].IsValid())
+                return i;
+        return -1;
+    }
+
     private unsafe PartyState.Member BuildPartyMember(PartyMember* m) => m != null ? new(m->ContentId, m->EntityId, (m->Flags & 0x10) != 0, m->NameString) : PartyState.EmptySlot;
 
     private void AddPartyMember(PartyState.Member m)