azeroth-shell 0.0.0-stage → 0.1.0

package/src/engine/game/talents.ts

@@ -0,0 +1,356 @@
+// Talent spend / refund / respec / premade. Pattern C: createTalentsModule(ctx, extras). nextRespecCost is
+// pure and re-exported from game.ts for barrel importers. No import of game.ts.
+
+import { applyAura, lowerRanksFor } from '../../domain/character/character.ts';
+import {
+  replaceSpell as replaceBarSpell,
+} from '../../domain/character/actionbar.ts';
+import {
+  ensureLivePlayerRotation,
+  upgradeSpellInRotation,
+} from '../../domain/rotation/rotation.ts';
+import { knows, learn } from '../../domain/character/spellbook.ts';
+import { hasAttrEx, SPELL_ATTR_EX } from '../spells/spellAttributes.ts';
+import {
+  spentPoints,
+  canSpend as canSpendTalent, canRefund as canRefundTalent,
+  spendTalent as doSpendTalent, refundTalent as doRefundTalent, respec as doRespec,
+  talentGrantedSpellIds,
+} from '../../domain/character/talents.ts';
+import { talentsForSpec, talentsFromLink } from '../../domain/character/talentLink.ts';
+import {
+  MAX_TALENT_BUILDS, nextTalentBuildId, normalizeTalentBuilds,
+  sanitizeTalentBuildName, uniqueTalentBuildName,
+} from '../../domain/character/talentBuilds.ts';
+import { moneyMarked } from '../../domain/economy/money.ts';
+import type { Game, GameState } from './types.ts';
+import type { GameCtx } from './context.ts';
+import type { DataStore } from '../../data/dataStore.ts';
+import { autofillPlayerBars } from './barAutofill.ts';
+
+/** Copper per gold (CMaNGOS `GOLD = SILVER * 100`). SharedDefines.h MoneyConstants. */
+const GOLD_COPPER = 10_000;
+/** One "month" for respec decay: CMaNGOS `MONTH = DAY * 30` (seconds) → ms. Common.h TimeConstants. */
+const RESPEC_MONTH_MS = 30 * 24 * 60 * 60 * 1000;
+
+// Next talent-respec cost in copper, matching Player::resetTalentsCost: 1g, then 5g, then 10g, then
+// either decaying by 5g a month down to 10g or rising by 5g up to a 50g cap. Cite: Player.cpp:3715.
+export function nextRespecCost(prevCostCopper: number, monthsSinceLast: number): number {
+  // The first time reset costs 1 gold
+  if (prevCostCopper < 1 * GOLD_COPPER) return 1 * GOLD_COPPER;
+  // then 5 gold
+  if (prevCostCopper < 5 * GOLD_COPPER) return 5 * GOLD_COPPER;
+  // After that it increases in increments of 5 gold
+  if (prevCostCopper < 10 * GOLD_COPPER) return 10 * GOLD_COPPER;
+  if (monthsSinceLast > 0) {
+    // This cost will be reduced by a rate of 5 gold per month
+    // to a minimum of 10 gold.
+    const newCost = prevCostCopper - 5 * GOLD_COPPER * monthsSinceLast;
+    return newCost < 10 * GOLD_COPPER ? 10 * GOLD_COPPER : newCost;
+  }
+  // After that it increases in increments of 5 gold until it hits a cap of 50 gold.
+  let newCost = prevCostCopper + 5 * GOLD_COPPER;
+  if (newCost > 50 * GOLD_COPPER) newCost = 50 * GOLD_COPPER;
+  return newCost;
+}
+
+/** True when both talent maps spend the same ranks (missing key ≡ 0). */
+export function talentMapsEqual(a: Record<number, number>, b: Record<number, number>): boolean {
+  const keys = new Set([...Object.keys(a), ...Object.keys(b)]);
+  for (const k of keys) {
+    const id = Number(k) | 0;
+    if (((a[id] as number) || 0) !== ((b[id] as number) || 0)) return false;
+  }
+  return true;
+}
+
+export type TalentsExtras = {
+  unlearnTalentGrantedSpells: (ids: Set<number>) => void;
+  eligibleSpellIds: () => number[];
+  playerRotationBand: () => string | undefined;
+};
+
+export function createTalentsModule(
+  ctx: GameCtx,
+  extras: TalentsExtras,
+): Pick<
+  Game,
+  | 'spendTalent'
+  | 'refundTalent'
+  | 'respec'
+  | 'respecCost'
+  | 'applyPremadeSpec'
+  | 'saveTalentBuild'
+  | 'deleteTalentBuild'
+  | 'applyTalentBuild'
+  | 'applyTalentLink'
+> {
+  const { ds, state, log } = ctx;
+  const { unlearnTalentGrantedSpells, eligibleSpellIds, playerRotationBand } = extras;
+
+  function respecCost(nowMs?: number): number {
+    if (spentPoints(state.char) === 0) return 0;
+    const now = nowMs ?? Date.now();
+    const prevCost = state.resetTalentsCost ?? 0;
+    const lastTime = state.resetTalentsTime ?? 0;
+    const months = Math.max(0, Math.floor((now - lastTime) / RESPEC_MONTH_MS));
+    return nextRespecCost(prevCost, months);
+  }
+
+  /** Shared player apply: paid respec when the tree is spent, grant/unlearn, rotation rebuild. */
+  function applyLearnSpell(state: GameState, sid: number, ds: DataStore, nowMs?: number) {
+    const ts = nowMs ?? Date.now();
+    state.spellbook = learn(state.spellbook, sid);
+    if (hasAttrEx(ds.spell(sid), SPELL_ATTR_EX.CAST_WHEN_LEARNED)) {
+      state.char = applyAura(state.char, sid, undefined, ts, ds);
+    }
+  }
+
+  function applyNamedTalents(
+    want: Record<number, number>,
+    name: string,
+    nowMs?: number,
+  ): { ok: true; name: string; cost: number } | { ok: false; reason: string } {
+    const have = state.char.talents ?? {};
+    if (talentMapsEqual(have, want)) return { ok: true, name, cost: 0 };
+
+    const spent = spentPoints(state.char);
+    const now = nowMs ?? Date.now();
+    let cost = 0;
+    if (spent > 0) {
+      cost = respecCost(now);
+      if (state.char.gold < cost) return { ok: false, reason: 'Not enough gold' };
+    }
+
+    const oldGranted = talentGrantedSpellIds(state.char, ds);
+    state.char = {
+      ...state.char,
+      talents: { ...want },
+      gold: state.char.gold - cost,
+    };
+    if (spent > 0) {
+      state.resetTalentsCost = cost;
+      state.resetTalentsTime = now;
+      if (state.char.pet) {
+        const petName = state.char.pet.name;
+        state.char = { ...state.char, pet: undefined };
+        log(`You dismissed ${petName}.`);
+      }
+    }
+
+    const newGranted = talentGrantedSpellIds(state.char, ds);
+    const lost = new Set<number>();
+    for (const id of oldGranted) if (!newGranted.has(id)) lost.add(id);
+    unlearnTalentGrantedSpells(lost);
+
+    let grantedNew = false;
+    for (const [tidStr, rnkRaw] of Object.entries(want)) {
+      const tid = Number(tidStr) | 0;
+      const rnk = rnkRaw || 0;
+      if (rnk < 1) continue;
+      const tal = ds.talent(tid);
+      if (!tal) continue;
+      const maxR = Math.min(rnk, tal.ranks.length);
+      for (let r = 1; r <= maxR; r++) {
+        const rank = tal.ranks[r - 1];
+        if (!rank) continue;
+        for (const eff of rank.effects ?? []) {
+          if (eff.kind === 'grant_spell' && typeof (eff as { spellId?: number }).spellId === 'number') {
+            const sid = (eff as { spellId: number }).spellId;
+            if (ds.spell(sid) && !knows(state.spellbook, sid)) {
+              applyLearnSpell(state, sid, ds, nowMs);
+              const lowers = lowerRanksFor(state.spellbook, sid, ds);
+              if (lowers.length) {
+                for (const oldId of lowers) state.actionBars = replaceBarSpell(state.actionBars, oldId, sid);
+                if (state.rotation?.custom) {
+                  state.rotation = upgradeSpellInRotation(state.rotation, lowers, sid);
+                }
+              }
+              grantedNew = true;
+            }
+          }
+          if (eff.kind === 'grant_passive' && rank.spellId) {
+            const sid = rank.spellId;
+            if (ds.spell(sid) && !knows(state.spellbook, sid)) {
+              applyLearnSpell(state, sid, ds, nowMs);
+              grantedNew = true;
+            }
+          }
+        }
+      }
+    }
+    if (grantedNew) {
+      autofillPlayerBars(state, eligibleSpellIds());
+    }
+    state.rotation = ensureLivePlayerRotation(
+      state.rotation,
+      state.char,
+      state.spellbook,
+      ds,
+      state.inventory,
+      { band: playerRotationBand() ?? null, role: state.squadRole },
+    );
+    log(cost > 0
+      ? `Respecced to ${name} for ${moneyMarked(cost)}.`
+      : `Applied talent build ${name}.`);
+    return { ok: true, name, cost };
+  }
+
+  return {
+    spendTalent(talentId) {
+      const check = canSpendTalent(state.char, talentId, ds);
+      if (!check.ok) return { ok: false, reason: check.reason ?? 'Cannot spend talent point' };
+      state.char = doSpendTalent(state.char, talentId, ds);
+      // Materialize any grant_spell (or grant_passive) unlocked by this rank immediately,
+      // mirroring quest-reward and trainer learning. Also used on load for pre-existing points.
+      let grantedNew = false;
+      const tal = ds.talent(talentId);
+      if (tal) {
+        const newRank = ((state.char.talents ?? {})[talentId] as number) || 0;
+        if (newRank >= 1) {
+          const rankIdx = Math.min(newRank - 1, tal.ranks.length - 1);
+          const rank = tal.ranks[rankIdx];
+          for (const eff of (rank?.effects ?? [])) {
+            if (eff.kind === 'grant_spell' && typeof (eff as any).spellId === 'number') {
+              const sid = (eff as any).spellId as number;
+              if (ds.spell(sid) && !knows(state.spellbook, sid)) {
+                applyLearnSpell(state, sid, ds, Date.now());
+                const lowers = lowerRanksFor(state.spellbook, sid, ds);
+                if (lowers.length) {
+                  for (const oldId of lowers) state.actionBars = replaceBarSpell(state.actionBars, oldId, sid);
+                  if (state.rotation?.custom) {
+                    state.rotation = upgradeSpellInRotation(state.rotation, lowers, sid);
+                  }
+                }
+                grantedNew = true;
+                log(`Talent granted ${ds.spell(sid)?.name ?? sid}.`);
+              }
+            }
+            if (eff.kind === 'grant_passive' && rank) {
+              const sid = rank.spellId;
+              if (ds.spell(sid) && !knows(state.spellbook, sid)) {
+                applyLearnSpell(state, sid, ds, Date.now());
+                grantedNew = true;
+              }
+            }
+          }
+        }
+      }
+      if (grantedNew) {
+        autofillPlayerBars(state, eligibleSpellIds());
+        state.rotation = ensureLivePlayerRotation(
+          state.rotation,
+          state.char,
+          state.spellbook,
+          ds,
+          state.inventory,
+          { band: playerRotationBand() ?? null, role: state.squadRole },
+        );
+      }
+      log('Talent point spent.');
+      return { ok: true };
+    },
+
+    refundTalent(talentId) {
+      const check = canRefundTalent(state.char, talentId, ds);
+      if (!check.ok) return { ok: false, reason: check.reason ?? 'Cannot refund talent' };
+      // Unlearn spells only this rank still uniquely granted (mirror spendTalent in reverse).
+      const beforeGrants = talentGrantedSpellIds(state.char, ds);
+      state.char = doRefundTalent(state.char, talentId, ds);
+      const afterGrants = talentGrantedSpellIds(state.char, ds);
+      const lost = new Set<number>();
+      for (const id of beforeGrants) if (!afterGrants.has(id)) lost.add(id);
+      unlearnTalentGrantedSpells(lost);
+      log('Talent point refunded.');
+      return { ok: true };
+    },
+
+    respec(nowMs) {
+      const spent = spentPoints(state.char);
+      if (spent === 0) return { ok: false, reason: 'No talents spent' };
+      // Escalating trainer cost + 5g/month decay. Cite: Player.cpp:3715 resetTalentsCost.
+      const now = nowMs ?? Date.now();
+      const prevCost = state.resetTalentsCost ?? 0;
+      const lastTime = state.resetTalentsTime ?? 0;
+      // CMaNGOS: time_t months = (sWorld.GetGameTime() - m_resetTalentsTime) / MONTH;
+      const months = Math.max(0, Math.floor((now - lastTime) / RESPEC_MONTH_MS));
+      const cost = nextRespecCost(prevCost, months);
+      if (state.char.gold < cost) return { ok: false, reason: 'Not enough gold' };
+      // Snapshot talent grants before clearing points so we can unlearn them immediately.
+      // Cite: Player.cpp:3742 resetTalents - removeSpell on every rank, then RemovePet.
+      const granted = talentGrantedSpellIds(state.char, ds);
+      state.char = { ...doRespec(state.char), gold: state.char.gold - cost };
+      // Cite: Player.cpp:3793–3794 - m_resetTalentsCost = cost; m_resetTalentsTime = now.
+      state.resetTalentsCost = cost;
+      state.resetTalentsTime = now;
+      unlearnTalentGrantedSpells(granted);
+      // Cite: Player.cpp:3798 RemovePet(PET_SAVE_REAGENTS) after talent unlearn.
+      if (state.char.pet) {
+        const petName = state.char.pet.name;
+        state.char = { ...state.char, pet: undefined };
+        log(`You dismissed ${petName}.`);
+      }
+      log(`Talents reset for ${moneyMarked(cost)}.`);
+      return { ok: true, cost };
+    },
+
+    respecCost,
+
+    applyPremadeSpec(specIdx, nowMs) {
+      const specs = ds.botSpecs(state.char.cls);
+      if (specs.length === 0) return { ok: false, reason: 'No premade talent builds for this class' };
+      if (!Number.isInteger(specIdx) || specIdx < 0 || specIdx >= specs.length) {
+        return { ok: false, reason: 'Unknown talent build' };
+      }
+      const next = specs[specIdx]!;
+      const want = talentsForSpec(next, state.char.cls, state.char.level, ds);
+      return applyNamedTalents(want, next.name, nowMs);
+    },
+
+    saveTalentBuild(name, cls, link) {
+      const cleanLink = typeof link === 'string' ? link.trim() : '';
+      if (!cleanLink) return { ok: false, reason: 'Nothing to save' };
+      if (!Number.isInteger(cls) || cls < 1) return { ok: false, reason: 'Unknown class' };
+      const trees = ds.talentTrees(cls);
+      if (!trees.length) return { ok: false, reason: 'No talent tree for that class' };
+      const have = normalizeTalentBuilds(state.talentBuilds);
+      if (have.length >= MAX_TALENT_BUILDS) {
+        return { ok: false, reason: `At most ${MAX_TALENT_BUILDS} saved builds` };
+      }
+      const id = nextTalentBuildId(have);
+      const savedName = uniqueTalentBuildName(have, sanitizeTalentBuildName(name));
+      state.talentBuilds = [...have, { id, name: savedName, cls, link: cleanLink }];
+      log(`Saved talent build ${savedName}.`);
+      return { ok: true, id, name: savedName };
+    },
+
+    deleteTalentBuild(id) {
+      const have = normalizeTalentBuilds(state.talentBuilds);
+      const next = have.filter((b) => b.id !== id);
+      if (next.length === have.length) return { ok: false, reason: 'No such talent build' };
+      state.talentBuilds = next.length ? next : undefined;
+      return { ok: true };
+    },
+
+    applyTalentBuild(id, nowMs) {
+      const b = (state.talentBuilds ?? []).find((row) => row.id === id);
+      if (!b) return { ok: false, reason: 'No such talent build' };
+      if (b.cls !== state.char.cls) return { ok: false, reason: 'That build is for another class' };
+      const want = talentsFromLink(b.link, state.char.cls, state.char.level, ds);
+      if (!Object.values(want).some((n) => n > 0)) {
+        return { ok: false, reason: `Nothing in that string fits a level ${state.char.level}` };
+      }
+      return applyNamedTalents(want, b.name, nowMs);
+    },
+
+    applyTalentLink(link, nowMs) {
+      const clean = typeof link === 'string' ? link.trim() : '';
+      if (!clean) return { ok: false, reason: 'Nothing to apply' };
+      const want = talentsFromLink(clean, state.char.cls, state.char.level, ds);
+      if (!Object.values(want).some((n) => n > 0)) {
+        return { ok: false, reason: `Nothing in that string fits a level ${state.char.level}` };
+      }
+      return applyNamedTalents(want, 'this tree', nowMs);
+    },
+  };
+}

