azeroth-shell 0.0.0-stage → 0.1.1

package/src/engine/game/factionState.ts

@@ -0,0 +1,108 @@
+// Reputation-pane list state: At War, Inactive and the watched faction, plus the derived at-war set the
+// interaction gates read. The rules live in domain/creature/reputation.ts; this owns the mutation.
+
+import type { DataStore } from '../../data/dataStore.ts';
+import type { Character } from '../../domain/character/character.ts';
+import type { ActionResult } from './types.ts';
+import {
+  FACTION_FLAG,
+  atWarFactionIds,
+  canToggleAtWar,
+  canToggleInactive,
+  effectiveFactionFlags,
+  isFactionVisible,
+  setFactionFlagBit,
+} from '../../domain/creature/reputation.ts';
+
+export interface FactionStateApi {
+  atWarFactions(): ReadonlySet<number>;
+  setFactionAtWar(factionId: number, on: boolean): ActionResult<{ atWar: boolean }>;
+  setFactionInactive(factionId: number, on: boolean): ActionResult<{ inactive: boolean }>;
+  setWatchedFaction(factionId: number): ActionResult<{ watched: number }>;
+}
+
+export interface FactionStateDeps {
+  ds: DataStore;
+  char: () => Character;
+  setChar: (next: Character) => void;
+  log: (line: string) => void;
+}
+
+// Bind the reputation-pane mutators to a game's character slot. The at-war set is memoized on the
+// identity of the two maps it derives from, which are replaced wholesale, so a stale set is impossible.
+export function createFactionStateApi(deps: FactionStateDeps): FactionStateApi {
+  const { ds, char, setChar, log } = deps;
+  let cache: {
+    reps: Character['reputations'];
+    flags: Character['factionFlags'];
+    set: ReadonlySet<number>;
+  } | null = null;
+
+  const atWarFactions = (): ReadonlySet<number> => {
+    const c = char();
+    if (cache && cache.reps === c.reputations && cache.flags === c.factionFlags) return cache.set;
+    const set = atWarFactionIds(ds.factions(), c.reputations, c.factionFlags, c.race, c.cls);
+    cache = { reps: c.reputations, flags: c.factionFlags, set };
+    return set;
+  };
+
+  /** Flip one FACTION_FLAG bit on the character, seeding from the FactionDef defaults. */
+  const writeFlag = (factionId: number, bit: number, on: boolean): void => {
+    const c = char();
+    const fac = ds.faction(factionId)!;
+    setChar({ ...c, factionFlags: setFactionFlagBit(c.factionFlags, fac, bit, on, c.race, c.cls) });
+  };
+
+  return {
+    atWarFactions,
+
+    setFactionAtWar(factionId, on) {
+      const c = char();
+      const fac = ds.faction(factionId);
+      if (!fac) return { ok: false, reason: 'Unknown faction' };
+      if (!canToggleAtWar(effectiveFactionFlags(fac, c.factionFlags, c.race, c.cls), on)) {
+        return {
+          ok: false,
+          reason: on
+            ? `You cannot declare war on ${fac.name}.`
+            : `You cannot change your stance toward ${fac.name}.`,
+        };
+      }
+      writeFlag(factionId, FACTION_FLAG.AT_WAR, on);
+      log(on ? `You are now at war with ${fac.name}.` : `You are now at peace with ${fac.name}.`);
+      return { ok: true, atWar: on };
+    },
+
+    setFactionInactive(factionId, on) {
+      const c = char();
+      const fac = ds.faction(factionId);
+      if (!fac) return { ok: false, reason: 'Unknown faction' };
+      if (!canToggleInactive(effectiveFactionFlags(fac, c.factionFlags, c.race, c.cls), on)) {
+        return { ok: false, reason: `${fac.name} cannot be made inactive.` };
+      }
+      writeFlag(factionId, FACTION_FLAG.INACTIVE, on);
+      // A parked faction can't stay on the XP bar (the client drops the watch too).
+      if (on && char().watchedFaction === factionId) {
+        setChar({ ...char(), watchedFaction: undefined });
+      }
+      return { ok: true, inactive: on };
+    },
+
+    setWatchedFaction(factionId) {
+      const c = char();
+      if (!factionId) {
+        setChar({ ...c, watchedFaction: undefined });
+        return { ok: true, watched: 0 };
+      }
+      const fac = ds.faction(factionId);
+      if (!fac) return { ok: false, reason: 'Unknown faction' };
+      if (!isFactionVisible(fac, c.reputations, c.factionFlags, c.race, c.cls)) {
+        return { ok: false, reason: `You have no standing with ${fac.name}.` };
+      }
+      // Same button toggles off (the client's checkbox).
+      const next = c.watchedFaction === factionId ? undefined : factionId;
+      setChar({ ...c, watchedFaction: next });
+      return { ok: true, watched: next ?? 0 };
+    },
+  };
+}

