azeroth-shell 0.0.0-stage → 0.1.0

package/src/domain/quests/interpreter/updaters.ts

@@ -0,0 +1,412 @@
+// QI2 — pure objective progress updaters ported from Player.cpp (AdjustQuestReqItemCount,
+// KilledMonster, CastedCreatureOrGO, TalkedToCreature). They return whether CanComplete would fire.
+
+import type { QuestDef } from '../../../data/schema.ts';
+import { canCompleteQuest, type CanCompleteOpts } from './canComplete.ts';
+import {
+  QUEST_FLAGS_SHARABLE,
+  QUEST_OBJECTIVES_COUNT,
+  QUEST_SPECIAL_FLAG_DELIVER,
+  QUEST_SPECIAL_FLAG_KILL_OR_CAST,
+  QUEST_SPECIAL_FLAG_SPEAKTO,
+  computeSpecialFlags,
+  hasQuestFlag,
+  hasSpecialFlag,
+} from './flags.ts';
+import {
+  cloneLog,
+  cloneStatus,
+  type InterpreterLog,
+  type InterpreterQuestStatus,
+  type QuestOf,
+} from './types.ts';
+
+export interface UpdaterResult {
+  log: InterpreterLog;
+  /** Quest ids that became completable after this update. */
+  completable: number[];
+}
+
+function incompleteStatuses(
+  log: InterpreterLog,
+): Array<[number, InterpreterQuestStatus]> {
+  const out: Array<[number, InterpreterQuestStatus]> = [];
+  for (const [id, st] of log) {
+    if (st.status === 'incomplete') out.push([id, st]);
+  }
+  return out;
+}
+
+function maybeComplete(
+  quest: QuestDef,
+  st: InterpreterQuestStatus,
+  opts?: CanCompleteOpts,
+): boolean {
+  return canCompleteQuest(quest, st, opts);
+}
+
+// AdjustQuestReqItemCount — sync m_itemcount from current inventory (capped). Cite: Player.cpp:13308–13324.
+export function adjustQuestReqItemCount(
+  quest: QuestDef,
+  status: InterpreterQuestStatus,
+  itemCountOf: (itemId: number) => number,
+): InterpreterQuestStatus {
+  const flags = computeSpecialFlags(quest);
+  if (!hasSpecialFlag(flags, QUEST_SPECIAL_FLAG_DELIVER)) return status;
+
+  const out = cloneStatus(status);
+  const raw = quest.rawObjectives;
+  if (raw) {
+    for (let i = 0; i < QUEST_OBJECTIVES_COUNT; i++) {
+      const req = raw.reqItemCount[i] ?? 0;
+      if (req === 0) continue;
+      const itemId = raw.reqItemId[i] ?? 0;
+      const cur = itemCountOf(itemId);
+      out.m_itemcount[i] = Math.min(cur, req);
+    }
+  } else {
+    const items = quest.itemTargets ?? [];
+    for (let i = 0; i < items.length && i < QUEST_OBJECTIVES_COUNT; i++) {
+      const req = items[i].count;
+      if (req === 0) continue;
+      out.m_itemcount[i] = Math.min(itemCountOf(items[i].item), req);
+    }
+  }
+  return out;
+}
+
+// AreaExploredOrEventHappens — set m_explored for one quest. Cite: Player.cpp:13335–13357 (slot COMPLETE UI
+// omitted; explored bit only).
+export function areaExploredOrEventHappens(
+  log: InterpreterLog,
+  questId: number,
+  questOf: QuestOf,
+  opts?: CanCompleteOpts,
+): UpdaterResult {
+  if (!questId) return { log, completable: [] };
+  const st = log.get(questId);
+  if (!st || st.status !== 'incomplete') return { log, completable: [] };
+
+  const out = cloneLog(log);
+  const next = cloneStatus(st);
+  if (!next.m_explored) next.m_explored = true;
+  out.set(questId, next);
+
+  const quest = questOf(questId);
+  const completable: number[] = [];
+  if (quest && maybeComplete(quest, next, opts)) completable.push(questId);
+  return { log: out, completable };
+}
+
+// ItemAddedQuestCheck — for each incomplete DELIVER quest, add to matching ReqItem. Cite:
+// Player.cpp:13377–13418.
+export function itemAddedQuestCheck(
+  log: InterpreterLog,
+  questOf: QuestOf,
+  entry: number,
+  count: number,
+  opts?: CanCompleteOpts,
+): UpdaterResult {
+  if (!entry || count <= 0) return { log, completable: [] };
+  const out = cloneLog(log);
+  const completable: number[] = [];
+
+  for (const [questid, st0] of incompleteStatuses(log)) {
+    const qInfo = questOf(questid);
+    if (!qInfo) continue;
+    const flags = computeSpecialFlags(qInfo);
+    if (!hasSpecialFlag(flags, QUEST_SPECIAL_FLAG_DELIVER)) continue;
+
+    const st = cloneStatus(st0);
+    let touched = false;
+    const raw = qInfo.rawObjectives;
+
+    if (raw) {
+      for (let j = 0; j < QUEST_OBJECTIVES_COUNT; j++) {
+        const reqitem = raw.reqItemId[j] ?? 0;
+        if (reqitem !== entry) continue;
+        const reqitemcount = raw.reqItemCount[j] ?? 0;
+        const curitemcount = st.m_itemcount[j];
+        if (curitemcount < reqitemcount) {
+          const add = Math.min(count, reqitemcount - curitemcount);
+          st.m_itemcount[j] = curitemcount + add;
+          touched = true;
+        }
+      }
+    } else {
+      const items = qInfo.itemTargets ?? [];
+      for (let j = 0; j < items.length && j < QUEST_OBJECTIVES_COUNT; j++) {
+        if (items[j].item !== entry) continue;
+        const reqitemcount = items[j].count;
+        const curitemcount = st.m_itemcount[j];
+        if (curitemcount < reqitemcount) {
+          const add = Math.min(count, reqitemcount - curitemcount);
+          st.m_itemcount[j] = curitemcount + add;
+          touched = true;
+        }
+      }
+    }
+
+    if (touched) {
+      out.set(questid, st);
+      if (maybeComplete(qInfo, st, opts)) completable.push(questid);
+    }
+  }
+
+  return { log: out, completable };
+}
+
+// KilledMonsterCredit — credit kill for matching ReqCreatureOrGOId > 0, ReqSpell == 0. Cite:
+// Player.cpp:13477–13527. Raid/group gate omitted (Phonecraft solo; IsAllowedInRaid always true here).
+export function killedMonsterCredit(
+  log: InterpreterLog,
+  questOf: QuestOf,
+  entry: number,
+  opts?: CanCompleteOpts,
+): UpdaterResult {
+  if (!entry) return { log, completable: [] };
+  const addkillcount = 1;
+  const out = cloneLog(log);
+  const completable: number[] = [];
+
+  for (const [questid, st0] of incompleteStatuses(log)) {
+    const qInfo = questOf(questid);
+    if (!qInfo) continue;
+    const flags = computeSpecialFlags(qInfo);
+    if (!hasSpecialFlag(flags, QUEST_SPECIAL_FLAG_KILL_OR_CAST)) continue;
+
+    const st = cloneStatus(st0);
+    let touched = false;
+    const raw = qInfo.rawObjectives;
+
+    if (raw) {
+      for (let j = 0; j < QUEST_OBJECTIVES_COUNT; j++) {
+        // skip GO activate objective or none (Player.cpp:13498–13500)
+        if ((raw.reqCreatureOrGoId[j] ?? 0) <= 0) continue;
+        // skip Cast at creature objective (Player.cpp:13502–13504)
+        if ((raw.reqSpell[j] ?? 0) !== 0) continue;
+
+        const reqkill = raw.reqCreatureOrGoId[j];
+        if (reqkill !== entry) continue;
+
+        const reqkillcount = raw.reqCreatureOrGoCount[j] ?? 0;
+        const cur = st.m_creatureOrGOcount[j];
+        if (cur < reqkillcount) {
+          st.m_creatureOrGOcount[j] = cur + addkillcount;
+          touched = true;
+        }
+      }
+    } else {
+      // Slim killTargets
+      const kills = qInfo.killTargets ?? [];
+      for (let j = 0; j < kills.length && j < QUEST_OBJECTIVES_COUNT; j++) {
+        if (kills[j].creatureEntry !== entry) continue;
+        const req = kills[j].count;
+        const cur = st.m_creatureOrGOcount[j];
+        if (cur < req) {
+          st.m_creatureOrGOcount[j] = cur + addkillcount;
+          touched = true;
+        }
+      }
+    }
+
+    if (touched) {
+      out.set(questid, st);
+      if (maybeComplete(qInfo, st, opts)) completable.push(questid);
+    }
+  }
+
+  return { log: out, completable };
+}
+
+// KilledMonster — credit the template entry, the live entry when it differs, then each non-zero
+// KillCredit[]. Cite: Player.cpp:13463–13475.
+export function killedMonster(
+  log: InterpreterLog,
+  questOf: QuestOf,
+  cInfoEntry: number,
+  opts?: CanCompleteOpts & {
+    creatureEntry?: number;
+    killCredits?: number[];
+  },
+): UpdaterResult {
+  let result: UpdaterResult = { log, completable: [] };
+  const seen = new Set<number>();
+
+  const apply = (entry: number) => {
+    if (!entry || seen.has(entry)) return;
+    seen.add(entry);
+    const r = killedMonsterCredit(result.log, questOf, entry, opts);
+    result = {
+      log: r.log,
+      completable: [...new Set([...result.completable, ...r.completable])],
+    };
+  };
+
+  if (cInfoEntry) apply(cInfoEntry);
+  const live = opts?.creatureEntry ?? 0;
+  if (live && live !== cInfoEntry) apply(live);
+  for (const kc of opts?.killCredits ?? []) {
+    if (kc) apply(kc);
+  }
+  return result;
+}
+
+// CastedCreatureOrGO — credit a cast objective matching ReqSpell plus the creature or GO target.
+// With originalCaster false, only SHARABLE quests credit. Cite: Player.cpp:13530–13600.
+export function castedCreatureOrGO(
+  log: InterpreterLog,
+  questOf: QuestOf,
+  entry: number,
+  isCreature: boolean,
+  spellId: number,
+  opts?: CanCompleteOpts & { originalCaster?: boolean },
+): UpdaterResult {
+  const originalCaster = opts?.originalCaster !== false;
+  const addCastCount = 1;
+  const out = cloneLog(log);
+  const completable: number[] = [];
+
+  for (const [questid, st0] of incompleteStatuses(log)) {
+    const qInfo = questOf(questid);
+    if (!qInfo) continue;
+
+    if (!originalCaster && !hasQuestFlag(qInfo.questFlags, QUEST_FLAGS_SHARABLE)) {
+      continue;
+    }
+
+    const flags = computeSpecialFlags(qInfo);
+    if (!hasSpecialFlag(flags, QUEST_SPECIAL_FLAG_KILL_OR_CAST)) continue;
+
+    const st = cloneStatus(st0);
+    let touched = false;
+    const raw = qInfo.rawObjectives;
+
+    if (raw) {
+      for (let j = 0; j < QUEST_OBJECTIVES_COUNT; j++) {
+        // skip kill creature objective (0) or wrong spell (Player.cpp:13558–13560)
+        if ((raw.reqSpell[j] ?? 0) !== spellId) continue;
+
+        let reqTarget = 0;
+        const id = raw.reqCreatureOrGoId[j] ?? 0;
+        if (isCreature) {
+          if (id > 0) reqTarget = id;
+        } else {
+          if (id < 0) reqTarget = -id;
+        }
+        if (reqTarget !== entry) continue;
+
+        const reqCastCount = raw.reqCreatureOrGoCount[j] ?? 0;
+        const cur = st.m_creatureOrGOcount[j];
+        if (cur < reqCastCount) {
+          st.m_creatureOrGOcount[j] = cur + addCastCount;
+          touched = true;
+        }
+        // same objective target can be in many quests, but not 2 slots on one quest
+        break;
+      }
+    } else {
+      // Slim spellCastTargets — progress by spell id only (FO3 shape).
+      const spells = qInfo.spellCastTargets ?? [];
+      for (let j = 0; j < spells.length && j < QUEST_OBJECTIVES_COUNT; j++) {
+        if (spells[j].spell !== spellId) continue;
+        const req = spells[j].count;
+        const cur = st.m_creatureOrGOcount[j];
+        if (cur < req) {
+          st.m_creatureOrGOcount[j] = cur + addCastCount;
+          touched = true;
+        }
+        break;
+      }
+    }
+
+    if (touched) {
+      out.set(questid, st);
+      if (maybeComplete(qInfo, st, opts)) completable.push(questid);
+    }
+  }
+
+  return { log: out, completable };
+}
+
+// TalkedToCreature — credit SPEAKTO / kill-or-cast creature talk objectives. Cite: Player.cpp:13603–13649.
+// Skips spell casts and GO objectives (Player.cpp:13624–13626).
+export function talkedToCreature(
+  log: InterpreterLog,
+  questOf: QuestOf,
+  entry: number,
+  opts?: CanCompleteOpts,
+): UpdaterResult {
+  if (!entry) return { log, completable: [] };
+  const addTalkCount = 1;
+  const out = cloneLog(log);
+  const completable: number[] = [];
+
+  for (const [questid, st0] of incompleteStatuses(log)) {
+    const qInfo = questOf(questid);
+    if (!qInfo) continue;
+    const flags = computeSpecialFlags(qInfo);
+    if (
+      !hasSpecialFlag(
+        flags,
+        QUEST_SPECIAL_FLAG_KILL_OR_CAST | QUEST_SPECIAL_FLAG_SPEAKTO,
+      )
+    ) {
+      continue;
+    }
+
+    const st = cloneStatus(st0);
+    let touched = false;
+    const raw = qInfo.rawObjectives;
+
+    if (raw) {
+      for (let j = 0; j < QUEST_OBJECTIVES_COUNT; j++) {
+        // skip spell casts and Gameobject objectives (Player.cpp:13624–13626)
+        if ((raw.reqSpell[j] ?? 0) > 0 || (raw.reqCreatureOrGoId[j] ?? 0) < 0) continue;
+        const reqTarget = raw.reqCreatureOrGoId[j] ?? 0;
+        if (reqTarget <= 0) continue;
+        if (reqTarget !== entry) continue;
+
+        const reqTalkCount = raw.reqCreatureOrGoCount[j] ?? 0;
+        const cur = st.m_creatureOrGOcount[j];
+        if (cur < reqTalkCount) {
+          st.m_creatureOrGOcount[j] = cur + addTalkCount;
+          touched = true;
+        }
+      }
+    } else {
+      // Slim: talk credit against killTargets (same slots as kill).
+      const kills = qInfo.killTargets ?? [];
+      for (let j = 0; j < kills.length && j < QUEST_OBJECTIVES_COUNT; j++) {
+        if (kills[j].creatureEntry !== entry) continue;
+        const req = kills[j].count;
+        const cur = st.m_creatureOrGOcount[j];
+        if (cur < req) {
+          st.m_creatureOrGOcount[j] = cur + addTalkCount;
+          touched = true;
+        }
+      }
+    }
+
+    if (touched) {
+      out.set(questid, st);
+      if (maybeComplete(qInfo, st, opts)) completable.push(questid);
+    }
+  }
+
+  return { log: out, completable };
+}
+
+// Credit a GO interact when ReqSpell is 0, i.e. activating it without a cast, through the
+// CastedCreatureOrGO(entry, isCreature=false, spellId=0) path. Cite: Player.cpp:13530.
+export function gameObjectActivated(
+  log: InterpreterLog,
+  questOf: QuestOf,
+  goEntry: number,
+  opts?: CanCompleteOpts,
+): UpdaterResult {
+  return castedCreatureOrGO(log, questOf, goEntry, false, 0, {
+    ...opts,
+    originalCaster: true,
+  });
+}

