azeroth-shell 0.2.0 → 0.3.0

package/src/cli/tuiFight.mjs

@@ -4,17 +4,17 @@
 // your cast bar is centred under the floor and the keyed ability bar runs along the bottom. A party fight or
 // a narrow terminal falls back to the list of unit frames (renderFrames). Auto-play runs the character's
 // rotation; a number key presses an ability over it for one GCD.
-import { bold, dim, cyan, yellow, green, red, gray, inverse, fit, vis, cut, bar, strip, brightBlue, itemText, orange } from './text.mjs';
+import { bold, dim, cyan, yellow, green, red, gray, inverse, fit, vis, cut, bar, strip, brightBlue, itemText, orange, coinText } from './text.mjs';
 import { className } from '../domain/core/ids.ts';
-import { SIZES, youSize, foeSize, canvas, put, putLines, floorLine, POWER_PAINT, POP_MS, POP_RISE_MS, LUNGE_MS, SHORT_BUFF_MS, ROLE_GLYPH, plateLines, auraRows, castSlot, auraText, auraTime, putMissiles, lootToasts, putLootToasts } from './tuiStage.mjs';
+import { SIZES, youSize, foeSize, canvas, put, putLines, floorLine, POWER_PAINT, POP_MS, POP_RISE_MS, LUNGE_MS, SHORT_BUFF_MS, ROLE_GLYPH, plateLines, auraRows, castSlot, castRows, auraText, auraTime, putMissiles, lootToasts, putLootToasts } from './tuiStage.mjs';
 import { partyStage } from './tuiPartyStage.mjs';
 import { combatDistanceYd, DEFAULT_OPEN_YD, MELEE_CONTACT_YD } from '../engine/combat/combatGeometry.ts';
 import { formatCombatLog, combatLogPlainText, dropLogRepeats, POWER_MERGE_MS } from './combatLogFormat.ts';
 import { impliedDest } from './combatLogFilter.ts';
-import { moneyText } from '../domain/economy/money.ts';
 import { maxHealth, maxPower } from '../domain/character/character.ts';
 import { powerType } from '../domain/character/characterStats.ts';
 import { pullOpts, sessionLogNames } from './squad.mjs';
+import { prepOoc, prepText } from './oocPrep.mjs';
 import { slotContent, visibleBars } from './tuiBars.mjs';
 import { autoLootOn, openLoot } from './tuiLoot.mjs';
 import { createCombatMacroHost } from './macroHostCombat.ts';
@@ -25,6 +25,8 @@ import { creatureArt, artWidth } from './modelArt.mjs';
 import { iconArt, iconsOn } from './iconArt.mjs';
 
 export const TICK_MS = 100; // one engine tick per 100 ms of real time, like the web client
+// Fight time with every living foe out of combat (an evade, a leash) before the fight ends as a stalemate.
+export const QUIET_END_MS = 3000;
 // A win holds the fight on screen this long (real time), plus a beat for each drop as it slides in.
 const WIN_HOLD_MS = 1000, DROP_HOLD_MS = 450, DROP_STAGGER_MS = 220, WIN_HOLD_MAX_MS = 3500;
 