package/src/engine/game/garmentsOoc.ts

@@ -0,0 +1,69 @@
+// OOC garments residual: Lesser Heal then Fortitude on the kneeling NPC credits TalkedToCreature. The
+// patient entry must be explicit — zone-granular auto-target free-completed the quest with no heal.
+
+import type { DataStore } from '../../data/dataStore.ts';
+import type { QuestLog } from '../../domain/quests/questlog.ts';
+import { getQuest, recordKill } from '../../domain/quests/questlog.ts';
+import {
+  garmentsReset,
+  garmentsSpellHit,
+  type GarmentsState,
+  GARMENTS_ENTRY_QUEST,
+  SPELL_LESSER_HEAL_R2,
+  SPELL_FORTITUDE_R1,
+} from '../../domain/scriptdev/npcsSpecial.ts';
+
+/** Session-scoped handler (heal state not persisted — re-heal after reload). */
+export function createGarmentsOocHandler(): {
+  afterCast: (
+    spellId: number,
+    targetCreature: number | undefined,
+    questlog: QuestLog,
+    ds: DataStore,
+    log: (line: string) => void,
+  ) => QuestLog;
+} {
+  const healByEntry = new Map<number, GarmentsState>();
+  return {
+    afterCast(spellId, targetCreature, questlog, ds, log) {
+      const targetEntry = (targetCreature ?? 0) | 0;
+      if (targetEntry <= 0) return questlog;
+      const garmentsQuest = GARMENTS_ENTRY_QUEST[targetEntry];
+      if (
+        garmentsQuest == null
+        || (spellId !== SPELL_LESSER_HEAL_R2 && spellId !== SPELL_FORTITUDE_R1)
+      ) {
+        return questlog;
+      }
+      const qst = getQuest(questlog, garmentsQuest);
+      // Cite: npcs_special.cpp:577 GetQuestStatus == QUEST_STATUS_INCOMPLETE
+      if (!qst || qst.status !== 'active') return questlog;
+
+      let gst = healByEntry.get(targetEntry);
+      if (!gst) {
+        gst = garmentsReset();
+        healByEntry.set(targetEntry, gst);
+      }
+      const hit = garmentsSpellHit({
+        entry: targetEntry,
+        spellId,
+        questIncomplete: true,
+        inCombat: false,
+        state: gst,
+      });
+      if (!hit.handled) return questlog;
+
+      healByEntry.set(targetEntry, hit.state);
+      const npc = ds.creature(targetEntry)?.name ?? `NPC ${targetEntry}`;
+      if (hit.phase === 'healed') {
+        log(`${npc} is healed.`);
+        return questlog;
+      }
+      if (hit.phase === 'fortitude_credit' && hit.questCreditEntry) {
+        log(`${npc} thanks you.`);
+        return recordKill(questlog, hit.questCreditEntry, (e) => ds.quest(e));
+      }
+      return questlog;
+    },
+  };
+}

package/src/engine/game/globalActionBar.ts

