azeroth-shell 0.0.0-stage → 0.1.0

package/src/engine/combat/tickWorkerBody.ts

@@ -0,0 +1,211 @@
+// The sim, running in a Worker (PERF-RUNSHEET S6b). `perf-measure.mjs simOffThread` reads the entry
+// file `simWorker.ts`, the pump in `combatView.ts` and the open channel in `combatSession.ts`.
+//
+// It owns a session built from PLAIN DATA — specs, a seed, a cloneable config — and answers `tick`
+// messages with the batch. Everything the tick used to call out for arrives as `SimTickInputs` and
+// everything it used to fire arrives back as `SimEffect[]` (mechanisms 2 and 1, already landed).
+
+import type { CombatantSpec, CombatAction, SimTickInputs } from './types.ts';
+import type { CombatEvent, Side } from '../core/events.ts';
+import type { SimEffect } from './simEffects.ts';
+import {
+  createPoseFiller, DISCRETE_BY_SIDE, DISCRETE_ZERO,
+  type DiscreteSnapshot, type DiscreteWant, type SimPoseFrame,
+} from './simSnapshot.ts';
+import type { CombatSession } from './session-types.ts';
+import type { SimCommand } from './simPump.ts';
+
+/** Everything the far side needs to build the same fight. No functions, no live references. */
+export type TickWorkerInit = {
+  kind: 'init';
+  player: CombatantSpec;
+  enemies: CombatantSpec[];
+  allies?: CombatantSpec[];
+  pet?: CombatantSpec | null;
+  seed: number;
+  /** Cloneable half of `CombatConfig`. The function-typed members are rebuilt here or arrive per tick. */
+  cfg: Record<string, unknown>;
+  // One per ally seat, in the same order: the plain-data half of a companion's action provider. The
+  // far side rebuilds each with `buildActionProvider` (actionProviderSpec.ts).
+  allyProviderSpecs?: (import('../../domain/bots/actionProviderSpec.ts').ActionProviderSpec | null)[];
+  /** The player's own rotation, when the engine drives them, in the same plain shape. */
+  playerProviderSpec?: import('../../domain/bots/actionProviderSpec.ts').ActionProviderSpec | null;
+  // The floor, by the URLs the main thread loaded it from: the worker's own nav registry is empty, and
+  // a session that cannot see the mesh walks and fires through walls (CLAUDE.md 0c.1).
+  navAssets?: { mapId: number; meshUrl?: string; collisionUrl?: string; outdoorsUrl?: string };
+  // Config members the payload could not carry because they hold closures. The far side rebuilds
+  // these from its own store; a name here that nothing rebuilds is a silent behaviour gap.
+  droppedCfg?: readonly string[];
+  // Set once every WRITE the caller can make is posted to the far side instead of landing on a
+  // session this side holds. Until then the sim cannot move off-thread: the fight would receive no
+  // orders. `combatView.openPump` says so in `sim_pump` while it is false.
+  commandChannel?: boolean;
+};
+
+export type TickWorkerReq =
+  | TickWorkerInit
+  | {
+    kind: 'tick';
+    seq: number;
+    action?: CombatAction;
+    inputs?: SimTickInputs;
+    // Ask for the discrete half. The caller sets it at its DOM rate, never per tick — 17 members of
+    // view JSON at 40 ticks a second is what the payload contract was written against.
+    wantViews?: boolean;
+    /** Beyond the fixed tables: the memo keys the reading side actually asked for. */
+    want?: DiscreteWant;
+    // Writes the reading side made since the last tick, in the order it made them. Applied BEFORE the
+    // step, so an order given this frame is in effect for the tick it was meant for.
+    commands?: readonly SimCommand[];
+  };
+
+export type TickWorkerRes =
+  | { kind: 'ready'; bootMs: number }
+  | {
+    kind: 'done';
+    seq: number;
+    events: CombatEvent[];
+    t: number;
+    ended: boolean;
+    /** The VERDICT, not only that the fight stopped — the reading side settles xp and loot off it. */
+    winner: Side | 'timeout' | null;
+    effects: SimEffect[];
+    // The pose channel, the RETURN half of the payload contract. A facade on the other side has no
+    // live session to read, so the frame has to travel with the batch.
+    poses?: SimPoseFrame;
+    /** Present only when the request asked for it. */
+    views?: DiscreteSnapshot;
+  }
+  | { kind: 'error'; error: string };
+
+type Port = {
+  onmessage: ((ev: MessageEvent<TickWorkerReq>) => void) | null;
+  postMessage(message: TickWorkerRes): void;
+};
+
+/** Seat allocations whose name the reading side already handed out. The far side takes the same one. */
+const SEAT_COMMANDS = new Set(['injectEnemy', 'injectAlly']);
+
+// Apply one command from the reading side. A seat command is FORCED to the name this side's copy
+// answered with, or the two rosters diverge after the first death (only one of them recycles).
+export function applySimCommand(session: CombatSession, cmd: SimCommand): void {
+  if (cmd.err) {
+    throw new Error(`command ${cmd.m} could not cross the seam: ${cmd.err}`);
+  }
+  const fn = (session as unknown as Record<string, unknown>)[cmd.m];
+  // A command this session does not have is dropped rather than thrown: the member list comes
+  // from the READING side, and an optional member may be absent on a stub.
+  if (typeof fn !== 'function') return;
+  let args = cmd.a;
+  if (SEAT_COMMANDS.has(cmd.m) && typeof cmd.r === 'string') {
+    args = [...args];
+    const opts = (args[2] ?? {}) as Record<string, unknown>;
+    args[2] = { ...opts, side: cmd.r };
+    const got = (fn as (...a: unknown[]) => unknown).apply(session, args);
+    if (got !== cmd.r) {
+      throw new Error(`${cmd.m}: this side seated ${String(got)}, the reading side ${cmd.r}`);
+    }
+    return;
+  }
+  (fn as (...a: unknown[]) => unknown).apply(session, args);
+}
+
+// Wire a port to a session the worker builds itself. Split from the module top level so a test can
+// drive it on THIS thread and compare the two sides event for event (`smoke/tickOverAPort.mjs`).
+export function serveTickWorker(
+  port: Port,
+  build: (init: TickWorkerInit, effectSink: SimEffect[]) => Promise<CombatSession> | CombatSession,
+): void {
+  let session: CombatSession | null = null;
+  // The session's `applyEffect` pushes here instead of acting; `build` must wire it.
+  const effects: SimEffect[] = [];
+  // One filler for the whole fight: the frame is refilled in place and cloned by `postMessage`.
+  let filler = createPoseFiller();
+  port.onmessage = async (ev): Promise<void> => {
+    const msg = ev.data;
+    try {
+      if (msg.kind === 'init') {
+        const t0 = Date.now();
+        // A tick for the OLD fight that lands during this build must not step the new one.
+        session = null;
+        effects.length = 0;
+        filler = createPoseFiller();
+        session = await build(msg, effects);
+        port.postMessage({ kind: 'ready', bootMs: Date.now() - t0 });
+        return;
+      }
+      if (!session) return;
+      effects.length = 0;
+      for (const cmd of msg.commands ?? []) applySimCommand(session, cmd);
+      const events = session.tick(msg.action, msg.inputs);
+      const poses = session.poseFrame?.(filler);
+      const views = msg.wantViews === true
+        ? discreteSnapshot(session, poses?.sides ?? [], msg.want)
+        : undefined;
+      port.postMessage({
+        kind: 'done',
+        seq: msg.seq,
+        events,
+        t: session.t,
+        ended: session.ended,
+        winner: session.winner,
+        effects: effects.slice(),
+        ...(poses ? { poses } : {}),
+        ...(views ? { views } : {}),
+      });
+    } catch (e) {
+      port.postMessage({ kind: 'error', error: String((e as Error)?.message ?? e) });
+    }
+  };
+}
+
+// Every member the facade would otherwise pull off a live session: the view family by name, the two
+// fixed tables, and whatever the reading side's memo was asked for since the last snapshot.
+export function discreteSnapshot(
+  session: CombatSession,
+  sides: readonly string[],
+  want?: DiscreteWant | null,
+): DiscreteSnapshot {
+  const s = session as unknown as Record<string, unknown>;
+  const zero: Record<string, unknown> = {
+    playerView: session.playerView(),
+    enemyView: session.enemyView(),
+    petView: session.petView(),
+    alliesView: session.alliesView(),
+    enemiesView: session.enemiesView(),
+    livingEnemiesView: session.livingEnemiesView(),
+  };
+  const zeroNames = want?.zero.length ? [...DISCRETE_ZERO, ...want.zero] : DISCRETE_ZERO;
+  for (const name of zeroNames) {
+    if (name in zero) continue;
+    const fn = s[name];
+    if (typeof fn === 'function') zero[name] = (fn as () => unknown).call(session);
+  }
+  const bySide: Record<string, Record<string, unknown>> = { viewOfSide: {} };
+  for (const side of sides) bySide.viewOfSide![side] = session.viewOfSide?.(side) ?? null;
+  for (const name of DISCRETE_BY_SIDE) {
+    const fn = s[name];
+    if (typeof fn !== 'function') continue;
+    const per: Record<string, unknown> = {};
+    for (const side of sides) per[side] = (fn as (a: string) => unknown).call(session, side);
+    bySide[name] = per;
+  }
+  if (want) {
+    for (const [name, args] of Object.entries(want.one)) {
+      const fn = s[name];
+      if (typeof fn !== 'function') continue;
+      const per = bySide[name] ?? (bySide[name] = {});
+      for (const a of args) {
+        const key = String(a);
+        if (key in per) continue;
+        per[key] = (fn as (a: unknown) => unknown).call(session, a);
+      }
+    }
+  }
+  return { zero, bySide };
+}
+
+/** The `applyEffect` a worker-side session gets: record, never act. The main thread owns the acting. */
+export function recordingApplyEffect(sink: SimEffect[]): (effect: SimEffect) => void {
+  return (effect) => { sink.push(effect); };
+}