package/src/engine/game/tamingRodUse.ts

@@ -0,0 +1,66 @@
+// Taming Rod practice-channel credit. A bare bag use never free-completes: credit lands only when the
+// rod is used on its sourced practice beast, and the rod itself is never consumed.
+
+import type { DataStore } from '../../data/dataStore.ts';
+import { countItem, type Inventory } from '../../domain/items/inventory.ts';
+import { getQuest, recordEventHappens, type QuestLog } from '../../domain/quests/questlog.ts';
+import { tamingRodByItem } from '../../domain/quests/questTameRods.ts';
+import type { ActionResult } from './types.ts';
+
+/** Bare consumeItem path: refuse free-complete; tell player to target the practice beast. */
+export function refuseBareTamingRodUse(
+  itemEntry: number,
+  inventory: Inventory,
+  ds: DataStore,
+): ActionResult<{ restored: number }> | null {
+  const tameRod = tamingRodByItem(itemEntry);
+  if (!tameRod) return null;
+  if (countItem(inventory, itemEntry) < 1) {
+    return { ok: false, reason: "You don't have this" };
+  }
+  const want = ds.creature(tameRod.targetCreature)?.name ?? 'the practice beast';
+  return { ok: false, reason: `You must use the Taming Rod on ${want}` };
+}
+
+export type TamingRodTargetResult =
+  | { handled: false }
+  | { handled: true; ok: false; reason: string }
+  | { handled: true; ok: true; questlog: QuestLog; logLine: string };
+
+// useQuestItemOnTarget path: grant AreaExploredOrEventHappens only for the named beast. Caller applies
+// questlog mutation + refreshQuests + activity log on ok:true.
+export function tryTamingRodOnTarget(opts: {
+  itemEntry: number;
+  targetCreatureEntry?: number;
+  inventory: Inventory;
+  questlog: QuestLog;
+  ds: DataStore;
+}): TamingRodTargetResult {
+  const tameRod = tamingRodByItem(opts.itemEntry);
+  if (!tameRod) return { handled: false };
+  if (countItem(opts.inventory, opts.itemEntry) < 1) {
+    return { handled: true, ok: false, reason: 'You do not have that item' };
+  }
+  const qst = getQuest(opts.questlog, tameRod.questId);
+  if (!qst || qst.status === 'turnedIn') {
+    return { handled: true, ok: false, reason: 'You have no matching taming quest' };
+  }
+  const target = opts.targetCreatureEntry;
+  if (target == null) {
+    return { handled: true, ok: false, reason: 'You must use the Taming Rod on a beast' };
+  }
+  if (target !== tameRod.targetCreature) {
+    const want = opts.ds.creature(tameRod.targetCreature)?.name
+      ?? `creature ${tameRod.targetCreature}`;
+    return { handled: true, ok: false, reason: `That is not the right beast (need ${want})` };
+  }
+  const questlog = recordEventHappens(opts.questlog, tameRod.questId);
+  const itName = opts.ds.item(opts.itemEntry)?.name ?? 'Taming Rod';
+  const beastName = opts.ds.creature(target)?.name ?? 'the beast';
+  return {
+    handled: true,
+    ok: true,
+    questlog,
+    logLine: `You use the ${itName} on ${beastName} (practice tame).`,
+  };
+}