@@ -38,6 +40,8 @@ const WIN_HOLD_MS = 1000, DROP_HOLD_MS = 450, DROP_STAGGER_MS = 220, WIN_HOLD_MA
 export function startFight(app, creatureEntry, { onEnd, label, begin, after, resolve, onTick, why } = {}) {
   if (app.fight) return { ok: false, reason: 'Already in a fight.' };
   if (app.isDead()) { app.flashMsg('You are dead.'); return { ok: false, reason: 'You are dead.' }; }
+  // A pull you chose buffs first, standing still; a dungeon stop does it in pullStop, an ambush (begin) cannot.
+  if (!begin && !resolve) { const buffed = prepText(prepOoc(app.g, app.ds)); if (buffed) app.say(cyan(buffed)); }
   const opts = begin ? { withSquad: true } : pullOpts(app.g, app.ds, app.cmds.buffPace, creatureEntry, (l) => app.say(cyan(l)));
   const b = begin ? begin() : app.g.beginFight(creatureEntry, opts);
   if (!app.result(b)) { app.render(); return { ok: false, reason: b.reason || 'Cannot fight that.' }; }
@@ -81,9 +85,24 @@ export function startFight(app, creatureEntry, { onEnd, label, begin, after, res
       else events = session.tick();
       this.logEvents(events);
       if (!session.ended) this.onTick?.();
+      if (!session.ended && !begin && !resolve) this.watchQuiet();
       if (session.ended) this.finish();
       app.renderSoon();
     },
+    /** A pull that went quiet: something was in combat, and every living foe has been out of it for QUIET_END_MS.
+     *  The engine keeps that session open (a reset mob stands passive and the rotation leaves it be, so a Scout
+     *  that evaded once held the fight for 970 s), so it ends here as a timeout, which settles as a stalemate:
+     *  the web client's "Enemies evade" settle. Not on a dungeon floor, whose session holds unpulled packs. */
+    wasEngaged: false, quietSince: null,
+    watchQuiet() {
+      const live = session.enemiesView().filter((e) => e.hp > 0);
+      if (live.some((e) => e.engaged)) { this.wasEngaged = true; this.quietSince = null; return; }
+      if (!this.wasEngaged || !live.length || !session.mirrorOutcome) return;
+      this.quietSince ??= session.t;
+      if (session.t - this.quietSince < QUIET_END_MS) return;
+      app.say(yellow(`${live.length > 1 ? 'Your foes reset' : `${live[0].name} resets`} and the fight is over.`));
+      session.mirrorOutcome(true, 'timeout');
+    },
     /** A win holds the fight on screen a moment before it gives the screen back: the foe at 0 on its plate and
      *  what it dropped sliding in beside it (putLootToasts). The timer keeps ticking through it, so the hold is
      *  counted in ticks: the speed keys and the check script drive it like the fight. */
@@ -102,6 +121,8 @@ export function startFight(app, creatureEntry, { onEnd, label, begin, after, res
     logEvents(events) {
       app.meter?.ingest(events);
       notePops(this.frames, events);
+      let known = null;
+      noteCasts(this.frames, events, (id) => (known ??= new Set(session.abilities().map((a) => a.spell.id))).has(id));
       if (this.folded()) return;
       const flush = () => { if (this.pend && this.pend.amount > 0) app.say(line(this.pend.t, this.pend.remake(this.pend.amount))); this.pend = null; };
       const line = (t, row) => `${dim((t / 1000).toFixed(1).padStart(5) + 's')} ${paintLog(row)}`;
@@ -130,7 +151,7 @@ export function startFight(app, creatureEntry, { onEnd, label, begin, after, res
       const tag = r.outcome === 'win' ? green(bold('Victory')) : r.outcome === 'defeat' ? red(bold('Defeat')) : yellow(bold('Stalemate'));
       const bits = [`${(r.result.durationMs / 1000).toFixed(1)} s`, `HP ${app.hpText()}`];
       if (r.xpGained) bits.push(`+${r.xpGained} xp`);
-      if (r.goldGained && !hold) bits.push(`+${moneyText(r.goldGained)}`);
+      if (r.goldGained && !hold) bits.push(`+${coinText(r.goldGained)}`);
       app.say(`${tag} against ${this.enemyName}  ${dim(bits.join('  '))}`);
       if (!hold) { noteLoot(app, r.loot, r.goldGained); for (const d of r.loot) app.say(`  ${yellow('You receive')} ${app.itemLabel(d.item)}${d.count > 1 ? ` x${d.count}` : ''}`); }
       const gained = (app.g.state.squad ?? []).filter((c) => (c.xp ?? 0) !== squadXp.get(c.id)).map((c) => `${c.name} ${(c.xp ?? 0) > (squadXp.get(c.id) ?? 0) ? `+${(c.xp ?? 0) - (squadXp.get(c.id) ?? 0)} xp` : 'levels up'}`);
@@ -558,7 +579,21 @@ const CAST_W = 30; // the cast/control slot on a frame's second line, so auras n
 function newFrameMemory(app) {
   // The player's own aura order carries across fights, so their frame never reshuffles.
   app.playerAuraOrder ??= new Map();
-  return { auraOrder: new Map([['player', app.playerAuraOrder]]), pops: new Map(), used: new Map(), lunge: new Map() };
+  return { auraOrder: new Map([['player', app.playerAuraOrder]]), pops: new Map(), used: new Map(), lunge: new Map(), casts: new Map(), barred: new Map() };
+}
+
+/** Every unit's casts as they go off, newest first, for its cast slot (castRows): a cast_finish with no
+ *  cast_start before it is an instant. `own(id)` keeps yours to the spells you know, so a proc's triggered
+ *  spell never shows as something you pressed. */
+function noteCasts(mem, events, own) {
+  for (const ev of events) {
+    if (!ev.actor || ev.spellId == null) continue;
+    if (ev.kind === 'cast_start') { mem.barred.set(ev.actor, ev.spellId); continue; }
+    if (ev.kind !== 'cast_finish' || (ev.actor === 'player' && !own(ev.spellId))) continue;
+    const instant = mem.barred.get(ev.actor) !== ev.spellId;
+    mem.barred.delete(ev.actor);
+    mem.casts.set(ev.actor, [{ t: ev.t, spellId: ev.spellId, name: ev.name, instant }, ...(mem.casts.get(ev.actor) ?? [])].slice(0, 8));
+  }
 }
 
 const POP_W = 18; // a hit or heal stays beside the bars for POP_MS (fight time), in a slot this wide
@@ -566,12 +601,14 @@ const USED_FLASH_MS = 500; // the ability bar slot of a spell just cast stays in
 const MISS_WORD = { miss: 'Miss', dodge: 'Dodge', parry: 'Parry', immune: 'Immune', deflect: 'Deflect', block: 'Block' };
 
 /** Damage and healing landing on each unit, newest first, for the numbers that pop up beside its bars; the
- *  player's casts, for the flash on the ability bar; and every melee swing, for the lunge. */
+ *  player's casts, for the flash on the ability bar; and every melee auto-attack, for the lunge. */
 function notePops(mem, events) {
   for (const ev of events) {
     let side, text;
     if (ev.actor === 'player' && ev.spellId != null && (ev.kind === 'cast_start' || ev.kind === 'cast_finish' || ev.kind === 'spell_hit' || ev.kind === 'cast_self')) mem.used?.set(ev.spellId, ev.t);
-    if (ev.kind === 'melee' && ev.actor) mem.lunge?.set(ev.actor, ev.t); // only a weapon swing lunges; spells, strikes and thorns do not
+    // Only a melee auto-attack lunges: spells, strikes and thorns do not, nor a ranged white (Auto Shot, Shoot
+    // or Throw), which the engine sends as a melee event tagged with the shoot spell's id and name.
+    if (ev.kind === 'melee' && ev.actor && ev.spellId == null && !ev.name) mem.lunge?.set(ev.actor, ev.t);
     if (ev.kind === 'melee' || ev.kind === 'spell_hit' || ev.kind === 'dot_tick') {
       side = ev.target ?? impliedDest(ev.actor);
       if (ev.amount > 0) text = ev.result === 'crit' ? bold(red(`-${ev.amount}!`)) : red(`-${ev.amount}`);
@@ -603,7 +640,7 @@ function unitFrame(app, mem, v, W, now, isPlayer, focused = false, { compact = f
   if (!bars) {
     const key = isPlayer ? 'player' : (v.side ?? v.name);
     const name = `${(dead ? gray : isPlayer ? green : yellow)(bold(v.name))} ${dim(`L${v.level}`)}`;
-    const slot = castSlot(v, now);
+    const slot = castSlot(v, now, mem.casts?.get(key));
     const auras = auraText(app, mem, v, key);
     return [cut(` ${fit(name, 20)} ${fit(slot, CAST_W)} ${fit(popText(mem, key, now), POP_W)} ${auras}`, W)];
   }
@@ -619,12 +656,15 @@ function unitFrame(app, mem, v, W, now, isPlayer, focused = false, { compact = f
   if (compact) return [cut(`${head}${v.casting && !dead ? `  ${yellow(v.casting.name)}` : after}`, W)];
   // The second line is always there, cast slot first (a cast bar, else crowd control, else stealth, blank when
   // idle) and the auras after it, so gaining a buff or starting a cast never moves this frame or the ones below.
-  const slot = castSlot(v, now);
+  const recent = mem.casts?.get(key);
   if (iconsOn()) {
-    // Icons: a strip of 4x4 icons beside the cast slot, each one's time (or stacks) under it on a third line.
+    // Icons: the cast slot two lines tall (the spell's icon, its name, the casts before it), then a strip of
+    // 4x4 icons, each aura's time (or stacks) under it on the third line.
     const [top, bottom] = auraIcons(app, mem, v, key);
-    return [cut(`${head}${after}`, W), cut(`   ${fit(slot, CAST_W)}  ${top}`, W), cut(`   ${' '.repeat(CAST_W)}  ${bottom}`, W)];
+    const [slotTop, slotUnder] = dead ? ['', ''] : castRows(app, v, recent, now, CAST_W);
+    return [cut(`${head}${after}`, W), cut(`   ${fit(slotTop, CAST_W)}  ${top}`, W), cut(`   ${fit(slotUnder, CAST_W)}  ${bottom}`, W)];
   }
+  const slot = castSlot(v, now, recent);
   const auras = auraText(app, mem, v, key);
   return [cut(`${head}${after}`, W), cut(`   ${fit(slot, CAST_W)}  ${auras}`, W)];
 }
@@ -662,7 +702,7 @@ export function fightArt(app, ctl, W, H) {
   const cols = artCols(W);
   const entry = ctl.session?.enemyView()?.creatureEntry ?? ctl.enemyEntry;
   const foe = cols && entry != null ? creatureArt(app.ds.creature(entry)?.displayId, cols, H) : null;
-  const me = cols && W >= 130 ? playerArt(app, cols, H)?.lines ?? null : null;
+  const me = cols && W >= 130 ? playerArt(app, cols, H, ctl.session?.playerView())?.lines ?? null : null;
   const innerW = W - (foe ? artWidth(foe) + 2 : 0) - (me ? artWidth(me) + 2 : 0);
   return { me, foe, innerW };
 }
@@ -698,13 +738,14 @@ function duelStage(app, ctl, W, H, { inline }) {
   const icons = iconsOn();
   const barW = W >= 140 ? 30 : W >= 110 ? 24 : 18;
   const plateW = barW + PLATE_PAD;
-  const auraH = icons ? 3 : 1;
-  // Rows the scene keeps whatever the sprites get: the plate (3), the state row, the auras and the floor.
-  // The state row is there idle or casting, so a cast never moves the auras under it. The ability bar goes
+  const auraH = icons ? 3 : 1, stateH = icons ? 2 : 1;
+  // Rows the scene keeps whatever the sprites get: the plate (3), the state rows, the auras and the floor.
+  // The state rows are there idle or casting, so a cast never moves the auras under them; with icons they are
+  // two, the spell's icon beside its name and the trail of casts before it (castRows). The ability bar goes
   // when rows are short, and only under auto-play.
   const barLines = ctl.abilityRows(W, W >= 140 ? 6 : 4, { live: !inline });
   let barRows = barLines.length;
-  const fixed = () => 3 + 1 + auraH + 1 + barRows;
+  const fixed = () => 3 + stateH + auraH + 1 + barRows;
   if (H - fixed() < 4 && ctl.auto) barRows = 0;
   const artRows = H - fixed();
   if (artRows < 4) return null;
@@ -718,7 +759,7 @@ function duelStage(app, ctl, W, H, { inline }) {
     return { v, key, art, aw: artWidth(art), cw: Math.max(pw, art ? artWidth(art) : 0), plateW: pw, ...o, barW: o.barW ?? barW };
   };
   const cols = [];
-  const you = column(pv, 'player', youSize(W), (c, r) => playerArt(app, c, r)?.lines ?? null, { isPlayer: true });
+  const you = column(pv, 'player', youSize(W), (c, r) => playerArt(app, c, r, pv)?.lines ?? null, { isPlayer: true });
   const margin = Math.max(GAP, Math.floor(W / 16)); // the actors stand a little in from the edges
   you.x = margin; cols.push(you);
   let left = you.x + you.cw + GAP, right = W - margin, petCol = null;
@@ -763,7 +804,7 @@ function duelStage(app, ctl, W, H, { inline }) {
     }
     cols.push(foe);
   }
-  const zone = artRows, stateRow = zone + 3, auraTop = zone + 4, floorRow = auraTop + auraH, barTop = floorRow + 1;
+  const zone = artRows, stateRow = zone + 3, auraTop = stateRow + stateH, floorRow = auraTop + auraH, barTop = floorRow + 1;
   const c = canvas(W, H);
   for (const col of cols) {
     const v = col.v, dead = v.hp <= 0;
@@ -774,9 +815,10 @@ function duelStage(app, ctl, W, H, { inline }) {
       col.ax = col.x + Math.max(0, Math.floor((col.cw - col.aw) / 2)) + lunge; col.top = zone - col.art.length; putLines(c, col.ax, col.top, col.art);
     }
     putLines(c, col.x, zone, plateLines(app, v, { ...col, dead }));
-    // Your cast sits where the foe's does: under the power bar, in the state row every plate keeps.
-    const slot = castSlot(v, now);
-    if (slot && !dead) put(c, col.x, stateRow, cut(slot, col.plateW));
+    // Your cast sits where the foe's does: under the power bar, in the state rows every plate keeps.
+    const recent = mem.casts.get(col.key);
+    const slot = dead ? [''] : icons ? castRows(app, v, recent, now, col.plateW) : [castSlot(v, now, recent)];
+    if (slot[0] || slot[1]) putLines(c, col.x, stateRow, slot.map((l) => cut(l, col.plateW)));
     else if (col === foe && hidden) put(c, col.x, stateRow, dim(`+${hidden} more in the fight`));
     if (!col.small && !dead) putLines(c, col.x, auraTop, auraRows(app, mem, v, col.key, col.plateW, icons));
     // Hits and heals rise from the chest, the newest lowest; without art they sit beside the name.

package/src/cli/tuiFightPanes.mjs

@@ -2,10 +2,10 @@
 // and the loot taken so far. The log is the game's own log (tui.mjs); the meter is phonecraft's DPSMate
 // aggregator fed every tick's events; threat reads the engine's ThreatManager through the session; loot is a
 // session-long tally of what the "You receive" lines handed over. The choice sticks between fights.
-import { bold, dim, cyan, yellow, green, red, inverse, fit, vis, cut, bar, pct } from './text.mjs';
+import { bold, dim, cyan, yellow, green, red, inverse, fit, vis, cut, bar, pct, coinText } from './text.mjs';
 import { createDpsMateMeter, partyMeterSnapshot } from '../domain/bots/dpsMate.ts';
-import { moneyText } from '../domain/economy/money.ts';
 import { runPaneLines, questPaneLines, bagsPaneLines } from './tuiAutopilot.mjs';
+import { iconsOn, iconArt, iconBlank } from './iconArt.mjs';
 
 export const FIGHT_PANES = [
   { id: 'log', label: 'Log' },
@@ -230,16 +230,25 @@ function threatLines(app, ctl, L) {
 function lootLines(app, L) {
   const t = app.lootTally ?? { rows: [], copper: 0 };
   const n = t.rows.reduce((a, r) => a + r.count, 0);
-  const lines = [` ${bold('Loot this sitting')} ${dim(`${n} item${n === 1 ? '' : 's'}${t.copper ? ` · ${moneyText(t.copper)}` : ''}`)}`];
+  const lines = [` ${bold('Loot this sitting')} ${dim(`${n} item${n === 1 ? '' : 's'}${t.copper ? ` · ${coinText(t.copper)}` : ''}`)}`];
   if (!t.rows.length && !t.copper) { lines.push(dim(' Nothing looted yet. Whatever you take shows up here.')); return lines; }
   const colW = Math.max(24, Math.floor((L.W - 2) / Math.max(1, Math.min(3, Math.floor(L.W / 30)))));
   const cols = Math.max(1, Math.floor((L.W - 2) / colW));
-  const cells = t.rows.map((r) => `${app.itemLabel(r.item)}${r.count > 1 ? dim(` x${r.count}`) : ''}`);
-  const rowsAvail = L.logH - 1;
+  // With icons each cell is two lines: a 4px icon down its left, the name beside the top and the count and
+  // kind beside the bottom.
+  const icons = iconsOn() && L.W >= 40;
+  const h = icons ? 2 : 1;
+  const cells = t.rows.map((r) => {
+    if (!icons) return [`${app.itemLabel(r.item)}${r.count > 1 ? dim(` x${r.count}`) : ''}`];
+    const it = app.ds.item(r.item);
+    const art = iconArt(it?.icon, 4) ?? iconBlank(4);
+    return [`${art[0]} ${app.itemLabel(r.item)}`, `${art[1]} ${dim([r.count > 1 ? `x${r.count}` : '', it?.typeName].filter(Boolean).join(' · '))}`];
+  });
+  const rowsAvail = Math.floor((L.logH - 1) / h);
   for (let i = 0; i < rowsAvail; i++) {
     const slice = cells.slice(i * cols, i * cols + cols);
     if (!slice.length) break;
-    lines.push(` ${slice.map((c) => fit(c, colW - 1)).join(' ')}`);
+    for (let k = 0; k < h; k++) lines.push(` ${slice.map((c) => fit(c[k], colW - 1)).join(' ')}`);
   }
   const shown = Math.min(cells.length, rowsAvail * cols);
   if (shown < cells.length) lines[lines.length - 1] = fit(lines[lines.length - 1], L.W - 10) + dim(`+${cells.length - shown} more`);

package/src/cli/tuiFloor.mjs

@@ -21,7 +21,7 @@ import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { bold, dim, yellow, green, red, cyan, fit } from './text.mjs';
 import { startFight } from './tuiFight.mjs';
-import { pullStop, restBetween } from './tuiDungeon.mjs';
+import { pullStop, restBetween, readyUp } from './tuiDungeon.mjs';
 import { prePull } from './squad.mjs';
 import { decodeNavMesh, registerNavMeshForMap, navMeshForMap } from '../domain/nav/navmesh.ts';
 import { bakeSlugForInstance } from '../world/bakeSlug.ts';
@@ -82,9 +82,13 @@ function stampTemplates(app, ents) {
 /** The floor for the current run, built on first use and kept on the app while the run lasts. */
 function floorFor(app, def) {
   const run = app.g.state.instance;
-  if (app.floor?.dungeonId === run.dungeonId) return app.floor;
-  // Bodies of stops already cleared stay dead on the rebuilt floor, with any loose kills from before.
-  const cleared = new Set(app.floorKills?.[run.dungeonId] ?? []);
+  // One floor per entry: a hearth or a taxi out never cleared app.floor, so the next run of the dungeon walked the old one.
+  const enteredAt = app.g.state.instanceEnteredAtMs ?? null;
+  if (app.floor?.dungeonId === run.dungeonId && app.floor.enteredAt === enteredAt) return app.floor;
+  // Bodies of stops already cleared stay dead on the rebuilt floor, with any loose kills from before. The kills
+  // ride on the run, not the dungeon: a fresh run of the same dungeon stood the last run's dead back up, and an
+  // event's body (the Ring of Law's champion, one guid every run) was born dead and paid out unfought.
+  const cleared = new Set(run.floorClearedGuids ?? []);
   for (const enc of def.encounters) if (isCleared(run, enc.id)) for (const gd of enc.spawnGuids ?? []) cleared.add(gd);
   const bossEntries = new Set(def.encounters.filter((e) => e.kind === 'boss' && e.creatureEntry > 0).map((e) => e.creatureEntry));
   const world = createContinuousWorld({
@@ -96,7 +100,7 @@ function floorFor(app, def) {
     skipEntry: (entry) => !bossEntries.has(entry) && isTechnicalTriggerCreature(app.ds.creature(entry)),
   });
   stampTemplates(app, world.entities);
-  const f = { dungeonId: run.dungeonId, def, world, runMs: 0, patrolIndex: new Map(), target: null, walking: false, follow: true, speed: 1, timer: null, script: null, questScanMs: -Infinity, waiting: [], eventHoldUntil: 0,
+  const f = { dungeonId: run.dungeonId, enteredAt, def, world, runMs: 0, patrolIndex: new Map(), target: null, walking: false, follow: true, speed: 1, timer: null, script: null, questScanMs: -Infinity, waiting: [], eventHoldUntil: 0,
     rng: mulberry32(((app.g.state.rngSeed ?? 1) ^ 0x9e3779b9) >>> 0) };
   f.script = scriptContext(app, f);
   app.floor = f;
@@ -158,8 +162,13 @@ function markEngaged(f, ents) {
 
 function remember(app, f, guids) {
   resolveKill(f.world, guids);
-  app.floorKills ??= {};
-  app.floorKills[f.dungeonId] = [...new Set([...(app.floorKills[f.dungeonId] ?? []), ...guids])];
+  keepKills(app, f);
+}
+
+/** The floor's dead onto the run, so a step outside keeps them and a fresh run starts without them. */
+function keepKills(app, f) {
+  const run = app.g.state.instance;
+  if (run?.dungeonId === f.dungeonId) app.g.state.instance = { ...run, floorClearedGuids: [...f.world.clearedGuids] };
 }
 
 /** One floor tick: patrols, the walk, the scripts, then what sees you. Returns true when a pull started. */
@@ -339,6 +348,7 @@ function fightBodies(app, f, ents) {
 /** The event is lost: its summoned bodies go, claimed ones stand down, and it waits a minute before it arms again. */
 function failEvent(app, f) {
   f.script.resetGauntletOnWipe();
+  keepKills(app, f); // the event's fallen came off the floor's dead; a rebuilt floor must not bring them back dead
   f.eventHoldUntil = f.runMs + EVENT_HOLD_MS;
   app.say(red('The event fails. Rest (z) before you go again; it waits a minute.'));
 }
@@ -398,6 +408,8 @@ function reopen(app) {
 export function walkTo(app, f, enc) {
   const dest = enc.origin;
   if (!dest) { app.flashMsg(`${enc.name} has no place on the floor.`); return; }
+  // Buff and drink before setting off: whatever sees you on the way pulls with no time for it.
+  readyUp(app);
   const r = setMoveOrder(f.world, dest, f.def.mapId);
   f.target = enc.id;
   f.walking = true;
@@ -407,7 +419,7 @@ export function walkTo(app, f, enc) {
 
 /** P on a stop: an event starts where it stands, anything else is pulled from here. */
 function pullFromHere(app, f, enc) {
-  if (!floorGauntletWaves(enc)) { pullStop(app, f.def, enc, { floor: true, onTick: () => stepInFight(app, f), onDone: (r) => settle(app, f, r) }); if (app.fight) app.fight.floor = f; return; }
+  if (!floorGauntletWaves(enc)) { pullStop(app, f.def, enc, { floor: true, ready: true, onTick: () => stepInFight(app, f), onDone: (r) => settle(app, f, r) }); if (app.fight) app.fight.floor = f; return; }
   const run = app.g.state.instance;
   const need = requiredFlags(enc).filter((fl) => !hasFlag(run, fl));
   if (need.length) { app.flashMsg(`${enc.name} has not been set off yet (${need.join(', ')}).`); return; }

package/src/cli/tuiGear.mjs

@@ -1,7 +1,6 @@
-// The Gear tab's lower rows: what repairs cost and where, the ammo you shoot, and the food, water and elixirs the
+// The Character tab's lower rows: what repairs cost and where, the ammo you shoot, and the food, water and elixirs the
 // game uses for you out of combat. Per-slot durability and r (repair this one) ride on the slot rows themselves.
-import { bold, dim, yellow, green, red, qualityPaint, itemText, secondsText } from './text.mjs';
-import { moneyText } from '../domain/economy/money.ts';
+import { bold, dim, yellow, green, red, qualityPaint, itemText, secondsText, coinText } from './text.mjs';
 import { equippedEntry, equippedInstance } from '../domain/items/itemInstance.ts';
 import { gearEnchantDisplayName } from '../domain/professions/gearEnchant.ts';
 import { hasDurability, maxDurability, currentDurability, repairCostSlot } from '../domain/items/durability.ts';
@@ -49,23 +48,23 @@ export function repairOne(app, slot) {
   const cost = repairCostSlot(app.ch, slot, (e) => app.ds.item(e));
   if (!cost) { app.flashMsg('That piece needs no repair.'); return; }
   const r = app.g.repairSlot(slot, q.vendorEntry ?? undefined);
-  app.result(r, r.ok ? `${q.vendorName} repairs it for ${moneyText(r.spent)}.` : '');
+  app.result(r, r.ok ? `${q.vendorName} repairs it for ${coinText(r.spent)}.` : '');
 }
 
-/** Enter on Repair all, or R on the Gear tab: mend everything you wear at the repairer the quote prices against. */
+/** Enter on Repair all, or R on the Character tab: mend everything you wear at the repairer the quote prices against. */
 export function repairAll(app) {
   const q = app.g.repairQuote();
   if (!q.cost) { app.flashMsg('Nothing needs repair.'); return; }
   if (!q.vendorName) { app.flashMsg('Nobody here repairs.'); return; }
   const r = app.g.repairAll(q.vendorEntry ?? undefined);
-  app.result(r, r.ok ? `Repaired for ${moneyText(r.spent)}.` : '');
+  app.result(r, r.ok ? `Repaired for ${coinText(r.spent)}.` : '');
 }
 
 export function slotRepairLines(app, slot) {
   const cost = repairCostSlot(app.ch, slot, (e) => app.ds.item(e));
   if (!cost) return [];
   const q = app.g.repairQuote();
-  return [q.vendorName ? dim(`r: repair this piece for ${moneyText(cost)} at ${q.vendorName}`) : dim(`Repairing this piece costs about ${moneyText(cost)}.`)];
+  return [q.vendorName ? dim(`r: repair this piece for ${coinText(cost)} at ${q.vendorName}`) : dim(`Repairing this piece costs about ${coinText(cost)}.`)];
 }
 
 const rangedWeapon = (app) => { const e = equippedEntry(app.ch.equipped.ranged); return e != null ? app.ds.item(e) : undefined; };
@@ -127,13 +126,13 @@ export function autoConsumablesDialog(app) {
   };
 }
 
-/** The rows under the paperdoll on the Gear tab. */
+/** The rows under the paperdoll on the Character tab. */
 export function gearExtraRows(app) {
   const rows = [H(''), H('Upkeep')];
   const q = app.g.repairQuote();
   rows.push({
-    text: `Repair all  ${q.cost ? yellow(moneyText(q.cost)) : dim('nothing to mend')}${q.cost ? dim(q.vendorName ? `  at ${q.vendorName}` : '  nobody here repairs') : ''}`,
-    detail: () => [bold('Repair'), '', q.cost ? `Mending everything you wear costs ${moneyText(q.cost)}.` : 'Everything you wear is in good shape.', q.vendorName ? dim(`Priced at ${q.vendorName}.`) : dim('A smith or general goods vendor repairs.'), '', dim('Enter: repair all   r on a slot: repair one piece')],
+    text: `Repair all  ${q.cost ? coinText(q.cost) : dim('nothing to mend')}${q.cost ? dim(q.vendorName ? `  at ${q.vendorName}` : '  nobody here repairs') : ''}`,
+    detail: () => [bold('Repair'), '', q.cost ? `Mending everything you wear costs ${coinText(q.cost)}.` : 'Everything you wear is in good shape.', q.vendorName ? dim(`Priced at ${q.vendorName}.`) : dim('A smith or general goods vendor repairs.'), '', dim('Enter: repair all   r on a slot: repair one piece')],
     act: (a) => repairAll(a),
   });
   const weapon = rangedWeapon(app);

package/src/cli/tuiLoot.mjs

@@ -2,9 +2,8 @@
 // keeps the haul in `state.pendingLoot`; Enter takes one row into the bags, a takes everything that fits, Esc
 // closes it (outdoor leftovers are gone then, an opened bag item keeps its remainder). With auto-loot on (the
 // default) fights never hold their loot and this window does not open.
-import { bold, dim, yellow, green, red, qualityPaint } from './text.mjs';
+import { bold, dim, yellow, green, red, qualityPaint, coinText } from './text.mjs';
 import { itemLines } from './tuiViews.mjs';
-import { moneyText } from '../domain/economy/money.ts';
 import { formatItemName } from '../domain/items/itemDisplayName.ts';
 import { farmNext } from './tuiFight.mjs';
 import { noteLoot } from './tuiFightPanes.mjs';
@@ -32,7 +31,7 @@ export function takeAll(app) {
   if (!app.result(r)) return;
   noteLoot(app, r.taken, r.copper);
   for (const t of r.taken) app.say(`  ${yellow('You receive')} ${app.itemLabel(t.item)}${t.count > 1 ? ` x${t.count}` : ''}`);
-  if (r.copper) app.say(`  ${yellow('You loot')} ${moneyText(r.copper)}`);
+  if (r.copper) app.say(`  ${yellow('You loot')} ${coinText(r.copper)}`);
   if (r.remaining) app.say(red(`  ${r.remaining} left in there: your bags are full.`));
   if (r.emptied && app.top()?.id === 'loot') app.pop();
 }
@@ -69,9 +68,9 @@ export function lootDialog(app) {
       const rows = [{ text: `${KIND_LABEL[L.kind] ?? L.kind}: ${L.title}`, header: true }];
       if (L.copper > 0) {
         rows.push({
-          text: yellow(moneyText(L.copper)),
-          detail: () => [bold('Money'), moneyText(L.copper)],
-          act: (a2) => { const r = a2.g.takeLootMoney(); if (a2.result(r)) { noteLoot(a2, [], r.copper); a2.say(`  ${yellow('You loot')} ${moneyText(r.copper)}`); if (r.emptied) a2.pop(); } },
+          text: coinText(L.copper),
+          detail: () => [bold('Money'), coinText(L.copper)],
+          act: (a2) => { const r = a2.g.takeLootMoney(); if (a2.result(r)) { noteLoot(a2, [], r.copper); a2.say(`  ${yellow('You loot')} ${coinText(r.copper)}`); if (r.emptied) a2.pop(); } },
         });
       }
       L.rows.forEach((r, i) => {

package/src/cli/tuiMap.mjs

@@ -0,0 +1,214 @@
+// The world map on the Travel tab: phonecraft's combined Azeroth terrain map (the picture every zone's
+// `mapPos` is measured on; scripts/bake-world-map.mjs) drawn in the detail pane with pins for where you
+// stand, the zone under the cursor and the route a journey takes between them. On the road the pin walks its
+// leg. Two packs, like the creature art: src/data/world-map.bin.gz as truecolour half-block cells (two map
+// pixels a row), or src/data/world-map-sixel.bin.br as the terminal's own pixels where it draws sixel
+// (sixel.mjs). No pack, no colour, or no room: no map, never an error.
+import { readFileSync } from 'node:fs';
+import { gunzipSync, brotliDecompressSync } from 'node:zlib';
+import { useColor, cyan, yellow, dim, vis } from './text.mjs';
+import { sixelImage, sixelOn, cellSize } from './sixel.mjs';
+
+const SMALL_URL = new URL('../data/world-map.bin.gz', import.meta.url);
+const SIXEL_URL = new URL('../data/world-map-sixel.bin.br', import.meta.url);
+
+// ---- the packs ----------------------------------------------------------------------------------------
+
+/** A pack as { w, h, pal, idx } (a palette index per pixel, every pixel drawn), or null. */
+function parse(buf) {
+  if (buf.toString('ascii', 0, 5) !== 'AZMAP' || buf[5] !== 1) return null;
+  const w = buf.readUInt16LE(6), h = buf.readUInt16LE(8), palLen = buf[10], palEnd = 11 + palLen * 3;
+  const idx = buf.subarray(palEnd, palEnd + w * h);
+  return idx.length === w * h ? { w, h, pal: buf.subarray(11, palEnd), idx } : null;
+}
+
+let small, big; // undefined: not read yet; null: not there
+function smallMap() {
+  if (small === undefined) { try { small = parse(gunzipSync(readFileSync(SMALL_URL))); } catch { small = null; } }
+  return small;
+}
+function sixelMap() {
+  if (big === undefined) { try { big = parse(brotliDecompressSync(readFileSync(SIXEL_URL))); } catch { big = null; } }
+  return big;
+}
+
+/** Is there a map to draw? */
+export const hasWorldMap = () => useColor && !!smallMap();
+
+/** The map area-averaged to tw x th, as packed rgb. */
+function resample(m, tw, th) {
+  const out = new Uint8Array(tw * th * 3), sx = m.w / tw, sy = m.h / th;
+  for (let ty = 0; ty < th; ty++) {
+    const y0 = Math.floor(ty * sy), y1 = Math.max(y0 + 1, Math.floor((ty + 1) * sy));
+    for (let tx = 0; tx < tw; tx++) {
+      const x0 = Math.floor(tx * sx), x1 = Math.max(x0 + 1, Math.floor((tx + 1) * sx));
+      let r = 0, g = 0, b = 0, n = 0;
+      for (let y = y0; y < y1 && y < m.h; y++) for (let x = x0; x < x1 && x < m.w; x++) {
+        const p = m.idx[y * m.w + x] * 3;
+        r += m.pal[p]; g += m.pal[p + 1]; b += m.pal[p + 2]; n++;
+      }
+      if (!n) continue;
+      const d = (ty * tw + tx) * 3;
+      out[d] = r / n; out[d + 1] = g / n; out[d + 2] = b / n;
+    }
+  }
+  return out;
+}
+
+// ---- what to pin -----------------------------------------------------------------------------------------
+
+/**
+ * The pins in map fractions (0..1 from the top-left, a zone's `mapPos`): `you`, walking its leg when a journey
+ * is under way; `dest`, the zone under the cursor (a journey's destination when none is given); `route`, the
+ * zones the trip passes after you, in order. `legs` is a travel preview's plan (or any list of { to }); a
+ * journey under way brings its own legs.
+ */
+function marks(app, dest, legs) {
+  const ds = app.ds, pos = (id) => ds.zone(id)?.mapPos ?? null;
+  const st = app.g.state.char.journey ? app.g.journeyStatus() : null;
+  let you = pos(app.ch.zoneId);
+  if (st) {
+    const i = st.progress.legIndex, leg = st.legs[i];
+    const a = leg ? pos(leg.from) : null, b = leg ? pos(leg.to) : null;
+    const t = leg?.seconds > 0 ? Math.min(1, Math.max(0, st.progress.legElapsedSeconds / leg.seconds)) : 1;
+    // Snapped to 1/250 of the map, so a tick that moves the pin under a pixel does not redraw (or re-encode) it.
+    you = a && b ? [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t].map((v) => Math.round(v * 250) / 250) : b ?? a ?? you;
+    legs = st.legs.slice(i);
+    dest ??= ds.zone(st.destination);
+  }
+  const route = [];
+  for (const l of legs ?? []) { const p = pos(l.to); if (p) route.push(p); }
+  return { you, dest: dest?.mapPos ?? null, route };
+}
+
+const at3 = (p) => (p ? `${p[0].toFixed(3)},${p[1].toFixed(3)}` : '-');
+
+// ---- half-block cells -------------------------------------------------------------------------------------
+
+const RESET = '\x1b[0m';
+const YOU = { glyph: '●', rgb: '255;210;60' }, DEST = { glyph: '◆', rgb: '90;220;255' }, ROUTE = { glyph: '·', rgb: '255;240;190' };
+
+/** The cells a straight line crosses between two cells (Bresenham), both ends included. */
+function lineCells([x0, y0], [x1, y1]) {
+  const out = [], dx = Math.abs(x1 - x0), dy = -Math.abs(y1 - y0), sx = x0 < x1 ? 1 : -1, sy = y0 < y1 ? 1 : -1;
+  let err = dx + dy, x = x0, y = y0;
+  for (;;) {
+    out.push([x, y]);
+    if (x === x1 && y === y1) return out;
+    const e2 = 2 * err;
+    if (e2 >= dy) { err += dy; x += sx; }
+    if (e2 <= dx) { err += dx; y += sy; }
+  }
+}
+
+/** The map as half-block lines that fit maxCols x maxRows keeping its proportions, the pins as glyphs on
+ *  their cells (the cell's own colour behind them). */
+function halfBlockLines(m, mk, maxCols, maxRows) {
+  const scale = Math.min(maxCols / m.w, (maxRows * 2) / m.h);
+  const gw = Math.max(2, Math.round(m.w * scale)), gh = Math.max(2, Math.round(m.h * scale) + 1) & ~1, rows = gh / 2;
+  const s = resample(m, gw, gh);
+  const cell = (p) => [Math.min(gw - 1, Math.floor(p[0] * gw)), Math.min(rows - 1, Math.floor(p[1] * rows))];
+  const over = new Map();
+  const pts = [mk.you, ...mk.route].filter(Boolean).map(cell);
+  for (let i = 0; i + 1 < pts.length; i++) for (const c of lineCells(pts[i], pts[i + 1])) over.set(c.join(), ROUTE);
+  if (mk.dest) over.set(cell(mk.dest).join(), DEST);
+  if (mk.you) over.set(cell(mk.you).join(), YOU);
+  const lines = [];
+  for (let y = 0; y < rows; y++) {
+    let line = '';
+    for (let x = 0; x < gw; x++) {
+      const t = (y * 2 * gw + x) * 3, u = ((y * 2 + 1) * gw + x) * 3, o = over.get(`${x},${y}`);
+      if (o) line += `\x1b[38;2;${o.rgb}m\x1b[48;2;${(s[t] + s[u]) >> 1};${(s[t + 1] + s[u + 1]) >> 1};${(s[t + 2] + s[u + 2]) >> 1}m${o.glyph}${RESET}`;
+      else line += `\x1b[38;2;${s[t]};${s[t + 1]};${s[t + 2]}m\x1b[48;2;${s[u]};${s[u + 1]};${s[u + 2]}m▀${RESET}`;
+    }
+    lines.push(line);
+  }
+  return lines;
+}
+
+const cache = new Map();
+const CACHE_MAX = 48;
+function remember(key, lines) {
+  if (cache.size >= CACHE_MAX) cache.delete(cache.keys().next().value);
+  cache.set(key, lines);
+  return lines;
+}
+
+// ---- sixel pixels ------------------------------------------------------------------------------------------
+
+const fitted = new Map(); // `${w}|${tw}x${th}` -> the map resampled to that size, kept for the next pin move
+const FIT_MAX = 4;
+
+/** The pins painted on the fitted map: a dashed route, a cyan diamond at the destination, a gold disc on you,
+ *  each with a dark rim so it reads on any terrain. Sizes follow the picture's width. */
+function paintPixels(base, tw, th, mk) {
+  const rgba = new Uint8Array(tw * th * 4);
+  for (let i = 0; i < tw * th; i++) { rgba[i * 4] = base[i * 3]; rgba[i * 4 + 1] = base[i * 3 + 1]; rgba[i * 4 + 2] = base[i * 3 + 2]; rgba[i * 4 + 3] = 255; }
+  const put = (x, y, c) => { if (x >= 0 && y >= 0 && x < tw && y < th) { const d = (y * tw + x) * 4; rgba[d] = c[0]; rgba[d + 1] = c[1]; rgba[d + 2] = c[2]; } };
+  const disc = (cx, cy, r, c) => { for (let y = Math.floor(cy - r); y <= cy + r; y++) for (let x = Math.floor(cx - r); x <= cx + r; x++) if ((x - cx) ** 2 + (y - cy) ** 2 <= r * r) put(x, y, c); };
+  const diamond = (cx, cy, r, c) => { for (let y = Math.floor(cy - r); y <= cy + r; y++) for (let x = Math.floor(cx - r); x <= cx + r; x++) if (Math.abs(x - cx) + Math.abs(y - cy) <= r) put(x, y, c); };
+  const DARK = [24, 20, 16], r = Math.max(3, tw / 90), px = (p) => [p[0] * tw, p[1] * th];
+  const pts = [mk.you, ...mk.route].filter(Boolean).map(px);
+  const dash = r * 2.2, gap = r * 1.6;
+  for (const [rad, c] of [[r / 2.6 + 1, DARK], [r / 2.6, [255, 240, 190]]]) {
+    let along = 0;
+    for (let i = 0; i + 1 < pts.length; i++) {
+      const [x0, y0] = pts[i], [x1, y1] = pts[i + 1], len = Math.hypot(x1 - x0, y1 - y0);
+      for (let d = 0; d <= len; d++) if ((along + d) % (dash + gap) < dash) disc(x0 + ((x1 - x0) * d) / len, y0 + ((y1 - y0) * d) / len, rad, c);
+      along += len;
+    }
+  }
+  if (mk.dest) { const [x, y] = px(mk.dest); diamond(x, y, r * 1.5 + 1.5, DARK); diamond(x, y, r * 1.5, [90, 220, 255]); }
+  if (mk.you) { const [x, y] = px(mk.you); disc(x, y, r + 1.5, DARK); disc(x, y, r, [255, 210, 60]); disc(x, y, r / 3, DARK); }
+  return rgba;
+}
+
+/** The map as sixel placeholder lines (sixel.mjs) fitted to maxCols x maxRows, or null when sixel is off. */
+function sixelLines(m, mk, key, maxCols, maxRows) {
+  if (!sixelOn()) return null;
+  const { w: cw, h: ch } = cellSize();
+  const scale = Math.min((maxCols * cw) / m.w, (maxRows * ch) / m.h);
+  const tw = Math.max(1, Math.round(m.w * scale)), th = Math.max(1, Math.round(m.h * scale));
+  return sixelImage(`map|${m.w}|${tw}x${th}|${key}`, () => {
+    const fitKey = `${m.w}|${tw}x${th}`;
+    let base = fitted.get(fitKey);
+    if (!base) {
+      if (fitted.size >= FIT_MAX) fitted.delete(fitted.keys().next().value);
+      fitted.set(fitKey, (base = resample(m, tw, th)));
+    }
+    return { w: tw, h: th, rgba: paintPixels(base, tw, th, mk) };
+  }, maxCols, maxRows);
+}
+
+// ---- the lines a pane draws ---------------------------------------------------------------------------------
+
+/**
+ * The world map for a detail pane, as lines no wider than `maxCols` and no more than `maxRows` of them (the
+ * last a legend): you pinned where you stand, `dest` (a zone) pinned if given, the `legs` of a planned trip
+ * (or the journey under way) drawn as a route. Null without colour, a pack, a position, or room.
+ */
+export function worldMapLines(app, { dest = null, legs = null, maxCols, maxRows } = {}) {
+  if (!useColor || !(maxCols >= 10) || !(maxRows >= 6)) return null;
+  const m = smallMap();
+  if (!m) return null;
+  const mk = marks(app, dest, legs);
+  if (!mk.you && !mk.dest) return null;
+  const key = [mk.you, mk.dest, ...mk.route].map(at3).join('|');
+  const rows = maxRows - 1;
+  let art = sixelLines(sixelMap() ?? m, mk, key, maxCols, rows);
+  if (!art) {
+    const ck = `${maxCols}x${rows}|${key}`;
+    art = cache.get(ck) ?? remember(ck, halfBlockLines(m, mk, maxCols, rows));
+  }
+  const legend = `${yellow(YOU.glyph)} you${mk.dest ? `  ${cyan(DEST.glyph)} destination` : ''}${mk.route.length ? dim('  ┄ route') : ''}`;
+  return [...art, legend];
+}
+
+/** `lines` with the map under them, as large as the detail pane has room for; `lines` alone when there is none. */
+export function withWorldMap(app, lines, opts = {}) {
+  const L = app.layout?.();
+  if (!L || !(L.detailW > 2)) return lines;
+  const w = L.detailW - 2, used = lines.reduce((n, l) => n + Math.max(1, Math.ceil(vis(l) / w)), 0);
+  const map = worldMapLines(app, { ...opts, maxCols: w, maxRows: L.mainH - used - 1 });
+  return map ? [...lines, '', ...map] : lines;
+}