azeroth-shell 0.0.0-stage → 0.1.0

package/src/engine/combat/displaceFloor.ts

@@ -0,0 +1,113 @@
+// GetHitPosition for combat-yard displacement: a fear dest, a knock-back landing and Charge all share
+// one rule — the last walkable sample on the start storey. A loaded mesh that refuses a step wins.
+
+import type { CombatPosYd, PullGeometryAnchor } from './combatGeometry.ts';
+import { stepToward } from './combatGeometry.ts';
+import { detHypot } from '../core/detMath.ts';
+import { type NavPos } from '../../domain/nav/nav.ts';
+import {
+  findNearestPoly,
+  isWalkableNavMesh,
+  navMeshForMap,
+  stepWalkableNavMesh,
+  type NavMesh,
+} from '../../domain/nav/navmesh.ts';
+
+/** 0.2 yd — walkLosClearNavMesh uses this so a 0.45 yd wall cell is a wall. */
+const SAMPLE_YD = 0.2;
+
+export type DisplaceFloor = {
+  mesh?: NavMesh | null;
+  toWorld: (p: CombatPosYd) => NavPos;
+  toCombat: (w: NavPos, prevZ?: number) => CombatPosYd;
+};
+
+function originOf(anchor?: PullGeometryAnchor): { x: number; y: number } | undefined {
+  return anchor?.frame === 'world-translated' ? anchor.origin : undefined;
+}
+
+export function displaceFloorOf(opts: {
+  mapId?: number;
+  origin?: { x: number; y: number };
+}): DisplaceFloor {
+  const origin = opts.origin;
+  const mesh = opts.mapId != null ? navMeshForMap(opts.mapId) : null;
+  return {
+    mesh,
+    toWorld: (p) => {
+      const base = origin ? { x: origin.x + p.x, y: origin.y + p.y } : { x: p.x, y: p.y };
+      return p.z == null ? base : { ...base, z: p.z };
+    },
+    toCombat: (w, prevZ) => {
+      const base = origin ? { x: w.x - origin.x, y: w.y - origin.y } : { x: w.x, y: w.y };
+      const z = w.z ?? prevZ;
+      return z == null ? base : { ...base, z };
+    },
+  };
+}
+
+export function displaceFloorFromCfg(cfg: {
+  geometryAnchor?: PullGeometryAnchor;
+}): DisplaceFloor {
+  return displaceFloorOf({
+    mapId: cfg.geometryAnchor?.mapId,
+    origin: originOf(cfg.geometryAnchor),
+  });
+}
+
+function worldOf(floor: DisplaceFloor, from: CombatPosYd, p: CombatPosYd): NavPos {
+  return floor.toWorld(from.z != null && p.z == null ? { ...p, z: from.z } : p);
+}
+
+function onFloor(floor: DisplaceFloor, w: NavPos): boolean {
+  return floor.mesh ? isWalkableNavMesh(floor.mesh, w.x, w.y, w.z, 4) : true;
+}
+
+function withMeshZ(floor: DisplaceFloor, w: NavPos): NavPos {
+  if (!floor.mesh) return w;
+  const hit = findNearestPoly(floor.mesh, w.x, w.y, w.z, 2);
+  if (!hit || hit.dist > 0.75) return w;
+  return { x: w.x, y: w.y, z: hit.z };
+}
+
+/** Last walkable point on the start storey along from→dest. Unchanged without a floor. */
+export function clampDisplacementToFloor(
+  from: CombatPosYd,
+  dest: CombatPosYd,
+  floor: DisplaceFloor,
+): CombatPosYd {
+  if (!floor.mesh) return dest;
+  const fw = worldOf(floor, from, from);
+  const tw = worldOf(floor, from, dest);
+  const dx = tw.x - fw.x;
+  const dy = tw.y - fw.y;
+  const dist = detHypot(dx, dy);
+  if (!(dist > 1e-9)) return from;
+  const n = Math.max(1, Math.ceil(dist / SAMPLE_YD));
+  let last = fw;
+  for (let i = 1; i <= n; i++) {
+    const t = i / n;
+    const p: NavPos = fw.z == null
+      ? { x: fw.x + dx * t, y: fw.y + dy * t }
+      : { x: fw.x + dx * t, y: fw.y + dy * t, z: fw.z };
+    if (!onFloor(floor, p)) break;
+    last = p;
+  }
+  return floor.toCombat(withMeshZ(floor, last), from.z);
+}
+
+/** One hop toward dest, clamped to the floor. Mesh refuse → stand still (no raster void). */
+export function stepDisplacement(
+  from: CombatPosYd,
+  dest: CombatPosYd,
+  stepYd: number,
+  floor: DisplaceFloor,
+): CombatPosYd {
+  if (!(stepYd > 0)) return from;
+  if (!floor.mesh) return stepToward(from, dest, stepYd, 0);
+  const fw = worldOf(floor, from, from);
+  const tw = worldOf(floor, from, dest);
+  const s = stepWalkableNavMesh(floor.mesh, fw, tw, stepYd);
+  if (detHypot(s.x - fw.x, s.y - fw.y) <= 1e-6) return from;
+  return clampDisplacementToFloor(from, floor.toCombat(s, from.z), floor);
+}