@@ -0,0 +1,179 @@
+// Raid action bar fire/edit surface. Pattern C: createGlobalActionBarModule(ctx, extras).
+// Empty by default. Every living raid member at least tries each slot.
+
+import { slotAt, SLOTS_PER_BAR, type ActionBar } from '../../domain/character/actionbar.ts';
+import {
+  clearGlobalBarSlot,
+  globalItemKind,
+  normalizeGlobalBar,
+  setGlobalBarItem,
+  setGlobalBarOutfit,
+  shouldTryGlobalAction,
+  type GlobalMemberSnap,
+} from '../../domain/raid/globalActionBar.ts';
+import { maxHealth, maxPower } from '../../domain/character/character.ts';
+import { canUseItem } from '../../domain/items/itemRestrictions.ts';
+import { countItem, emptyInventory } from '../../domain/items/inventory.ts';
+import { findOutfitByName, normalizeOutfitterState } from '../../domain/bots/outfitter.ts';
+import { companionCharacter, companionLevel } from '../../domain/bots/squad.ts';
+import type { CombatSession } from '../combat.ts';
+import type { Game } from './types.ts';
+import type { GameCtx } from './context.ts';
+
+export type GlobalActionBarExtras = {
+  consumeItem: Game['consumeItem'];
+  useCompanionItem: Game['useCompanionItem'];
+  wearOutfitByName: Game['wearOutfitByName'];
+  liveSession: () => CombatSession | null;
+};
+
+function raidHasItem(state: Game['state'], entry: number): boolean {
+  if (countItem(state.inventory, entry) > 0) return true;
+  for (const c of state.squad ?? []) {
+    if (countItem(c.bags ?? emptyInventory(), entry) > 0) return true;
+  }
+  return false;
+}
+
+function alreadyOnGlobalBar(bar: ActionBar, entry: number): boolean {
+  return (bar.items ?? []).includes(entry);
+}
+
+export function createGlobalActionBarModule(
+  ctx: GameCtx,
+  extras: GlobalActionBarExtras,
+): Pick<
+  Game,
+  | 'setGlobalItemSlot'
+  | 'setGlobalOutfitSlot'
+  | 'clearGlobalActionSlot'
+  | 'fireGlobalActionBar'
+  | 'fireGlobalActionSlot'
+> {
+  const { ds, state } = ctx;
+
+  const barOf = (): ActionBar => normalizeGlobalBar(state.globalActionBar);
+
+  const write = (next: ActionBar): void => {
+    state.globalActionBar = next;
+  };
+
+  const memberSnaps = (entry: number | null, outfitName: string | null): GlobalMemberSnap[] => {
+    const sess = extras.liveSession();
+    const it = entry != null ? ds.item(entry) : undefined;
+    const out: GlobalMemberSnap[] = [];
+
+    const pv = sess?.playerView();
+    const pCount = sess
+      ? (sess.unitItems('player').find((x) => x.item.entry === entry)?.count ?? 0)
+      : (entry != null ? countItem(state.inventory, entry) : 0);
+    out.push({
+      alive: pv ? pv.hp > 0 : state.char.health > 0,
+      classId: state.char.cls,
+      health: pv ? pv.hp : state.char.health,
+      maxHealth: pv ? pv.maxHp : maxHealth(state.char, ds),
+      power: pv ? pv.power : state.char.power,
+      maxPower: pv ? pv.maxPower : maxPower(state.char, ds),
+      itemCount: pCount,
+      canUse: it ? canUseItem(state.char, it, ds) : true,
+      hasOutfit: outfitName
+        ? !!findOutfitByName(normalizeOutfitterState(state.outfitter), outfitName)
+        : false,
+    });
+
+    const squad = state.squad ?? [];
+    for (let i = 0; i < squad.length; i++) {
+      const comp = squad[i]!;
+      const lvl = companionLevel(comp, state.char.level);
+      const char = companionCharacter(comp, lvl, ds);
+      const av = sess?.alliesView()?.[i];
+      const side = `ally_${i}`;
+      const cCount = sess
+        ? (sess.unitItems(side).find((x) => x.item.entry === entry)?.count ?? 0)
+        : (entry != null ? countItem(comp.bags ?? emptyInventory(), entry) : 0);
+      out.push({
+        alive: av ? av.hp > 0 : char.health > 0,
+        classId: char.cls,
+        health: av ? av.hp : char.health,
+        maxHealth: av ? av.maxHp : maxHealth(char, ds),
+        power: av ? av.power : char.power,
+        maxPower: av ? av.maxPower : maxPower(char, ds),
+        itemCount: cCount,
+        canUse: it ? canUseItem(char, it, ds) : true,
+        hasOutfit: outfitName
+          ? !!findOutfitByName(normalizeOutfitterState(comp.outfitter), outfitName)
+          : false,
+      });
+    }
+    return out;
+  };
+
+  const fireSlot = (slot: number): number => {
+    const content = slotAt(barOf(), slot);
+    if (!content) return 0;
+    if (content.kind === 'outfit') {
+      if (extras.liveSession()) return 0;
+      const snaps = memberSnaps(null, content.name);
+      if (!snaps.some((m) => shouldTryGlobalAction(content, m, null))) return 0;
+      extras.wearOutfitByName(content.name, { party: true });
+      return 1;
+    }
+    if (content.kind !== 'item') return 0;
+    const it = ds.item(content.entry);
+    const kind = globalItemKind(it);
+    const snaps = memberSnaps(content.entry, null);
+    const sess = extras.liveSession();
+    let tried = 0;
+    for (let i = 0; i < snaps.length; i++) {
+      const snap = snaps[i]!;
+      if (!shouldTryGlobalAction(content, snap, kind)) continue;
+      tried++;
+      if (i === 0) {
+        if (sess) sess.useUnitItem('player', content.entry);
+        else extras.consumeItem(content.entry);
+      } else {
+        const side = `ally_${i - 1}`;
+        const id = state.squad?.[i - 1]?.id;
+        if (sess) sess.useUnitItem(side, content.entry);
+        else if (id) extras.useCompanionItem(id, content.entry);
+      }
+    }
+    return tried;
+  };
+
+  return {
+    setGlobalItemSlot(slot, entry) {
+      if (entry == null) {
+        write(clearGlobalBarSlot(barOf(), slot));
+        return;
+      }
+      const current = barOf();
+      if (!raidHasItem(state, entry) && !alreadyOnGlobalBar(current, entry)) return;
+      const it = ds.item(entry);
+      if (!it || !(it.useInCombat || it.useBuff || it.useSpell != null)) return;
+      write(setGlobalBarItem(current, slot, entry));
+    },
+
+    setGlobalOutfitSlot(slot, name) {
+      if (name == null || !name.trim()) {
+        write(clearGlobalBarSlot(barOf(), slot));
+        return;
+      }
+      write(setGlobalBarOutfit(barOf(), slot, name));
+    },
+
+    clearGlobalActionSlot(slot) {
+      write(clearGlobalBarSlot(barOf(), slot));
+    },
+
+    fireGlobalActionBar() {
+      let tried = 0;
+      for (let i = 0; i < SLOTS_PER_BAR; i++) tried += fireSlot(i);
+      return { tried };
+    },
+
+    fireGlobalActionSlot(slot) {
+      return { tried: fireSlot(slot) };
+    },
+  };
+}