package/src/domain/quests/questCorpseUse.ts

@@ -0,0 +1,155 @@
+// Quest srcItem whose useSpell is spell_script_target type 2 (a corpse). Farm those corpse
+// entries; never hunt SUMMON_WILD kill-credit creatures. Cite: SpellMgr.h:1771-1776.
+
+import type { DataStore } from '../../data/dataStore.ts';
+import type { QuestDef } from '../../data/schema.ts';
+import type { Inventory } from '../items/inventory.ts';
+import { countItem } from '../items/inventory.ts';
+import type { QuestState } from './questlog.ts';
+import {
+  SPELL_EFFECT_CREATE_ITEM,
+  SPELL_EFFECT_SUMMON_WILD,
+} from '../../engine/spells/interpreter/opcodes.ts';
+import {
+  scriptTargetRowsFor,
+  SPELL_TARGET_TYPE_DEAD,
+} from '../../engine/spells/scriptTargets.ts';
+
+export type CorpseUseStamp = {
+  creatureEntry?: number;
+  hitBySpells?: readonly number[];
+} | null | undefined;
+
+/** True when every `spell_script_target` row for this spell is type 2 DEAD. */
+export function isCorpseUseSpell(spellId: number): boolean {
+  const rows = scriptTargetRowsFor(spellId);
+  return rows.length > 0 && rows.every((r) => r.t === SPELL_TARGET_TYPE_DEAD);
+}
+
+export function itemIsQuestCorpseUse(ds: DataStore, itemEntry: number): boolean {
+  const spell = ds.item(itemEntry)?.useSpell ?? 0;
+  return spell > 0 && isCorpseUseSpell(spell);
+}
+
+/** srcItem.useSpell when that spell is a pure type-2 corpse target. */
+export function corpseUseSpellId(ds: DataStore, quest: QuestDef): number {
+  const item = quest.srcItem?.item ?? 0;
+  if (!(item > 0)) return 0;
+  const spell = ds.item(item)?.useSpell ?? 0;
+  return spell > 0 && isCorpseUseSpell(spell) ? spell : 0;
+}
+
+export function corpseUseItemForQuest(ds: DataStore, quest: QuestDef): number {
+  return corpseUseSpellId(ds, quest) > 0 ? (quest.srcItem?.item ?? 0) : 0;
+}
+
+/** Creature entries the item must be used on (dead). Cite: spell_script_target type 2. */
+export function corpseUseFarmEntries(ds: DataStore, quest: QuestDef): number[] {
+  const spell = corpseUseSpellId(ds, quest);
+  if (!spell) return [];
+  const seen = new Set<number>();
+  const out: number[] = [];
+  for (const r of scriptTargetRowsFor(spell)) {
+    const e = r.e | 0;
+    if (e > 0 && !seen.has(e)) {
+      seen.add(e);
+      out.push(e);
+    }
+  }
+  return out;
+}
+
+/** SUMMON_WILD miscValue — kill-credit NPCs that never spawn in a zone. */
+export function corpseUseSummonedEntries(ds: DataStore, quest: QuestDef): number[] {
+  const spell = corpseUseSpellId(ds, quest);
+  if (!spell) return [];
+  return summonedEntriesForSpell(ds, spell);
+}
+
+export function summonedEntriesForSpell(ds: DataStore, spellId: number): number[] {
+  const sp = ds.spell(spellId);
+  const seen = new Set<number>();
+  const out: number[] = [];
+  const add = (e: number) => {
+    if (e > 0 && !seen.has(e)) {
+      seen.add(e);
+      out.push(e);
+    }
+  };
+  for (const e of sp?.effects ?? []) {
+    if (e.kind === 'summon_wild') add(e.creature | 0);
+  }
+  for (const r of sp?.rawEffects ?? []) {
+    if ((r.effect | 0) === SPELL_EFFECT_SUMMON_WILD) add(r.miscValue | 0);
+  }
+  return out;
+}
+
+export function createdItemsForSpell(ds: DataStore, spellId: number): number[] {
+  const sp = ds.spell(spellId);
+  const seen = new Set<number>();
+  const out: number[] = [];
+  const add = (e: number) => {
+    if (e > 0 && !seen.has(e)) {
+      seen.add(e);
+      out.push(e);
+    }
+  };
+  for (const e of sp?.effects ?? []) {
+    if (e.kind === 'conjure') add(e.item | 0);
+  }
+  for (const r of sp?.rawEffects ?? []) {
+    if ((r.effect | 0) === SPELL_EFFECT_CREATE_ITEM) add((r.itemType ?? 0) | 0);
+  }
+  return out;
+}
+
+export function corpseUseCreatedItems(ds: DataStore, quest: QuestDef): number[] {
+  const spell = corpseUseSpellId(ds, quest);
+  return spell ? createdItemsForSpell(ds, spell) : [];
+}
+
+export function corpseUseWorkRemaining(
+  ds: DataStore,
+  quest: QuestDef,
+  qs: QuestState,
+  inv?: Inventory,
+): boolean {
+  if (!corpseUseSpellId(ds, quest)) return false;
+  for (const e of corpseUseSummonedEntries(ds, quest)) {
+    const kt = (quest.killTargets ?? []).find((k) => k.creatureEntry === e);
+    if (kt && (qs.kills[String(e)] ?? 0) < kt.count) return true;
+  }
+  for (const item of corpseUseCreatedItems(ds, quest)) {
+    const it = (quest.itemTargets ?? []).find((t) => t.item === item);
+    if (!it) continue;
+    if (!inv || countItem(inv, it.item) < it.count) return true;
+  }
+  return false;
+}
+
+export function corpseUseFightEntries(
+  ds: DataStore,
+  quest: QuestDef,
+  qs: QuestState,
+  inv?: Inventory,
+): number[] {
+  return corpseUseWorkRemaining(ds, quest, qs, inv) ? corpseUseFarmEntries(ds, quest) : [];
+}
+
+/** srcItem to use on the current corpse, or 0 when there is nothing to click. */
+export function pendingCorpseUseItem(
+  ds: DataStore,
+  quest: QuestDef,
+  inv: Inventory,
+  lastCorpse: CorpseUseStamp,
+): number {
+  const item = corpseUseItemForQuest(ds, quest);
+  if (!(item > 0) || countItem(inv, item) < 1) return 0;
+  const corpse = lastCorpse?.creatureEntry ?? 0;
+  if (!(corpse > 0)) return 0;
+  if (!corpseUseFarmEntries(ds, quest).includes(corpse)) return 0;
+  const spell = corpseUseSpellId(ds, quest);
+  if (spell > 0 && (lastCorpse?.hitBySpells ?? []).includes(spell)) return 0;
+  return item;
+}

