Release Healer Man 0.1.38

src/game/expandedClassDamageAudit.test.ts

@@ -0,0 +1,225 @@
+import { afterAll, describe, expect, it } from "vitest";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { COA_CLASS_IDS, ROM_CLASS_IDS, PLAYABLE_RACES, classesForRace, type ClassId } from "../app/characterCatalog";
+import { createDungeonParty, usePartyStore, type PartyMember } from "./partyStore";
+import { useCombatStore } from "./combatStore";
+import { clearMobRuntimeRegistry, setMobPosition } from "./mobRuntimeRegistry";
+import { clearPartyRuntimeRegistry, registerPartyRuntimePosition, updatePartyRuntimeTargetVisibility } from "./partyRuntimeRegistry";
+import { advanceDungeonPartyCombat, partyCombatRangeBand, resetPartyRuntimeClock } from "./partyRuntime";
+import { subscribeCombatPresentation } from "./combatPresentation";
+import { subscribeCombatEvents } from "./combatEvents";
+import { abilitiesForClass, resourceProfileForClass } from "./abilityCatalog";
+import { choosePartyAbility } from "./partyAbilityAi";
+
+const auditReport: unknown[] = [];
+
+afterAll(() => {
+  if (process.env.CLASS_DAMAGE_AUDIT_REPORT !== "1") return;
+  const directory = resolve("artifacts/class-damage-audit");
+  mkdirSync(directory, { recursive: true });
+  writeFileSync(resolve(directory, "report.json"), `${JSON.stringify({ durationSeconds: 30, results: auditReport }, null, 2)}\n`);
+});
+
+function initializeAudit(classId: ClassId, level: number, template?: PartyMember): PartyMember {
+  clearMobRuntimeRegistry();
+  clearPartyRuntimeRegistry();
+  resetPartyRuntimeClock();
+  const raceId = PLAYABLE_RACES.find((race) => classesForRace(race.id).some((entry) => entry.id === classId))!.id;
+  useCombatStore.getState().initializeCharacter({ classId, raceId, level });
+  const combat = useCombatStore.getState();
+  const profile = resourceProfileForClass(classId);
+  const base = createDungeonParty("expanded-damage-audit", level)[0];
+  const member: PartyMember = template ?? { ...base, id: `audit-${classId}`, name: classId, classId, raceId, level,
+    role: "damage", specialization: "Primary", specializationId: null, talentTreeId: "", talentRanks: {},
+    health: combat.maxHealth, maxHealth: combat.maxHealth, gearStats: combat.gearStats,
+    resourceType: profile.type, resourceName: combat.resourceName, resource: combat.resource,
+    maxResource: combat.maxResource, resourcePools: combat.resourcePools, runes: combat.deathKnightRunes };
+  usePartyStore.getState().initializeParty("expanded-damage-audit", level, combat.health);
+  usePartyStore.setState({ members: [member] });
+  useCombatStore.getState().synchronizeActors();
+  registerPartyRuntimePosition(member.id, [2 - partyCombatRangeBand(member).preferred, 0, 0]);
+  useCombatStore.getState().registerMob("audit", { name: "Training target", maxHealth: 10_000_000, xpReward: 0 });
+  setMobPosition("audit", [2, 0, 0]);
+  useCombatStore.getState().damageMob("audit", 1, 100);
+  updatePartyRuntimeTargetVisibility(member.id, "audit", true);
+  return member;
+}
+
+describe("expanded class damage audit", () => {
+  for (const control of ["NPC", "player"] as const) {
+    it(`${control} Radiant Flame deals five pulses during the channel without repeating them on completion`, () => {
+      const member = initializeAudit("sun-cleric", 20);
+      const ability = abilitiesForClass(member.classId).find((candidate) => candidate.name === "Radiant Flame")!;
+      const damageEvents: number[] = [];
+      if (control === "NPC") {
+        usePartyStore.setState({ members: [{ ...member, cooldowns: Object.fromEntries(abilitiesForClass(member.classId)
+          .filter((candidate) => candidate.id !== ability.id).map((candidate) => [candidate.id, 60_000])) }] });
+        useCombatStore.getState().commitCompanionActors(usePartyStore.getState().members);
+      } else {
+        usePartyStore.setState({ members: [], selectedMemberId: null, selfSelected: false });
+        useCombatStore.getState().synchronizeActors();
+        useCombatStore.getState().selectMob("audit");
+      }
+      const stop = subscribeCombatEvents((event) => {
+        if (event.kind === "damage" && event.targetActorId === "audit" && event.abilityId === ability.id) damageEvents.push(event.effectiveAmount);
+      });
+      const advance = (now: number) => {
+        useCombatStore.getState().tick(0.1, now);
+        if (control === "NPC") advanceDungeonPartyCombat(now);
+      };
+      if (control === "player") expect(useCombatStore.getState().castAbility(ability.id, undefined, 1_000).ok).toBe(true);
+      advance(1_000);
+      advance(1_700);
+      expect(damageEvents).toHaveLength(0);
+      advance(1_800);
+      expect(damageEvents).toHaveLength(1);
+      expect(damageEvents[0]).toBeGreaterThan(0);
+      for (const now of [2_600, 3_400, 4_200, 5_000]) advance(now);
+      expect(damageEvents).toHaveLength(5);
+      usePartyStore.getState().setCommand("stop");
+      advance(5_100);
+      advance(6_000);
+      expect(damageEvents).toHaveLength(5);
+      stop();
+    });
+  }
+
+  for (const [mode, classes, levels] of [["CoA", COA_CLASS_IDS, [1, 2, 4, 9, 20, 80]], ["RoM", ROM_CLASS_IDS, [1, 20, 70]]] as const) {
+    for (const level of levels) {
+      it(`${mode} NPCs execute damaging abilities at level ${level}`, () => {
+        const report: unknown[] = [];
+        const failures: string[] = [];
+        for (const classId of classes) {
+          const member = initializeAudit(classId, level);
+          const releases = new Set<string>();
+          let damage = 0;
+          let abilityDamage = 0;
+          const stopEvents = subscribeCombatEvents((event) => {
+            const actor = useCombatStore.getState().actors[event.sourceActorId];
+            if (event.kind === "damage" && event.targetActorId === "audit"
+              && (event.sourceActorId === member.id || actor?.ownerId === member.id)) {
+              damage += event.effectiveAmount;
+              if (event.abilityId !== "party-auto-attack") abilityDamage += event.effectiveAmount;
+            }
+          });
+          const stopPresentation = subscribeCombatPresentation((message) => {
+            if (message.kind === "event" && message.event.sourceActorId === member.id && message.event.phase === "release") releases.add(message.event.name);
+          });
+          for (let now = 1_000; now <= 31_000; now += 100) {
+            useCombatStore.getState().tick(0.1, now);
+            advanceDungeonPartyCombat(now);
+          }
+          stopEvents();
+          stopPresentation();
+          expect(useCombatStore.getState().mobs.audit.dead, `${classId} level ${level} must sustain the full audit`).toBe(false);
+          report.push({ classId, damage, abilityDamage, releases: [...releases], resource: usePartyStore.getState().members[0].resource });
+          auditReport.push({ mode, control: "NPC", classId, level, damage, abilityDamage, abilities: [...releases] });
+          const hasDamageAbility = abilitiesForClass(classId).some((ability) => !ability.passive
+            && ability.talentEntryId === undefined && ability.unlockLevel <= level
+            && ability.effects.some((effect) => ["damage", "dot", "finisher-damage", "execute", "summon"].includes(effect.kind)));
+          if (damage <= 1 || (hasDamageAbility && abilityDamage <= 0)) failures.push(classId);
+        }
+        expect(failures, JSON.stringify(report)).toEqual([]);
+      });
+    }
+    for (const level of levels) {
+      it(`${mode} players execute damaging abilities at level ${level}`, () => {
+        const failures: unknown[] = [];
+        for (const classId of classes) {
+          const member = initializeAudit(classId, level);
+          usePartyStore.setState({ members: [], selectedMemberId: null, selfSelected: false });
+          useCombatStore.getState().synchronizeActors();
+          useCombatStore.getState().setPlayerPosition([0, 0, 0]);
+          setMobPosition("audit", [partyCombatRangeBand(member).preferred, 0, 0]);
+          useCombatStore.getState().selectMob("audit");
+          const abilities = abilitiesForClass(classId);
+          const harmful = (ability: (typeof abilities)[number]) => !ability.passive && ability.talentEntryId === undefined
+            && ability.effects.some((effect) => ["damage", "dot", "finisher-damage", "execute", "summon"].includes(effect.kind));
+          const firstAttack = abilities.filter(harmful).sort((left, right) => left.unlockLevel - right.unlockLevel)[0];
+          let damage = 0;
+          let abilityDamage = 0;
+          const casts = new Set<string>();
+          const reasons = new Set<string>();
+          const stop = subscribeCombatEvents((event) => {
+            if (event.kind === "damage" && event.targetActorId === "audit") {
+              damage += event.effectiveAmount;
+              if (event.abilityId && !event.abilityId.includes("auto-attack")) abilityDamage += event.effectiveAmount;
+            }
+          });
+          const kickoff = firstAttack ? useCombatStore.getState().castAbility(firstAttack.id, undefined, 1_000) : null;
+          if (kickoff?.ok && firstAttack) casts.add(firstAttack.name);
+          for (let now = 1_000; now <= 31_000; now += 100) {
+            useCombatStore.getState().tick(0.1, now);
+            const combat = useCombatStore.getState();
+            if (combat.activeCast) continue;
+            const rejected = new Set<string>();
+            const playerMember: PartyMember = { ...member, resource: combat.resource, resourcePools: combat.resourcePools,
+              cooldowns: combat.cooldowns, globalCooldownEndsAt: combat.globalCooldownEndsAt, runes: combat.deathKnightRunes };
+            for (let attempts = 0; attempts < abilities.length; attempts += 1) {
+              const ability = choosePartyAbility(playerMember, { now, target: combat.mobs.audit,
+                canUseAbility: (candidate) => harmful(candidate) && !rejected.has(candidate.id)
+                  && !combat.effects.some((effect) => effect.sourceAbilityId === candidate.id && effect.remainingTicks > 0)
+                  && !candidate.effects.some((effect) => effect.kind === "apply-aura"
+                    && combat.auras.some((aura) => aura.definition.id === effect.aura.id && aura.targetId === "audit")) });
+              if (!ability) break;
+              const result = useCombatStore.getState().castAbility(ability.id, undefined, now);
+              if (result.ok) { casts.add(ability.name); break; }
+              rejected.add(ability.id);
+              if (result.reason) reasons.add(result.reason);
+            }
+          }
+          stop();
+          expect(useCombatStore.getState().mobs.audit.dead, `${classId} level ${level} must sustain the full audit`).toBe(false);
+          const hasAttack = abilities.some((ability) => harmful(ability) && ability.unlockLevel <= level);
+          auditReport.push({ mode, control: "player", classId, level, damage, abilityDamage, abilities: [...casts],
+            firstOffensiveAbilityLevel: firstAttack?.unlockLevel ?? null, failureReasons: [...reasons] });
+          if (hasAttack && abilityDamage <= 0) failures.push({ classId, damage, abilityDamage, casts: [...casts], reasons: [...reasons], kickoff,
+            firstAttack: firstAttack?.name, autoAttackTargetId: useCombatStore.getState().autoAttackTargetId });
+        }
+        expect(failures).toEqual([]);
+      });
+    }
+  }
+
+  for (const level of [1, 20, 70]) {
+    it(`actual RoM companion templates deal ability damage at level ${level}`, () => {
+      const templates = new Map<string, PartyMember>();
+      for (let seed = 0; seed < 100; seed += 1) {
+        for (const role of ["healer", "damage"] as const) {
+          for (const member of createDungeonParty(`rom-audit-${seed}`, level, role, 5, "rom")) {
+            templates.set(`${member.classId}:${member.role}`, member);
+          }
+        }
+      }
+      expect(new Set([...templates.values()].map((member) => member.classId))).toEqual(new Set(ROM_CLASS_IDS));
+      for (const template of templates.values()) {
+        const member = initializeAudit(template.classId, level, template);
+        let damage = 0;
+        let abilityDamage = 0;
+        const abilities = new Set<string>();
+        const stop = subscribeCombatEvents((event) => {
+          const actor = useCombatStore.getState().actors[event.sourceActorId];
+          if (event.kind !== "damage" || event.targetActorId !== "audit"
+            || (event.sourceActorId !== member.id && actor?.ownerId !== member.id)) return;
+          damage += event.effectiveAmount;
+          if (event.abilityId !== "party-auto-attack") {
+            abilityDamage += event.effectiveAmount;
+            if (event.abilityId) abilities.add(event.abilityId);
+          }
+        });
+        for (let now = 1_000; now <= 31_000; now += 100) {
+          useCombatStore.getState().tick(0.1, now);
+          advanceDungeonPartyCombat(now);
+        }
+        stop();
+        auditReport.push({ mode: "RoM", control: "shipped NPC", classId: member.classId, role: member.role,
+          level, damage, abilityDamage, abilities: [...abilities] });
+        expect(abilityDamage, `${member.classId} ${member.role} level ${level}`).toBeGreaterThan(0);
+        const finalMember = usePartyStore.getState().members[0];
+        expect(finalMember.resource).toBeGreaterThanOrEqual(0);
+        expect(finalMember.resource).toBeLessThanOrEqual(finalMember.maxResource);
+      }
+    });
+  }
+});