package/src/engine/game/goInteractQuestCredit.ts

@@ -0,0 +1,51 @@
+// Quest credit after a successful interactObject Use: a plain Use records the object, while a goober
+// spell or a lock-key item whose use spell matches the required one credits the cast on the GO.
+
+import {
+  recordObject,
+  recordCastedCreatureOrGO,
+  reqSpellForObjectTarget,
+  type QuestLog,
+} from '../../domain/quests/questlog.ts';
+import type { QuestDef } from '../../data/schema/quest.ts';
+
+export function applyInteractObjectQuestCredit(opts: {
+  questlog: QuestLog;
+  objectEntry: number;
+  /** false skips recordObject (QUESTGIVER leaves credit undefined). */
+  questCredit?: boolean;
+  /** Goober/trap spell cast on Use (GameObject.cpp:1645). */
+  castSpellId?: number;
+  /** LOCK_KEY_ITEM used for this open, if any. */
+  keyItemEntry?: number;
+  /** item.useSpell for that key (0 when none). */
+  keyUseSpell?: number;
+  questOf: (entry: number) => QuestDef | undefined;
+  activeQuests: ReadonlyArray<{ entry: number; status: string }>;
+}): QuestLog {
+  let log = opts.questlog;
+  if (opts.questCredit !== false) {
+    log = recordObject(log, opts.objectEntry, opts.questOf);
+  }
+
+  let spellId = opts.castSpellId && opts.castSpellId > 0 ? opts.castSpellId : 0;
+  // Key-as-cast-item: interactObject opens via LOCK_KEY_ITEM; real client casts item.useSpell
+  // on the GO (OPEN_LOCK), which credits with that spell id — not spellid=0 bare Use.
+  if (!spellId && opts.keyItemEntry != null && (opts.keyUseSpell ?? 0) > 0) {
+    const useSpell = opts.keyUseSpell!;
+    for (const qs of opts.activeQuests) {
+      if (qs.status === 'turnedIn') continue;
+      const q = opts.questOf(qs.entry);
+      if (!q) continue;
+      if (!(q.objectTargets ?? []).some((ot) => ot.objectEntry === opts.objectEntry)) continue;
+      if (reqSpellForObjectTarget(q, opts.objectEntry) === useSpell) {
+        spellId = useSpell;
+        break;
+      }
+    }
+  }
+  if (spellId > 0) {
+    log = recordCastedCreatureOrGO(log, opts.objectEntry, spellId, opts.questOf);
+  }
+  return log;
+}