package/src/domain/quests/questDialog.ts

@@ -0,0 +1,43 @@
+// Which of quest_template's four texts the player is owed at each step of the dialog. Port of
+// GossipDef.cpp:531 SendQuestGiverRequestItems, falling through to :435 SendQuestGiverOfferReward.
+
+import type { QuestDef } from '../../data/schema.ts';
+
+export type QuestDialogStep = 'details' | 'requestItems' | 'offerReward';
+
+/** GetReqItemsCount() — the ReqItemId slots the ender takes off you. Cite: QuestDef.h:205. */
+function reqItemsCount(quest: QuestDef): number {
+  const raw = quest.rawObjectives?.reqItemId;
+  if (raw) return raw.filter((id) => id > 0).length;
+  return (quest.itemTargets ?? []).length;
+}
+
+/** The step the ender is at. `completable` is CanRewardQuest: would the turn-in pay right now. */
+export function questEnderStep(quest: QuestDef, completable: boolean): QuestDialogStep {
+  const request = quest.requestItemsText?.trim() ?? '';
+  if (!request || (reqItemsCount(quest) === 0 && completable)) return 'offerReward';
+  return 'requestItems';
+}
+
+/** The line for a step, or '' when that quest_template column is blank. */
+export function questStepText(quest: QuestDef, step: QuestDialogStep): string {
+  if (step === 'details') return quest.detailsText ?? '';
+  if (step === 'requestItems') return quest.requestItemsText ?? '';
+  return quest.offerRewardText ?? '';
+}
+
+/** What the ender says now. Empty for the 136 quests whose OfferRewardText row is blank too. */
+export function questEnderText(quest: QuestDef, completable: boolean): string {
+  return questStepText(quest, questEnderStep(quest, completable));
+}
+
+/** Every line the ender speaks, in packet order: the RequestItems frame first when the client
+ *  would get one, then the OfferReward frame it falls through to. Cite: GossipDef.cpp:531. */
+export function questEnderLines(quest: QuestDef, completable: boolean): string[] {
+  const lines: string[] = [];
+  if (questEnderStep(quest, completable) === 'requestItems') {
+    lines.push(quest.requestItemsText ?? '');
+  }
+  if (completable && quest.offerRewardText) lines.push(quest.offerRewardText);
+  return lines.filter(Boolean);
+}