package/src/engine/combat/duelBounds.ts

@@ -0,0 +1,47 @@
+// Player::CheckDuelDistance — the arbiter flag stands at the midpoint of the two duelists
+// (SpellEffects.cpp:4259-4261), and a duelist who stays outside it long enough loses by DUEL_FLED.
+
+import type { CombatContext } from './context.ts';
+import type { CombatPosYd } from './combatGeometry.ts';
+import type { Side } from '../core/events.ts';
+import { detHypot } from '../core/detMath.ts';
+
+/** Out at 50 yd, back in at 40, forfeit 10 s later. Cite: Player.cpp:6908, :6918, :6925. */
+export const DUEL_OUT_OF_BOUNDS_YD = 50;
+export const DUEL_BACK_IN_BOUNDS_YD = 40;
+export const DUEL_FLED_AFTER_MS = 10_000;
+
+const DUELISTS: readonly Side[] = ['player', 'enemy'];
+
+export interface DuelBounds {
+  /** The side that fled, or null. Called once a tick; a positionless duel always answers null. */
+  fled: () => Side | null;
+}
+
+export function createDuelBounds(ctx: CombatContext): DuelBounds {
+  let arbiter: CombatPosYd | null = null;
+  const outSince = new Map<string, number>();
+  const gapTo = (p: CombatPosYd, q: CombatPosYd): number => detHypot(p.x - q.x, p.y - q.y);
+
+  return {
+    fled: (): Side | null => {
+      const at = DUELISTS.map((s) => ctx.posOf?.(s));
+      if (!at[0] || !at[1]) return null;
+      arbiter ??= { x: (at[0].x + at[1].x) / 2, y: (at[0].y + at[1].y) / 2 };
+      for (let i = 0; i < DUELISTS.length; i++) {
+        const side = DUELISTS[i]!;
+        const d = gapTo(at[i]!, arbiter);
+        const since = outSince.get(side) ?? 0;
+        if (!since) {
+          if (d <= DUEL_OUT_OF_BOUNDS_YD) continue;
+          outSince.set(side, ctx.t);
+          ctx.push({ t: ctx.t, kind: 'flavor', text: `${side === 'player' ? 'You have' : 'Your opponent has'} left the duel area.` });
+          continue;
+        }
+        if (d <= DUEL_BACK_IN_BOUNDS_YD) { outSince.set(side, 0); continue; }
+        if (ctx.t - since >= DUEL_FLED_AFTER_MS) return side;
+      }
+      return null;
+    },
+  };
+}

package/src/engine/combat/equippedItemGate.ts