package/src/engine/game/goMoTransportUse.ts

@@ -0,0 +1,61 @@
+// Apply a successful type-15 Use: AddPassenger, then TeleportTransport via the transports bake.
+// Cite: Transports.cpp:271 AddPassenger; :349 Transport::Update; :206 TeleportTransport.
+
+import { departJourney } from '../../domain/nav/travel.ts';
+import type { JourneyLeg } from '../../domain/nav/travelTypes.ts';
+import { resolveType15Ride } from '../../domain/world/goMoTransport.ts';
+import { refuseIfDead } from '../../domain/run/death.ts';
+import type { GameObjectDef } from '../../data/schema.ts';
+import type { LootDrop } from '../../domain/items/loot.ts';
+import type { ActionResult } from './types.ts';
+import type { GameCtx } from './context.ts';
+
+export type Type15DepartHooks = {
+  afterDepart: (nowMs: number) => void;
+};
+
+export function applyType15MoTransportUse(
+  ctx: GameCtx,
+  go: GameObjectDef,
+  nowMs: number,
+  hooks: Type15DepartHooks,
+): ActionResult<{ yielded: LootDrop[]; destination?: string; travelMs?: number; boarded?: boolean }> {
+  const { ds, state, log } = ctx;
+  const dead = refuseIfDead(state.char.health, state.deathFlow);
+  if (dead) return dead;
+  if (state.char.journey) return { ok: false, reason: 'You are already travelling' };
+
+  const ride = resolveType15Ride(go, state.char.zoneId, ds.transports(), nowMs);
+  if (ride.kind === 'not_at_dock') {
+    return { ok: false, reason: 'The transport is not here' };
+  }
+  if (ride.kind === 'board') {
+    log(`You board ${go.name}.`);
+    return { ok: true, yielded: [], boarded: true };
+  }
+
+  const leg: JourneyLeg = {
+    kind: 'transport',
+    from: ride.from,
+    to: ride.to,
+    seconds: ride.seconds,
+    costCopper: 0,
+    transportEntry: ride.transportEntry,
+    waitSeconds: ride.waitSeconds,
+  };
+  if (state.instance) state.instance = null;
+  const journey = departJourney([leg], nowMs);
+  state.char = { ...state.char, journey };
+  state.corpse = null;
+  hooks.afterDepart(nowMs);
+
+  const destName = ds.zone(ride.to)?.name ?? ride.to;
+  const etaMin = Math.max(1, Math.round(ride.seconds / 60));
+  log(`You board ${go.name} for ${destName} (ETA ~${etaMin} min).`);
+  return {
+    ok: true,
+    yielded: [],
+    destination: ride.to,
+    travelMs: ride.seconds * 1000,
+  };
+}

package/src/engine/game/goTransportUse.ts