package/src/domain/quests/questFight.ts

@@ -0,0 +1,34 @@
+// Quest-fight NPCs (Bartleby, Calvin Montague, Dashel Stonefist). These bake EXPLORATION_OR_EVENT
+// with empty killTargets, so without this helper the template stays Friendly and the chain locks.
+
+import type { DataStore } from '../../data/dataStore.ts';
+import type { QuestLog } from './questlog.ts';
+import { requiresEventCredit } from './questlog.ts';
+import { resolveQuestScript } from './interpreter/dbscript/registry.ts';
+
+// If `creatureEntry` is the accept target of an active event quest whose QI4 registry emits
+// AttackStart, return that quest id for event credit. Otherwise null.
+export function questFightEventQuestId(
+  ds: DataStore,
+  log: QuestLog,
+  creatureEntry: number,
+): number | null {
+  for (const qs of log.quests) {
+    if (qs.status !== 'active') continue;
+    // Already credited via finishEscort / prior yield.
+    if (qs.explored === true) continue;
+    const q = ds.quest(qs.entry);
+    if (!q) continue;
+    if (!requiresEventCredit(q)) continue;
+    const starters = q.starterCreatureEntries ?? [];
+    if (!starters.includes(creatureEntry)) continue;
+    const script = resolveQuestScript(q.entry);
+    if (!script?.run) continue;
+    const intents = script.run('accept', q.entry);
+    const attackStart = intents.some(
+      (i) => i.kind === 'attack_start' && i.canAttack !== false,
+    );
+    if (attackStart) return q.entry;
+  }
+  return null;
+}

