Update Healer Man server

src/game/romNativeEncounterPressure.integration.test.ts

@@ -0,0 +1,250 @@
+import { afterAll, describe, expect, it } from "vitest";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { PLAYER_AGGRO_ID } from "./aggro";
+import { useCombatStore } from "./combatStore";
+import { subscribeCombatEvents } from "./combatEvents";
+import { subscribeCombatPresentation } from "./combatPresentation";
+import { useGameStore } from "./store";
+import { usePartyStore, createConfiguredPartyMember } from "./partyStore";
+import { advanceDungeonPartyCombat, resetPartyRuntimeClock } from "./partyRuntime";
+import { clearMobRuntimeRegistry, setMobPosition } from "./mobRuntimeRegistry";
+import { clearPartyRuntimeRegistry, registerPartyRuntimePosition,
+  updatePartyRuntimePosition, updatePartyRuntimeTargetVisibility } from "./partyRuntimeRegistry";
+import { ROM_FIVE_IDENTITIES } from "./romFiveIdentities";
+import { requireDungeonDefinition } from "./dungeonRegistry";
+import { dungeonEnemyScaling } from "./dungeonBossScaling";
+import { BenchmarkController } from "./benchmark/benchmarkController";
+import { BENCHMARK_SCENARIOS } from "./benchmark/benchmarkScenarios";
+import type { EnemyAttackDefinition } from "./enemyAttacks";
+
+const dungeon = requireDungeonDefinition("barren-caves");
+const bossEntity = dungeon.entities["rw-barren-caves-101462"];
+const bossSpawn = dungeon.staticSpawns.find((spawn) => spawn.entityId === bossEntity.id)!;
+const BOSS_ID = bossSpawn.id;
+const priest = ROM_FIVE_IDENTITIES.find((identity) => identity.classId === "rom-priest")!;
+const report: unknown[] = [];
+
+afterAll(() => {
+  if (process.env.ROM_NATIVE_PRESSURE_REPORT !== "1") return;
+  const directory = resolve("artifacts/rom-enemy-followup");
+  mkdirSync(directory, { recursive: true });
+  writeFileSync(resolve(directory, "pressure.json"), `${JSON.stringify({
+    scope: "Explicit native five / Barren Caves Anglo diagnostic, levels 10/30/60/80. Scripted positions, normal HP budgets; no scene navigation or readiness certification.",
+    samples: report,
+  }, null, 2)}\n`);
+});
+
+function setup(level = 30, stacked = false, attacks?: readonly EnemyAttackDefinition[], activeIdentity = priest) {
+  clearMobRuntimeRegistry();
+  clearPartyRuntimeRegistry();
+  resetPartyRuntimeClock();
+  useGameStore.getState().activateDungeon("barren-caves", "normal", { bossDifficulty: 1 });
+  const combat = useCombatStore.getState();
+  combat.initializeCharacter({ ...activeIdentity, level, statRuleset: "rom" });
+  combat.setPlayerPosition([stacked || activeIdentity.role === "tank" ? 2 : 10, 0, 0]);
+  usePartyStore.getState().initializeParty("native-pressure", level, useCombatStore.getState().health, activeIdentity.role, 5, "rom");
+  const members = ROM_FIVE_IDENTITIES.filter((identity) => identity !== activeIdentity).map((identity, index) =>
+    createConfiguredPartyMember({ ...identity, statRuleset: "rom", specialization: "Primary",
+      talentTreeId: "" }, level, index, "native-pressure"));
+  usePartyStore.setState({ members, command: "defend" });
+  combat.synchronizeActors();
+  const scaling = dungeonEnemyScaling(dungeon, bossEntity, BOSS_ID, level, "normal", 1, "rom", "rom");
+  combat.registerMob(BOSS_ID, { name: "Anglo", boss: true, runewakerNpcId: 101462,
+    ...scaling, xpReward: 0, attacks: attacks ?? bossEntity.combat?.attacks });
+  setMobPosition(BOSS_ID, [0, 0, 0]);
+  for (const member of members) {
+    const distance = stacked || member.classId === "rom-knight" || member.classId === "rom-rogue" ? 2
+      : member.classId === "rom-scout" ? 8 : 10;
+    registerPartyRuntimePosition(member.id, [distance, 0, 0]);
+    updatePartyRuntimeTargetVisibility(member.id, BOSS_ID, true);
+  }
+  const tank = members.find((member) => member.role === "tank")
+    ?? { id: PLAYER_AGGRO_ID, maxHealth: useCombatStore.getState().maxHealth };
+  combat.damageMob(BOSS_ID, 1, 1_000, { actorId: tank.id, role: "tank" });
+  combat.selectMob(BOSS_ID);
+  return { tank, members };
+}
+
+function measurePressure(level: number, stacked: boolean, activeHealer: boolean) {
+  const { tank } = setup(level, stacked);
+  const controller = new BenchmarkController();
+  let incoming = 0;
+  let rawIncoming = 0;
+  let absorbed = 0;
+  let effectiveHealing = 0;
+  let overheal = 0;
+  let healerCasts = 0;
+  let invalid = 0;
+  let resourceBlocked = 0;
+  let tankLow = 1;
+  let partyLow = 1;
+  let manaLow = 1;
+  let endAt = 1_000;
+  const outgoingByAbility: Record<string, number> = {};
+  const castsByAbility: Record<string, number> = {};
+  const controls = new Set<string>();
+  const otherDamage: Record<string, number> = {};
+  const invalidDetails: unknown[] = [];
+  const castAbility = useCombatStore.getState().castAbility;
+  useCombatStore.setState({ castAbility: (...args) => {
+    const result = castAbility(...args);
+    if (!result.ok && result.reason) invalidDetails.push({ abilityId: result.abilityId, reason: result.reason,
+      duringCompletion: Boolean(args[3]) });
+    return result;
+  } });
+  const stopCasts = subscribeCombatPresentation((message) => {
+    if (message.kind !== "event" || message.event.sourceActorId !== PLAYER_AGGRO_ID || message.event.phase !== "release") return;
+    const id = `${message.event.abilityId}:${message.event.name}`;
+    castsByAbility[id] = (castsByAbility[id] ?? 0) + 1;
+  });
+  const stop = subscribeCombatEvents((event) => {
+    if (event.sourceActorId === BOSS_ID && event.kind === "damage") {
+      incoming += event.effectiveAmount;
+      rawIncoming += event.rawAmount;
+      absorbed += event.absorbed;
+    }
+    if (event.sourceActorId === PLAYER_AGGRO_ID && event.kind === "healing") {
+      effectiveHealing += event.effectiveAmount;
+      overheal += event.overheal;
+      const id = event.abilityId ?? "unknown";
+      outgoingByAbility[id] = (outgoingByAbility[id] ?? 0) + event.effectiveAmount;
+    }
+    if (event.kind === "damage" && event.sourceActorId !== BOSS_ID && event.targetActorId !== BOSS_ID) {
+      const id = `${event.sourceActorId}:${event.abilityId}`;
+      otherDamage[id] = (otherDamage[id] ?? 0) + event.effectiveAmount;
+    }
+  });
+  try {
+    for (let now = 1_100; now <= 121_000; now += 100) {
+      endAt = now;
+      const combat = useCombatStore.getState();
+      combat.tick(0.1, now);
+      combat.advanceMobCombat(now);
+      advanceDungeonPartyCombat(now);
+      if (activeHealer && !useCombatStore.getState().mobs[BOSS_ID].dead && useCombatStore.getState().health > 0) {
+        const decision = controller.act(now, "healer", { ...BENCHMARK_SCENARIOS[0], hostileTargets: 1 }, false);
+        healerCasts += Number(decision.cast);
+        invalid += decision.invalidFailures;
+        resourceBlocked += Number(decision.resourceBlocked);
+      }
+      const state = useCombatStore.getState();
+      const members = usePartyStore.getState().members;
+      tankLow = Math.min(tankLow, state.actors[tank.id]?.health! / tank.maxHealth);
+      partyLow = Math.min(partyLow, state.health / state.maxHealth,
+        ...members.map((member) => member.health / member.maxHealth));
+      manaLow = Math.min(manaLow, (state.resourcePools.mana ?? 0) / (state.maxResourcePools.mana ?? 1));
+      for (const aura of state.auras) if (aura.sourceId === BOSS_ID && aura.definition.id.startsWith("enemy-control:")) {
+        controls.add(aura.targetId);
+      }
+      if (state.mobs[BOSS_ID].dead || state.health <= 0) break;
+    }
+  } finally { stop(); stopCasts(); useCombatStore.setState({ castAbility }); }
+  const state = useCombatStore.getState();
+  const result = { level, stacked, activeHealer, seconds: (endAt - 1_000) / 1_000,
+    clear: state.mobs[BOSS_ID].dead, damage: incoming, rawIncoming, absorbed, effectiveHealing, overheal,
+    playerMaxHealth: state.maxHealth, tankMaxHealth: state.actors[tank.id].maxHealth,
+    healerCasts, resourceBlocked, invalid, tankLow, partyLow, manaLow,
+    finalMana: state.resourcePools.mana, maxMana: state.maxResourcePools.mana,
+    playerDead: state.health <= 0,
+    deadCompanions: usePartyStore.getState().members.filter((member) => member.health <= 0).map((member) => member.classId),
+    mechanics: state.mobs[BOSS_ID].abilityCastCounts, controlledActors: [...controls], outgoingByAbility, castsByAbility, otherDamage, invalidDetails };
+  report.push(result);
+  return result;
+}
+
+describe("native RoM encounter and healing pressure", () => {
+  it.each(["Trample", "Bash"])("resolves %s against current positions after its warning", (name) => {
+    const attack = bossEntity.combat!.attacks.find((entry) => entry.name === name)!;
+    const { members } = setup(30, true, [{ ...attack, initialCooldownMs: [0, 0] }]);
+    const releases: string[] = [];
+    const stopPresentation = subscribeCombatPresentation((message) => {
+      if (message.kind === "event" && message.event.sourceActorId === BOSS_ID) releases.push(message.event.phase);
+    });
+    useCombatStore.getState().advanceMobCombat(1_100);
+    expect(useCombatStore.getState().mobs[BOSS_ID].activeCast?.name).toBe(name);
+    useCombatStore.getState().setPlayerPosition([8, 0, 0]);
+    const mage = members.find((member) => member.classId === "rom-mage")!;
+    updatePartyRuntimePosition(mage.id, 12, 0, 0);
+    useCombatStore.getState().advanceMobCombat(2_899);
+    expect(useCombatStore.getState().combatEvents.some((event) => event.abilityId === attack.id)).toBe(false);
+    useCombatStore.getState().advanceMobCombat(2_900);
+    stopPresentation();
+    const hits = useCombatStore.getState().combatEvents.filter((event) => event.kind === "damage" && event.abilityId === attack.id);
+    expect(new Set(hits.map((event) => event.targetActorId))).toEqual(new Set(members.filter((member) => member.id !== mage.id).map((member) => member.id)));
+    expect(hits.every((event) => event.school === "physical")).toBe(true);
+    expect(releases).toContain("cast-start");
+    expect(releases).toContain("release");
+  });
+
+  it("lets dispelling Gulp restore the controlled actor before natural expiry", () => {
+    const attack = bossEntity.combat!.attacks.find((entry) => entry.name === "Gulp")!;
+    const { tank } = setup(30, true, [{ ...attack, initialCooldownMs: [0, 0] }]);
+    useCombatStore.getState().advanceMobCombat(1_100);
+    useCombatStore.getState().advanceMobCombat(2_900);
+    expect(useCombatStore.getState().controlMechanic).toBe("stun");
+    expect(useCombatStore.getState().actors[tank.id].controlledUntil).toBeGreaterThan(2_900);
+    expect(useCombatStore.getState().dispelActor(PLAYER_AGGRO_ID, ["magic"], 1, 3_000)).toBe(1);
+    expect(useCombatStore.getState().controlledUntil).toBeLessThanOrEqual(3_000);
+    expect(useCombatStore.getState().dispelActor(tank.id, ["magic"], 1, 3_000)).toBe(1);
+    expect(useCombatStore.getState().actors[tank.id].controlledUntil).toBeLessThanOrEqual(3_000);
+  });
+
+  it("lets a native companion counter an interruptible boss warning", () => {
+    const attack = bossEntity.combat!.attacks.find((entry) => entry.name === "Trample")!;
+    setup(30, true, [{ ...attack, initialCooldownMs: [0, 0] }]);
+    useCombatStore.getState().advanceMobCombat(1_100);
+    expect(useCombatStore.getState().mobs[BOSS_ID].activeCast).not.toBeNull();
+    const counters: string[] = [];
+    const stop = subscribeCombatPresentation((message) => {
+      if (message.kind === "event" && message.event.sourceActorId === BOSS_ID) counters.push(message.event.phase);
+    });
+    for (let now = 1_200; now < 2_900; now += 100) {
+      useCombatStore.getState().tick(0.1, now);
+      advanceDungeonPartyCombat(now);
+    }
+    const boss = useCombatStore.getState().mobs[BOSS_ID];
+    stop();
+    expect(boss.activeCast).toBeNull();
+    expect(counters).toContain("cast-cancel");
+    expect(useCombatStore.getState().combatEvents.some((event) => event.kind === "damage" && event.abilityId === attack.id)).toBe(false);
+  });
+
+  it("lets a ranged native Priest companion dispel Gulp from the player tank", () => {
+    const attack = bossEntity.combat!.attacks.find((entry) => entry.name === "Gulp")!;
+    const knight = ROM_FIVE_IDENTITIES.find((identity) => identity.classId === "rom-knight")!;
+    const { members } = setup(30, false, [{ ...attack, initialCooldownMs: [0, 0] }], knight);
+    const healer = members.find((member) => member.classId === "rom-priest")!;
+    useCombatStore.getState().advanceMobCombat(1_100);
+    useCombatStore.getState().advanceMobCombat(2_900);
+    expect(useCombatStore.getState().controlledUntil).toBe(5_900);
+    expect(useCombatStore.getState().actors[healer.id].controlledUntil).toBeLessThan(2_900);
+    for (let now = 3_000; now < 5_900 && useCombatStore.getState().controlledUntil > now; now += 100) {
+      useCombatStore.getState().tick(0.1, now);
+      advanceDungeonPartyCombat(now);
+    }
+    expect(useCombatStore.getState().controlledUntil).toBe(0);
+    expect(useCombatStore.getState().controlMechanic).toBeNull();
+  });
+
+  it("records active-healer and idle-healer pressure in the explicit native cohort", () => {
+    for (const level of [10, 30, 60, 80]) for (const stacked of [false, true]) {
+      const active = measurePressure(level, stacked, true);
+      const idle = measurePressure(level, stacked, false);
+      // Record failures before asserting the cohort, retaining every level in
+      // the pressure report when a new demand pattern exposes a policy gap.
+      expect(active.damage).toBeGreaterThan(0);
+      expect(active.healerCasts).toBeGreaterThan(0);
+      // A safe pull may permit the healer to deal damage throughout; require
+      // healing across the cohort rather than inventing demand in every pull.
+      expect(active.effectiveHealing).toBeGreaterThanOrEqual(0);
+      expect(idle.healerCasts).toBe(0);
+      expect(idle.effectiveHealing).toBe(0);
+      expect(Number.isFinite(active.manaLow)).toBe(true);
+      expect(Number.isFinite(active.partyLow)).toBe(true);
+    }
+    expect(report.some((sample) => (sample as { effectiveHealing: number }).effectiveHealing > 0)).toBe(true);
+    expect(report.filter((sample) => (sample as { activeHealer: boolean }).activeHealer)
+      .map((sample) => (sample as { invalid: number }).invalid)).toEqual(Array(8).fill(0));
+  }, 180_000);
+});