package/src/engine/combat/totemAuras.ts

@@ -0,0 +1,122 @@
+// Totem aura bookkeeping, peeled out of createSession (which sits on a filesize ratchet).
+// Pure functions over the effect list — no session state, no rng, no DOM.
+
+import type { ActiveEffect, Fighter } from './types.ts';
+import type { CombatEvent, Side, TotemSide } from '../core/events.ts';
+import { reverseBuffMod, applyResistMod } from './fighterFactory.ts';
+
+// Remove the auras an unsummoned totem is responsible for, and ONLY those: UnSummon strips its FIRST
+// kit spell, so an aura totem loses its buff while anything it triggered survives. That is twisting.
+export function stripTotemAuras(args: {
+  effects: ActiveEffect[];
+  side: TotemSide;
+  kitSpellId: number;
+  t: number;
+  bySide: (s: Side) => Fighter;
+  push: (e: CombatEvent) => void;
+}): number {
+  const { effects, side, kitSpellId, t, bySide, push } = args;
+  let removed = 0;
+  for (let i = effects.length - 1; i >= 0; i--) {
+    const e = effects[i]!;
+    if (e.fromTotem !== side && e.source !== side) continue;
+    const isOwnPulse = e.source === side && e.kind === 'proc_trigger_spell';
+    const isMagnetCopy = e.kind === 'spell_magnet' && (e.fromTotem === side || e.source === side);
+    if (!isOwnPulse && !isMagnetCopy && kitSpellId > 0 && e.spellId !== kitSpellId) continue;
+    const owner = bySide(e.target);
+    if (e.kind === 'buff') {
+      reverseBuffMod(owner, e.mod, e.amount ?? 0, e.school, {
+        creatureTypeMask: e.creatureTypeMask,
+        schoolMask: e.schoolMask,
+      });
+      owner.buffActive.delete(e.spellId);
+      push({ t, kind: 'aura', actor: e.target, name: e.name, applied: false });
+    } else if (e.kind === 'resist') {
+      applyResistMod(owner, e.school, -(e.amount ?? 0));
+      owner.buffActive.delete(e.spellId);
+      push({ t, kind: 'aura', actor: e.target, name: e.name, applied: false });
+    } else if (e.kind === 'restore_health' || e.kind === 'restore_power') {
+      owner.buffActive.delete(e.spellId);
+      push({ t, kind: 'aura', actor: e.target, name: e.name, applied: false });
+    } else if (e.kind === 'spell_magnet') {
+      // Area copies drop when the totem caster dies. Cite: SpellAuras AreaAura::Update.
+      owner.buffActive.delete(e.spellId);
+      push({ t, kind: 'aura', actor: e.target, name: e.name, applied: false });
+    }
+    effects.splice(i, 1);
+    removed++;
+  }
+  return removed;
+}
+
+// Totem summon ids sit in `buffActive` as rotation bookkeeping, never auras the caster carries. Below:
+// the party-wide SPELL_MAGNET copies, durationMs 0 meaning the totem's lifetime. Cite: spell 8178.
+export function applySpellMagnetToParty(args: {
+  effects: ActiveEffect[];
+  effectsOn?: (side: Side) => ActiveEffect[];
+  party: readonly Fighter[];
+  source: TotemSide;
+  spell: { id: number; name: string; procCharges?: number };
+  expiresAt: number;
+  t: number;
+  push: (e: CombatEvent) => void;
+  touchEffect?: (e: ActiveEffect) => void;
+}): void {
+  const charges = args.spell.procCharges != null && args.spell.procCharges > 0
+    ? args.spell.procCharges
+    : 1;
+  for (const fr of args.party) {
+    if (fr.hp <= 0) continue;
+    const rows = args.effectsOn?.(fr.side) ?? args.effects;
+    const live = rows.find(
+      (e) => e.kind === 'spell_magnet'
+        && e.spellId === args.spell.id
+        && e.target === fr.side
+        && e.source === args.source,
+    );
+    if (live) {
+      live.expiresAt = args.expiresAt;
+      live.charges = charges;
+      args.touchEffect?.(live);
+      continue;
+    }
+    fr.buffActive.add(args.spell.id);
+    args.effects.push({
+      kind: 'spell_magnet',
+      source: args.source,
+      target: fr.side,
+      spellId: args.spell.id,
+      name: args.spell.name,
+      expiresAt: args.expiresAt,
+      charges,
+      fromTotem: args.source,
+    });
+    args.push({ t: args.t, kind: 'aura', actor: fr.side, name: args.spell.name, applied: true });
+  }
+}
+
+export function totemSummonMarkerIds(totems: Iterable<Fighter>): Set<number> {
+  const out = new Set<number>();
+  for (const tot of totems) {
+    if (tot.totemSummonSpellId) out.add(tot.totemSummonSpellId);
+  }
+  return out;
+}
+
+/** Kit auras a standing totem is granting the player right now, with their real remaining time. */
+export function totemGrantedAuras(
+  effects: readonly ActiveEffect[],
+  side: TotemSide,
+  t: number,
+): { spellId: number; name: string; remainingMs: number }[] {
+  const out: { spellId: number; name: string; remainingMs: number }[] = [];
+  for (const e of effects) {
+    if (e.fromTotem !== side || e.target !== 'player' || e.expiresAt <= t) continue;
+    out.push({
+      spellId: e.spellId,
+      name: e.name,
+      remainingMs: Number.isFinite(e.expiresAt) ? Math.max(0, Math.round(e.expiresAt - t)) : 0,
+    });
+  }
+  return out;
+}