package/src/domain/quests/questObjectiveLabel.ts

@@ -0,0 +1,39 @@
+import type { QuestDef } from '../../data/schema.ts';
+import { stripInternalNameTags } from '../core/internalNameTags.ts';
+
+export { stripInternalNameTags } from '../core/internalNameTags.ts';
+
+// Player-facing quest-log line for one objective slot. ObjectiveText wins over creature/GO/item name
+// (SMSG_QUEST_QUERY_RESPONSE). Cite: QuestDef.cpp:61-62; QuestHandler.cpp:336-337.
+export function questObjectiveLabel(text: string | undefined, fallbackName: string): string {
+  const sourced = (text ?? '').trim();
+  if (sourced) return sourced;
+  return stripInternalNameTags(fallbackName);
+}
+
+export function creatureObjectiveLabel(quest: QuestDef, entry: number, fallbackName: string): string {
+  const slim = quest.killTargets?.find((k) => k.creatureEntry === entry)?.text;
+  if (slim?.trim()) return slim.trim();
+  const raw = quest.rawObjectives;
+  const i = raw?.reqCreatureOrGoId?.findIndex((id) => id === entry) ?? -1;
+  const fromRaw = i >= 0 ? raw?.objectiveText?.[i] : '';
+  return questObjectiveLabel(fromRaw, fallbackName);
+}
+
+export function objectObjectiveLabel(quest: QuestDef, entry: number, fallbackName: string): string {
+  const slim = quest.objectTargets?.find((o) => o.objectEntry === entry)?.text;
+  if (slim?.trim()) return slim.trim();
+  const raw = quest.rawObjectives;
+  const i = raw?.reqCreatureOrGoId?.findIndex((id) => id === -entry) ?? -1;
+  const fromRaw = i >= 0 ? raw?.objectiveText?.[i] : '';
+  return questObjectiveLabel(fromRaw, fallbackName);
+}
+
+export function itemObjectiveLabel(quest: QuestDef, item: number, fallbackName: string): string {
+  const slim = quest.itemTargets?.find((it) => it.item === item)?.text;
+  if (slim?.trim()) return slim.trim();
+  const raw = quest.rawObjectives;
+  const i = raw?.reqItemId?.findIndex((id) => id === item) ?? -1;
+  const fromRaw = i >= 0 ? raw?.objectiveText?.[i] : '';
+  return questObjectiveLabel(fromRaw, fallbackName);
+}