@@ -0,0 +1,297 @@
+// The player equipped-item cast gate. The C++ runs it only for a player, so creatures skip it — their
+// kits bake mainhand only and still Shoot. Ranged bits come off the baked mask, never an invented one.
+
+import { SPELL_ATTR, hasAttr, SPELL_ATTR_EX3, hasAttrEx3 } from "../spells/spellAttributes.ts";
+import { SHAPESHIFT_FORM } from '../../data/schema.ts';
+import type { SpellDef } from '../../data/schema.ts';
+import { roleOf } from './roles.ts';
+import type { CombatantSpec } from './types.ts';
+
+/** ItemPrototype.h ITEM_CLASS_WEAPON */
+export const EQUIP_ITEM_CLASS_WEAPON = 2;
+
+// Forms whose attack speed the client overrides: the equipped weapon is not usable in them, so every
+// weapon-enchant proc is dead — a cat druid swings paws, not the enchanted item.
+export function formOverridesWeapon(form: number | undefined): boolean {
+  return form === SHAPESHIFT_FORM.CAT
+    || form === SHAPESHIFT_FORM.BEAR
+    || form === SHAPESHIFT_FORM.DIREBEAR;
+}
+
+// CanUseEquippedWeapon whole. A form that overrides attack speed kills every hand, while disarm kills
+// only the main one, so an off hand or a bow still swings its enchant. The form arm returns first.
+export function canUseEquippedWeapon(
+  hand: 'mainhand' | 'offhand' | 'ranged',
+  form: number | undefined,
+  disarmed: boolean,
+): boolean {
+  if (formOverridesWeapon(form)) return false;
+  return hand === 'mainhand' ? !disarmed : true;
+}
+/** ItemPrototype.h ITEM_CLASS_ARMOR */
+export const EQUIP_ITEM_CLASS_ARMOR = 4;
+
+// Weapon subclasses that occupy the ranged slot (bow/gun/thrown/crossbow/wand). Cite: ItemPrototype.h
+// ITEM_SUBCLASS_WEAPON_*.
+const RANGED_WEAPON_SUBCLASS_BITS =
+  (1 << 2)  // bow
+  | (1 << 3)  // gun
+  | (1 << 16) // thrown
+  | (1 << 18) // crossbow
+  | (1 << 19); // wand
+
+/** Minimal item shape for IsFitToSpellRequirements. */
+export interface FitItemProbe {
+  /** ItemPrototype.Class */
+  itemClass: number;
+  /** ItemPrototype.SubClass */
+  subclass: number;
+  /** ItemPrototype.InventoryType — only required when inv-type mask applies. */
+  inventoryType?: number;
+  /** Paperdoll slot, required for item-target CheckCast against HELD_ITEM_ONLY. */
+  equipSlot?: string;
+}
+
+/** Spec fields the equipped-item gate reads (player paperdoll / hand-built fixtures). */
+export type EquippedItemFitSpec = Pick<
+  CombatantSpec,
+  | 'ranged'
+  | 'rangedWeaponSubclass'
+  | 'mainhandWeaponSubclass'
+  | 'offhandWeaponSubclass'
+  | 'brokenMainhandWeaponSubclass'
+  | 'brokenOffhandWeaponSubclass'
+  | 'brokenRangedWeaponSubclass'
+  | 'offhandArmorSubclass'
+  | 'bodyArmorSubclasses'
+  | 'rangedArmorSubclass'
+  | 'equippedItemFitReady'
+>;
+
+// Item::IsFitToSpellRequirements (Item.cpp:834–862). `itemTarget` mirrors (spell.Targets &
+// TARGET_FLAG_ITEM) — inventory-type mask is only checked on the enchant / item-target path.
+export function itemFitsSpellRequirements(
+  spell: SpellDef,
+  item: FitItemProbe,
+  opts?: { itemTarget?: boolean },
+): boolean {
+  // Cite: Spell.cpp:6534-6536 if (HasAttribute(HELD_ITEM_ONLY) && (slot < EQUIPMENT_SLOT_MAINHAND || slot > EQUIPMENT_SLOT_RANGED))
+  if (opts?.itemTarget && hasAttr(spell, SPELL_ATTR.HELD_ITEM_ONLY)) {
+    // The gate must check the item's equipped slot, not its inventory type.
+    // Equipment slots: 'mainhand', 'offhand', 'ranged'.
+    const eq = item.equipSlot;
+    if (eq !== 'mainhand' && eq !== 'offhand' && eq !== 'ranged') return false;
+  }
+  const eic = spell.equippedItemClass;
+  if (eic != null && eic >= 0) {
+    if (eic !== (item.itemClass | 0)) return false;
+    const mask = (spell.equippedItemSubClassMask ?? 0) | 0;
+    if (mask !== 0 && (mask & (1 << (item.subclass | 0))) === 0) return false;
+  }
+  // Cite: Item.cpp:856–860 — inv-type only when Targets includes TARGET_FLAG_ITEM.
+  const invMask = (spell.equippedItemInventoryTypeMask ?? 0) | 0;
+  if (invMask !== 0 && opts?.itemTarget) {
+    if (item.inventoryType == null) return false;
+    if ((invMask & (1 << (item.inventoryType | 0))) === 0) return false;
+  }
+  return true;
+}
+
+// The HasItemFitToSpellReqirements slot scan: any equipped probe the fit test accepts is enough, and
+// an absent item class is no requirement. Probes carry a real item class, so the masks cannot cross.
+export function hasItemFitToSpellRequirements(
+  spell: SpellDef,
+  probes: readonly FitItemProbe[],
+  opts?: { itemTarget?: boolean },
+): boolean {
+  const eic = spell.equippedItemClass;
+  if (eic == null || eic < 0) return true;
+  for (const p of probes) {
+    if (itemFitsSpellRequirements(spell, p, opts)) return true;
+  }
+  return false;
+}
+
+// Build FitItemProbe[] from CombatantSpec weapon/armor subclass fields. Cite: Player.cpp weapon scan
+// MH/OH/ranged; armor scan body+OH+ranged.
+export function fitProbesFromSpec(spec: EquippedItemFitSpec): FitItemProbe[] {
+  const out: FitItemProbe[] = [];
+  if (spec.mainhandWeaponSubclass != null) {
+    out.push({ itemClass: EQUIP_ITEM_CLASS_WEAPON, subclass: spec.mainhandWeaponSubclass | 0, equipSlot: "mainhand" });
+  }
+  if (spec.offhandWeaponSubclass != null) {
+    out.push({ itemClass: EQUIP_ITEM_CLASS_WEAPON, subclass: spec.offhandWeaponSubclass | 0, equipSlot: "offhand" });
+  }
+  if (spec.rangedWeaponSubclass != null) {
+    out.push({ itemClass: EQUIP_ITEM_CLASS_WEAPON, subclass: spec.rangedWeaponSubclass | 0, equipSlot: "ranged" });
+  }
+  if (spec.offhandArmorSubclass != null) {
+    out.push({ itemClass: EQUIP_ITEM_CLASS_ARMOR, subclass: spec.offhandArmorSubclass | 0, equipSlot: "offhand" });
+  }
+  if (spec.rangedArmorSubclass != null) {
+    out.push({ itemClass: EQUIP_ITEM_CLASS_ARMOR, subclass: spec.rangedArmorSubclass | 0, equipSlot: "ranged" });
+  }
+  for (const sub of spec.bodyArmorSubclasses ?? []) {
+    out.push({ itemClass: EQUIP_ITEM_CLASS_ARMOR, subclass: sub | 0 });
+  }
+  return out;
+}
+
+// Resolve probes for enforcement: a ready paperdoll always enforces, any set subclass field enforces
+// against known probes, and otherwise null — the hand-built fixture grace.
+export function resolveFitProbes(spec: EquippedItemFitSpec): FitItemProbe[] | null {
+  if (spec.equippedItemFitReady) return fitProbesFromSpec(spec);
+  const hasAny =
+    spec.mainhandWeaponSubclass != null
+    || spec.offhandWeaponSubclass != null
+    || spec.rangedWeaponSubclass != null
+    || spec.offhandArmorSubclass != null
+    || spec.rangedArmorSubclass != null
+    || ((spec.bodyArmorSubclasses?.length ?? 0) > 0);
+  if (!hasAny) return null;
+  return fitProbesFromSpec(spec);
+}
+
+// True when the spell's cast requirements include an equipped ranged weapon. Data-driven when EquippedItem*
+// is baked; otherwise shoot / dmgClass RANGED.
+export function spellRequiresEquippedRangedWeapon(spell: SpellDef): boolean {
+  const eic = spell.equippedItemClass;
+  if (eic != null && eic >= 0) {
+    if (eic !== EQUIP_ITEM_CLASS_WEAPON) return false;
+    const mask = (spell.equippedItemSubClassMask ?? 0) | 0;
+    // mask 0 = any weapon subclass (not specifically ranged).
+    if (mask === 0) return false;
+    // All required bits are ranged subclasses (Multi-Shot / wand Shoot shape).
+    return (mask & ~RANGED_WEAPON_SUBCLASS_BITS) === 0
+      && (mask & RANGED_WEAPON_SUBCLASS_BITS) !== 0;
+  }
+  // Unbaked EquippedItem* fallback — covers rows still missing the columns. A baked `shoot` role is
+  // the only safe signal: every real ranged ability HAS the columns (Auto Shot / Aimed Shot /
+  // Multi-Shot / Volley eic 2 mask 262156, wand Shoot 524288, Throw 65536), so an absent class means
+  // no requirement, exactly as Player.cpp:18572-18575 reads it. Deriving one from DmgClass instead
+  // invented a ranged weapon for 59 rows that need none — the paladin's Hammer of Wrath (24239, 30 yd)
+  // and the rogue's Blind among them (KI-1075).
+  return roleOf(spell) === 'shoot';
+}
+
+// Whether the player's ranged slot satisfies a ranged EquippedItem mask. A known mask and subclass
+// require a bit match, so wand Shoot does not accept a bow; an unknown subclass accepts.
+export function rangedWeaponFitsSpell(
+  spell: SpellDef,
+  hasRangedWeapon: boolean,
+  rangedWeaponSubclass?: number | null,
+): boolean {
+  if (!hasRangedWeapon) return false;
+  const eic = spell.equippedItemClass;
+  if (eic == null || eic < 0) return true; // fallback path: presence only
+  if (eic !== EQUIP_ITEM_CLASS_WEAPON) return false;
+  const mask = (spell.equippedItemSubClassMask ?? 0) | 0;
+  if (mask === 0) return true;
+  if (rangedWeaponSubclass == null) return true;
+  return itemFitsSpellRequirements(spell, {
+    itemClass: EQUIP_ITEM_CLASS_WEAPON,
+    subclass: rangedWeaponSubclass | 0,
+  });
+}
+
+// Player usability / cast refuse: needs a ranged weapon and does not have one that fits the spell's
+// EquippedItem* mask. Reuses the existing 'no ranged weapon' reason (createSession abilities).
+export function playerMissingRequiredRangedWeapon(
+  spell: SpellDef,
+  hasRangedWeapon: boolean,
+  rangedWeaponSubclass?: number | null,
+): boolean {
+  if (!spellRequiresEquippedRangedWeapon(spell)) return false;
+  return !rangedWeaponFitsSpell(spell, hasRangedWeapon, rangedWeaponSubclass);
+}
+
+// The full player equipped-item refusal. Creatures never reach it. With unknown paperdoll subclasses
+// the melee and armor masks are not refused, while a pure-ranged mask still gates Multi-Shot.
+export function playerMissingRequiredEquippedItem(
+  spell: SpellDef,
+  spec: EquippedItemFitSpec,
+): boolean {
+  // Only with a resolved paperdoll: an unknown mainhand is not an absent one, same rule as the
+  // fit probes below. Cite: Player.h:1129 hasWeaponForAttack -> GetWeaponForAttack(t, true, true).
+  if (spec.equippedItemFitReady && hasAttrEx3(spell, SPELL_ATTR_EX3.REQUIRES_MAIN_HAND_WEAPON)) {
+    if (spec.mainhandWeaponSubclass == null) return true;
+  }
+
+  const eic = spell.equippedItemClass;
+
+  // Unbaked EquippedItem* — ranged fallback only.
+  if (eic == null || eic < 0) {
+    return playerMissingRequiredRangedWeapon(
+      spell,
+      !!spec.ranged,
+      spec.rangedWeaponSubclass,
+    );
+  }
+
+  const probes = resolveFitProbes(spec);
+  if (probes === null) {
+    // Fixture grace for non-ranged; keep pure-ranged enforcement.
+    if (spellRequiresEquippedRangedWeapon(spell)) {
+      return playerMissingRequiredRangedWeapon(
+        spell,
+        !!spec.ranged,
+        spec.rangedWeaponSubclass,
+      );
+    }
+    return false;
+  }
+
+  return !hasItemFitToSpellRequirements(spell, probes);
+}
+
+// Probes for weapons still on the paperdoll at 0 durability (combat-inert). Cite: buildCombatant
+// broken*WeaponSubclass; durability.ts isBroken.
+export function brokenWeaponFitProbes(spec: EquippedItemFitSpec): FitItemProbe[] {
+  const out: FitItemProbe[] = [];
+  if (spec.brokenMainhandWeaponSubclass != null) {
+    out.push({ itemClass: EQUIP_ITEM_CLASS_WEAPON, subclass: spec.brokenMainhandWeaponSubclass | 0, equipSlot: 'mainhand' });
+  }
+  if (spec.brokenOffhandWeaponSubclass != null) {
+    out.push({ itemClass: EQUIP_ITEM_CLASS_WEAPON, subclass: spec.brokenOffhandWeaponSubclass | 0, equipSlot: 'offhand' });
+  }
+  if (spec.brokenRangedWeaponSubclass != null) {
+    out.push({ itemClass: EQUIP_ITEM_CLASS_WEAPON, subclass: spec.brokenRangedWeaponSubclass | 0, equipSlot: 'ranged' });
+  }
+  return out;
+}
+
+// True when a broken-but-equipped weapon would satisfy EquippedItem* / ranged need. Distinguishes empty
+// slot from "repair your gear" (KI-891 / KI-798).
+export function brokenWeaponWouldSatisfySpell(
+  spell: SpellDef,
+  spec: EquippedItemFitSpec,
+): boolean {
+  const broken = brokenWeaponFitProbes(spec);
+  if (broken.length === 0) return false;
+
+  if (hasAttrEx3(spell, SPELL_ATTR_EX3.REQUIRES_MAIN_HAND_WEAPON)) {
+    if (spec.brokenMainhandWeaponSubclass != null) return true;
+  }
+
+  const eic = spell.equippedItemClass;
+  // Unbaked EquippedItem* — ranged presence fallback only.
+  if (eic == null || eic < 0) {
+    return spellRequiresEquippedRangedWeapon(spell) && spec.brokenRangedWeaponSubclass != null;
+  }
+  if (eic !== EQUIP_ITEM_CLASS_WEAPON) return false;
+  return hasItemFitToSpellRequirements(spell, broken);
+}
+
+// The ability-strip reason when the equipped-item gate refuses. Broken gear still equipped reads as
+// broken rather than empty, and a missing ranged slot keeps its own wording.
+export function playerEquippedItemRefuseReason(
+  spell: SpellDef,
+  spec: EquippedItemFitSpec,
+): string | undefined {
+  if (!playerMissingRequiredEquippedItem(spell, spec)) return undefined;
+  // Prefer broken over empty: paperdoll still shows the weapon (KI-891 / KI-798).
+  if (brokenWeaponWouldSatisfySpell(spell, spec)) return 'broken weapon';
+  if (spellRequiresEquippedRangedWeapon(spell)) return 'no ranged weapon';
+  if ((spell.equippedItemClass ?? -1) === EQUIP_ITEM_CLASS_ARMOR) return 'no required armor';
+  return 'no required weapon';
+}