package/src/engine/combat/triggerPayload.ts

@@ -0,0 +1,42 @@
+// A periodic-trigger payload, scaled to the caster's level the way an ordinary cast is.
+//
+// `applySpell` resolves EVERY spell it is handed with `casterLevel` plus the spell's own level band
+// (applySpell.ts:469, :496-497), so a rank-1 nuke stops scaling at its maxLevel. The periodic-trigger
+// tick pays direct damage inline instead of routing through applySpell, so its payload came off the
+// bake row unscaled: Hellfire Effect 5857 paid 83 at level 60 where CalculateSpellEffectValue pays 87.
+// 24 payloads carry EffectRealPointsPerLevel, every rank of Arcane Missiles among them.
+// Cite: Object.cpp:2926-2936 CalculateSpellEffectValue level clamp; Unit.cpp:11855 GetSpellRank.
+
+import type { SpellDef } from '../../data/schema.ts';
+import { resolveCombatSpell } from '../spells/interpreter/index.ts';
+
+// Keyed by def identity then caster level: resolving is pure in both, and a tick must not pay for it
+// once a second per aura.
+const CACHE = new WeakMap<SpellDef, Map<number, SpellDef>>();
+
+/** The payload as the caster would cast it. Returns the input unchanged when there is nothing to scale. */
+export function payloadAtCasterLevel(
+  trig: SpellDef,
+  casterLevel: number,
+  casterIsPlayer: boolean,
+): SpellDef {
+  const level = casterLevel | 0;
+  if (!(level > 0)) return trig;
+  if (!trig.rawEffects?.some((r) => Number(r.perLevel) !== 0)) return trig;
+  let byLevel = CACHE.get(trig);
+  if (!byLevel) {
+    byLevel = new Map();
+    CACHE.set(trig, byLevel);
+  }
+  const key = casterIsPlayer ? level : -level;
+  const hit = byLevel.get(key);
+  if (hit) return hit;
+  const out = resolveCombatSpell(trig, {
+    casterLevel: level,
+    casterIsPlayer,
+    ...(trig.baseLevel != null ? { spellBaseLevel: trig.baseLevel } : {}),
+    ...(trig.maxLevel != null ? { spellMaxLevel: trig.maxLevel } : {}),
+  });
+  byLevel.set(key, out);
+  return out;
+}