package/src/engine/game/tempSpawnCreature.ts

@@ -0,0 +1,136 @@
+// SCRIPT_COMMAND_TEMP_SPAWN_CREATURE from the event dbscripts, applied to the session surface. Until
+// this path the intents were only dispositioned, so a binding rune spawned no ritual target.
+
+import type { QuestDef } from '../../data/schema.ts';
+import type { QuestLog } from '../../domain/quests/questlog.ts';
+import type { TempSpawnRecord } from '../../domain/quests/interpreter/dbscript/types.ts';
+import type { FireGoEventResult } from '../../domain/world/goEventFire.ts';
+
+/** One creature temp-summoned from an executed event script row. */
+export interface TempSpawnedCreature {
+  creatureEntry: number;
+  x: number;
+  y: number;
+  z: number;
+  o: number;
+  /** Despawn delay ms from datalong2 (0 = dead-despawn only). */
+  despawnDelayMs: number;
+  /** Wall-clock expiry when delay > 0; else 0. */
+  expiresAtMs: number;
+  eventId: number;
+}
+
+function fromRecord(
+  rec: TempSpawnRecord,
+  eventId: number,
+  nowMs: number,
+): TempSpawnedCreature | null {
+  const creatureEntry = rec.creatureEntry | 0;
+  if (creatureEntry <= 0) return null;
+  const despawnDelayMs = rec.despawnDelay | 0;
+  return {
+    creatureEntry,
+    x: rec.x ?? 0,
+    y: rec.y ?? 0,
+    z: rec.z ?? 0,
+    o: rec.o ?? 0,
+    despawnDelayMs,
+    expiresAtMs: despawnDelayMs > 0 ? nowMs + despawnDelayMs : 0,
+    eventId: eventId | 0,
+  };
+}
+
+/** Collect TEMP_SPAWN_CREATURE results from fireGoEventScripts outputs. */
+export function collectTempSpawnsFromEventFire(
+  fired: readonly FireGoEventResult[],
+  nowMs: number,
+): TempSpawnedCreature[] {
+  const out: TempSpawnedCreature[] = [];
+  const seen = new Set<string>();
+  for (const f of fired) {
+    const bag = f.vm?.world?.tempSpawns ?? [];
+    for (const rec of bag) {
+      const sp = fromRecord(rec, f.eventId, nowMs);
+      if (!sp) continue;
+      // Same entry from the same event once per fire batch (duplicate rows rare).
+      const key = `${f.eventId}:${sp.creatureEntry}:${sp.x}:${sp.y}:${sp.z}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      out.push(sp);
+    }
+    // Belt: intents if world bag was cleared by a host transform.
+    for (const intent of f.vm?.intents ?? []) {
+      if (intent.kind !== 'temp_spawn_creature') continue;
+      const sp = fromRecord(intent, f.eventId, nowMs);
+      if (!sp) continue;
+      const key = `${f.eventId}:${sp.creatureEntry}:${sp.x}:${sp.y}:${sp.z}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      out.push(sp);
+    }
+  }
+  return out;
+}
+
+// Temp-spawned entries that are still unmet kill objectives on active quests: a ritual summon engages
+// the player when it appears, the stand-in for "the demon spawns and attacks at the circle".
+export function unmetQuestKillTempSpawns(
+  questlog: QuestLog,
+  questOf: (entry: number) => QuestDef | undefined,
+  spawns: readonly TempSpawnedCreature[],
+): number[] {
+  const needed = new Set<number>();
+  for (const qs of questlog.quests) {
+    if (qs.status !== 'active') continue;
+    const def = questOf(qs.entry);
+    if (!def) continue;
+    for (const kt of def.killTargets ?? []) {
+      const cur = qs.kills?.[String(kt.creatureEntry)] ?? 0;
+      if (cur < kt.count) needed.add(kt.creatureEntry);
+    }
+  }
+  const out: number[] = [];
+  const seen = new Set<number>();
+  for (const sp of spawns) {
+    const e = sp.creatureEntry;
+    if (!needed.has(e) || seen.has(e)) continue;
+    seen.add(e);
+    out.push(e);
+  }
+  return out;
+}
+
+export interface ApplyTempSpawnsFromEventOpts {
+  fired: readonly FireGoEventResult[];
+  nowMs: number;
+  questlog: QuestLog;
+  questOf: (entry: number) => QuestDef | undefined;
+  creatureName: (entry: number) => string;
+  /** Instant resolve fight — ritual summons engage (Binding, etc.). */
+  fight: (creatureEntry: number) => { ok: boolean; reason?: string };
+  log: (msg: string) => void;
+}
+
+// Materialize TEMP_SPAWN_CREATURE from event fire results. Logs each spawn; auto-fights entries that are
+// unmet active-quest kill targets (ritual path).
+export function applyTempSpawnsFromEventFire(opts: ApplyTempSpawnsFromEventOpts): {
+  spawns: TempSpawnedCreature[];
+  engaged: number[];
+} {
+  const spawns = collectTempSpawnsFromEventFire(opts.fired, opts.nowMs);
+  if (!spawns.length) return { spawns, engaged: [] };
+
+  for (const sp of spawns) {
+    const name = opts.creatureName(sp.creatureEntry);
+    opts.log(`${name} appears!`);
+  }
+
+  const toFight = unmetQuestKillTempSpawns(opts.questlog, opts.questOf, spawns);
+  const engaged: number[] = [];
+  for (const entry of toFight) {
+    const fr = opts.fight(entry);
+    if (fr.ok) engaged.push(entry);
+    else if (fr.reason) opts.log(fr.reason);
+  }
+  return { spawns, engaged };
+}