package/src/engine/combat/evadeLifecycle.ts

@@ -0,0 +1,63 @@
+// The scripted half of EnterEvadeMode. Two seams evade a mob and both land here, so an encounter fails
+// the same way whichever fires. Before this, 91 onEvade rows had no dispatcher at all.
+
+import {
+  applyInstanceSetData,
+  instanceEventForCreature,
+  lifecycleActions,
+  scriptDevByCreature,
+  scriptDevInstanceForCreature,
+} from '../../domain/scriptdev/index.ts';
+import type { ScriptDevAction } from '../../domain/scriptdev/types.ts';
+import type { CombatContext } from './context.ts';
+import type { Fighter } from './types.ts';
+import { isEnemySide } from '../core/events.ts';
+import { linkedEvadeDespawns } from '../../domain/creature/creatureLinking.ts';
+import { emitSimEffect } from './simEffects.ts';
+
+// Run the instance hook and the boss script's evade and reset for a mob that just evaded. Call it
+// AFTER the hp and threat reset: a Reset row may set health and must win over the evade's full heal.
+export function runEvadeLifecycle(ctx: CombatContext, ef: Fighter): void {
+  const entry = (ef.spec.creatureEntry ?? 0) | 0;
+  if (!entry) return;
+  // LINKING_EVENT_EVADE: a master going home takes its DESPAWN_ON_EVADE slaves off the floor — the
+  // six C'Thun tentacle types carry it beside SELFKILL_ON_DEATH. Cite: CreatureLinkingMgr.h:65.
+  for (const slaveEntry of linkedEvadeDespawns(entry, ef.spec.mapId)) {
+    for (const other of ctx.enemyBlock()) {
+      if (other === ef || ((other.spec.creatureEntry ?? 0) | 0) !== slaveEntry) continue;
+      if (!isEnemySide(other.side) || other.hp <= 0) continue;
+      ctx.forceDespawnEnemy?.(other);
+      ctx.push({ t: ctx.t, kind: 'despawn', actor: other.side });
+    }
+  }
+  /** field:value pairs the instance hook already wrote, so a boss row does not repeat them. */
+  const written = new Set<string>();
+  const instIr = scriptDevInstanceForCreature(entry);
+  const ev = instIr ? instanceEventForCreature(instIr, entry, 'evade') : null;
+  if (instIr && ev) {
+    const res = applyInstanceSetData(instIr, ev.field, ev.value, ctx.instanceData);
+    for (const w of res.writes) {
+      written.add(`${w.field}:${w.value}`);
+      ctx.push({ t: ctx.t, kind: 'instance_data', field: w.field, value: w.value });
+    }
+    for (const go of res.openDoors) {
+      ctx.push({ t: ctx.t, kind: 'flavor', text: `Door ${go} opens.` });
+    }
+    for (const text of res.flavor) ctx.push({ t: ctx.t, kind: 'flavor', text });
+    emitSimEffect(ctx, {
+      kind: 'instanceData', store: new Map(ctx.instanceData), openDoors: res.openDoors,
+    });
+  }
+  const bossIr = scriptDevByCreature(entry);
+  if (isEnemySide(ef.side)) ctx.enemyCastBySide.get(ef.side)?.scriptDev?.oneshotTags?.clear();
+  if (!bossIr) return;
+  const acts: ScriptDevAction[] = [
+    ...lifecycleActions(bossIr, 'onEvade'),
+    ...lifecycleActions(bossIr, 'onReset'),
+  ].filter((a) => a.kind !== 'set_instance_data'
+    || !written.has(`${a.field | 0}:${a.value | 0}`));
+  if (acts.length) ctx.applyScriptDevCombatActions?.(ef, acts);
+  // SummonedJustReachedHome rides the same evade: this engine has no walk-home phase.
+  // Cite: CreatureAI.cpp JustReachedHome after EnterEvadeMode; boss_maexxna.cpp:145-148.
+  ctx.notifyEventAiReachedHome?.(ef);
+}