package/src/engine/combat/triggeredCompanion.ts

@@ -0,0 +1,63 @@
+// A TRIGGERED COMPANION IS NOT AN ACTION: the unit never SELECTS a payload, so no reader answering
+// "what can this unit DO" may count one. 12 melee creatures otherwise read as ranged kits.
+
+import { specialCasePayloadIds } from '../spells/specialCasePayloads.ts';
+import { auraRemovePayloadIds } from '../spells/interpreter/handlers/aura-remove.ts';
+
+type TriggerEffect =
+  | { kind: 'trigger_spell'; spellId: number }
+  | { kind: 'proc_trigger_spell'; triggerSpellId: number }
+  | { kind: string };
+
+/** The minimum a kit member must expose to take part in the walk. */
+export type CompanionCandidate = {
+  readonly id?: number;
+  readonly effects?: readonly TriggerEffect[];
+  readonly rawEffects?: readonly {
+    readonly effect?: number;
+    readonly auraName?: number;
+    readonly triggerSpell?: number;
+  }[];
+};
+
+// Ids in this kit that another member of the SAME kit triggers, keyed on array identity so a
+// shapeshift misses the cache naturally. Without the memo it is kit^2 per unit per tick, 4.6%.
+const cache = new WeakMap<object, Set<number>>();
+
+export function triggeredIdsOf(spells: readonly CompanionCandidate[]): Set<number> {
+  let ids = cache.get(spells as unknown as object);
+  if (ids) return ids;
+  ids = new Set<number>();
+  for (const other of spells) {
+    for (const e of other.effects ?? []) {
+      const tid = e.kind === 'trigger_spell'
+        ? (e as { spellId: number }).spellId
+        : e.kind === 'proc_trigger_spell'
+          ? (e as { triggerSpellId: number }).triggerSpellId
+          : undefined;
+      if (tid != null && other.id !== tid) ids.add(tid);
+    }
+    // The DBC row too: the bake sometimes collapses an aura-42 host into a dedicated kind, and the
+    // parsed walk then cannot see the pair at all. Same fact, second spelling.
+    for (const re of other.rawEffects ?? []) {
+      const an = re.auraName ?? 0;
+      if (an !== 23 && an !== 42 && (re.effect ?? 0) !== 64) continue;
+      const tid = re.triggerSpell ?? 0;
+      if (tid > 0 && other.id !== tid) ids.add(tid);
+    }
+    // And the payloads no DBC column names, because a C++ branch picks them from the victim's school
+    // or the heal target's class. Cite: specialCasePayloads.ts; UnitAuraProcHandler.cpp:870-907.
+    if (other.id != null) {
+      for (const pid of specialCasePayloadIds(other.id)) {
+        if (pid > 0 && other.id !== pid) ids.add(pid);
+      }
+      // And an aura-REMOVAL body's payload, cast when the aura ends. This walk never covered them:
+      // 5 kit slots on 3 raid bosses were still selectable — Renataki, Huhuran, Grobbulus.
+      for (const pid of auraRemovePayloadIds(other.id)) {
+        if (pid > 0 && other.id !== pid) ids.add(pid);
+      }
+    }
+  }
+  cache.set(spells as unknown as object, ids);
+  return ids;
+}