@@ -0,0 +1,60 @@
+// Apply a successful type-11 Use: board (AddPassenger) and, for Subway, depart the tram bake.
+// Cite: Transports.cpp:271 AddPassenger; :454 ElevatorTransport::Update; travelEdges kind tram.
+
+import { departJourney } from '../../domain/nav/travel.ts';
+import type { JourneyLeg } from '../../domain/nav/travelTypes.ts';
+import { resolveType11Ride } from '../../domain/world/goTransport.ts';
+import { refuseIfDead } from '../../domain/run/death.ts';
+import type { GameObjectDef } from '../../data/schema.ts';
+import type { LootDrop } from '../../domain/items/loot.ts';
+import type { ActionResult } from './types.ts';
+import type { GameCtx } from './context.ts';
+
+export type Type11DepartHooks = {
+  afterDepart: (nowMs: number) => void;
+};
+
+export function applyType11TransportUse(
+  ctx: GameCtx,
+  go: GameObjectDef,
+  nowMs: number,
+  hooks: Type11DepartHooks,
+): ActionResult<{ yielded: LootDrop[]; destination?: string; travelMs?: number; boarded?: boolean }> {
+  const { ds, state, log } = ctx;
+  const dead = refuseIfDead(state.char.health, state.deathFlow);
+  if (dead) return dead;
+  if (state.char.journey) return { ok: false, reason: 'You are already travelling' };
+
+  const ride = resolveType11Ride(go, state.char.zoneId, ds.travelEdges(), nowMs);
+  if (ride.kind === 'not_at_station') {
+    return { ok: false, reason: 'The tram is not here' };
+  }
+  if (ride.kind === 'elevator') {
+    log(`You board ${go.name}.`);
+    return { ok: true, yielded: [], boarded: true };
+  }
+
+  const leg: JourneyLeg = {
+    kind: 'tram',
+    from: ride.from,
+    to: ride.to,
+    seconds: ride.seconds,
+    costCopper: 0,
+    waitSeconds: ride.waitSeconds,
+  };
+  if (state.instance) state.instance = null;
+  const journey = departJourney([leg], nowMs);
+  state.char = { ...state.char, journey };
+  state.corpse = null;
+  hooks.afterDepart(nowMs);
+
+  const destName = ds.zone(ride.to)?.name ?? ride.to;
+  const etaMin = Math.max(1, Math.round(ride.seconds / 60));
+  log(`You board ${go.name} for ${destName} (ETA ~${etaMin} min).`);
+  return {
+    ok: true,
+    yielded: [],
+    destination: ride.to,
+    travelMs: ride.seconds * 1000,
+  };
+}

package/src/engine/game/healthstoneUpkeep.ts

@@ -0,0 +1,59 @@
+// Party healthstone upkeep — the same conjure-and-trade the dungeon runs before a pull
+// (squadDungeon.ts:741), on a timer instead of once, so a stone that got eaten is replaced and a
+// party that never zoned into an instance gets one at all. Warlock.cpp:107-174.
+
+import type { DataStore } from '../../data/dataStore.ts';
+import {
+  companionCharacter, companionLevel, companionSpellbook,
+} from '../../domain/bots/squad.ts';
+import { healthstoneRunLog, runPrePullHealthstones, stoneHolder, type StoneHolder } from './prePullHealthstones.ts';
+import type { HealthstoneRunResult } from './prePullHealthstones.ts';
+import type { GameState } from './types.ts';
+
+/** How often one party re-checks its stones. A conjure is instant, the walk between them is not. */
+export const HEALTHSTONE_UPKEEP_MS = 30_000;
+
+/** The player and every squad companion as stone holders, reading and writing their real bags. */
+export function partyStoneHolders(state: GameState, ds: DataStore): StoneHolder[] {
+  return [
+    stoneHolder({
+      name: state.char.name,
+      char: state.char,
+      role: state.squadRole ?? 'dps',
+      specName: state.rotation?.autoSig?.spec ?? null,
+      knownSpellIds: state.spellbook.known,
+      auraSpellIds: (state.char.activeAuras ?? []).map((a) => a.spellId),
+      read: () => state.inventory,
+      write: (inv) => { state.inventory = inv; },
+    }),
+    ...(state.squad ?? []).map((c) => {
+      const lvl = companionLevel(c, state.char.level);
+      return stoneHolder({
+        name: c.name,
+        char: companionCharacter(c, lvl, ds),
+        role: c.role,
+        specName: c.rotation?.autoSig?.spec ?? ds.botSpecs(c.cls)[c.specIdx ?? 0]?.name ?? null,
+        knownSpellIds: companionSpellbook(c, lvl, ds).known,
+        auraSpellIds: (c.prePullAuras ?? []).map((a) => a.spellId),
+        read: () => c.bags,
+        write: (inv) => { c.bags = inv; },
+      });
+    }),
+  ];
+}
+
+/**
+ * Top every party member back up to one healthstone. Silent when nobody is short or no warlock can
+ * pay — only a run that actually handed something over writes a feed line.
+ */
+export function runHealthstoneUpkeep(
+  state: GameState,
+  ds: DataStore,
+  log: (msg: string) => void,
+): HealthstoneRunResult {
+  const result = runPrePullHealthstones(partyStoneHolders(state, ds), ds, state.char.name);
+  if (result.handouts.length > 0) {
+    for (const line of healthstoneRunLog(result, ds, state.char.name)) log(line);
+  }
+  return result;
+}