azeroth-shell 0.2.0 → 0.4.0

package/src/cli/tuiDungeon.mjs

@@ -3,14 +3,14 @@
 // stops, gates, chests and NPCs; Enter on an unlocked stop fights it live with the squad. Ports phonecraft
 // instanceView.ts (the entry card), liveDungeonHeadless.ts (pulls, gates, rest, Finish instantly) and the
 // floor's object clicks (liveObjectLoot.ts) onto the sequential route.
-import { bold, dim, cyan, yellow, green, red, gray, qualityPaint, fit, plural, secondsText, wrapLines, itemText } from './text.mjs';
+import { bold, dim, cyan, yellow, green, red, gray, qualityPaint, fit, plural, secondsText, wrapLines, itemText, coinText } from './text.mjs';
 import { openFloor } from './tuiFloor.mjs';
 import { startFight } from './tuiFight.mjs';
 import { noteLoot } from './tuiFightPanes.mjs';
 import { prePull } from './squad.mjs';
+import { prepOoc, prepText } from './oocPrep.mjs';
 import { questDialog } from './tuiViews.mjs';
 import { nextDoQuestStep } from '../domain/quests/doQuest.ts';
-import { moneyText } from '../domain/economy/money.ts';
 import { maxHealth } from '../domain/character/character.ts';
 import { bagCapacity } from '../domain/items/equipment.ts';
 import { companionLevel, companionCharacter } from '../domain/bots/squad.ts';
@@ -27,10 +27,12 @@ import { isSkippableBeginFailure } from '../engine/game/types.ts';
 import {
   instancePortals, routeEncounterList, routeEncounterIdList, encounterOf, isCleared, isUnlocked, nextEncounter,
   isComplete, requiredFlags, hasFlag, routeBossProgress, applyEncounterCleared, autoAdvanceRouteGates,
-  itemDropsInsideInstance, lockRemainingMs, restoreSavedRun,
+  itemDropsInsideInstance, lockRemainingMs, restoreSavedRun, canEnter, NORMAL_INSTANCE_RESET_TIME_MS,
 } from '../world/instances.ts';
 import { instanceObjectPins, lootObjectPins, objectGatesFor } from '../world/instanceObjects.ts';
 import { dungeonNpcsForMap } from '../data/dungeonSpawns.ts';
+import { extraEntrancesForInstance } from '../data/dungeons/pack-from-clusters.ts';
+import { buildEntryLockInputs } from '../domain/run/canEnterContext.ts';
 import { getDungeonGameObject } from '../data/dungeonGameObjects.ts';
 import { countRouteTrash, selectRouteEncounters, DEFAULT_ROUTE_DENSITY, DEFAULT_PULL_FUSION } from '../world/dungeonRoute.ts';
 import { WIPE_RETRY_PER_PULL, WIPE_CAP_PER_RUN } from '../world/dungeonPreset.ts';
@@ -45,6 +47,12 @@ const hasOwned = (app) => (entry) => countItem(ownedInventory(app.g.state.invent
 const bagCapacityOf = (app) => bagCapacity(app.ch, app.ds);
 const isRaid = (def) => (def.maxPlayers ?? 5) > 5;
 
+/** Inside a run whose every required stop is down: nothing left but the way out. */
+export function runCleared(app) {
+  const def = runDef(app);
+  return !!def && isComplete(def, app.g.state.instance);
+}
+
 /** Bodies in a stop: the pack's counts, or the primary alone. */
 function packSize(enc) {
   const n = (enc.pack ?? []).reduce((s, m) => s + (m.count ?? 1), 0);
@@ -53,48 +61,96 @@ function packSize(enc) {
 
 // ---- portals and entry ------------------------------------------------------------------------------------
 
+/** The engine's own door check (level, attunement, key, quest chain, lockout), so the row says no before Enter does. Ref worldView.ts:626. */
+function entryCheck(app, def, now = Date.now()) {
+  const g = app.g;
+  return canEnter(def, app.ch.level, g.state.lockouts ?? {}, now, { teleports: app.ds.areatriggerTeleports(), instanceSaves: g.state.instanceSaves, ...buildEntryLockInputs(g.state, def.name) });
+}
+
+/** The other doors into this instance (Maraudon's orange side, Gnomeregan's train depot, Uldaman's back door...). */
+const extraDoors = (def) => extraEntrancesForInstance(def.id).map((row) => ({ id: row.id, name: String(row.name ?? '').replace(/\s*-\s*Entering.*$/i, '').trim() || def.name }));
+
 function lockText(app, def, now = Date.now()) {
   const g = app.g;
   const held = restoreSavedRun(g.state.instanceSaves, def.id, now);
   const lock = lockRemainingMs(g.state.lockouts ?? {}, def.id, now);
   if (held) {
     const left = (g.state.instanceSaves?.[def.id]?.expiresAtMs ?? now) - now;
+    if (isComplete(def, held)) return green(`cleared, resets in ${secondsText(left)}`);
     return yellow(`your run is held, ${held.defeated.length} cleared, ${secondsText(left)} left`);
   }
   if (lock > 0) return red(`saved, ${secondsText(lock)} left`);
   return '';
 }
 
-/** World tab rows: the instance portals in this zone. */
+/** World tab rows: the instance portals in this zone, the one you are in among them. */
 export function portalRows(app) {
   const g = app.g, ds = app.ds, ch = app.ch;
-  const rows = [];
-  if (g.state.instance) {
-    const def = runDef(app);
-    rows.push(H(''), H('Dungeon'), { text: `${green('▶')} Back into ${bold(def?.name ?? g.state.instance.dungeonId)}`, detail: () => [bold(def?.name ?? ''), 'You are inside this dungeon.', '', dim('Enter: the run window')], act: () => openRun(app) });
-    return rows;
-  }
+  const inside = runDef(app);
   const portals = instancePortals(ds, ch.zoneId).filter((d) => !d.id.startsWith('alterac'));
-  if (!portals.length) return rows;
-  rows.push(H(''), H(`Dungeons (${portals.length})`));
+  // The run you are in is listed even when its door is in another zone.
+  if (inside && !portals.some((d) => d.id === inside.id)) portals.unshift(inside);
+  if (!portals.length) return [];
+  const rows = [H(''), H(`Dungeons (${portals.length})`)];
   for (const def of portals) {
-    const low = ch.level < def.minLevel;
+    const range = dim(`L${def.levelRange[0]}-${def.levelRange[1]}${isRaid(def) ? `  ${def.maxPlayers}-man raid` : ''}`);
+    if (def.id === inside?.id) {
+      rows.push({ text: `${cyan(def.name)} ${range}  ${green('▶ you are in it')}`, data: { dungeon: def }, detail: () => portalLines(app, def), act: () => openRun(app) });
+      continue;
+    }
+    const chk = entryCheck(app, def);
+    const low = !chk.ok && !restoreSavedRun(g.state.instanceSaves, def.id, Date.now());
     const lock = lockText(app, def);
     rows.push({
-      text: `${low ? dim(def.name) : cyan(def.name)} ${dim(`L${def.levelRange[0]}-${def.levelRange[1]}${isRaid(def) ? `  ${def.maxPlayers}-man raid` : ''}`)}${low ? red(`  requires ${def.minLevel}`) : ''}${lock ? `  ${lock}` : ''}`,
+      text: `${low ? dim(def.name) : cyan(def.name)} ${range}${low && !lock ? red(`  ${chk.reason ?? `requires ${def.minLevel}`}`) : ''}${lock ? `  ${lock}` : ''}`,
       data: { dungeon: def },
       detail: () => portalLines(app, def),
-      act: () => app.push(entryDialog(app, def)),
+      act: () => goToDungeon(app, def),
     });
   }
   return rows;
 }
 
+/** Enter on a portal: out of the run you are in (it is held), then straight back into a run you left
+ *  half done, or the entry card for a fresh one. */
+function goToDungeon(app, def) {
+  if (app.g.state.instance) {
+    const was = runDef(app);
+    if (!app.result(app.g.leaveInstance(Date.now()), `You leave ${was?.name ?? 'the dungeon'}.`)) return;
+    app.dungeonPulls = [];
+    app.floor = null;
+    app.stack = [];
+  }
+  const held = restoreSavedRun(app.g.state.instanceSaves, def.id, Date.now());
+  if (held && !isComplete(def, held)) enter(app, def, { routeDensity: held.routeDensity ?? DEFAULT_ROUTE_DENSITY, asRaid: isRaid(def), door: null });
+  else app.push(entryDialog(app, def));
+}
+
+// A 5-man you walk out of stays as you left it for two hours here, not the engine's 30 minutes
+// (NORMAL_INSTANCE_RESET_TIME): time to hearth, sell, repair and come back. Raids keep their lockout.
+const RUN_HOLD_MS = 2 * 60 * 60 * 1000;
+
+/** After every action: when the run you were in is gone (leave, hearth, taxi, another door), stretch its hold. */
+export function holdRunLonger(app) {
+  const g = app.g;
+  if (!g) { app.inRunId = null; return; }
+  const was = app.inRunId, now = g.state.instance?.dungeonId ?? null;
+  app.inRunId = now;
+  if (!was || was === now) return;
+  const def = app.ds.instance(was), save = g.state.instanceSaves?.[was];
+  if (!def || def.lockoutMs > 0 || !save) return;
+  g.state.instanceSaves = { ...g.state.instanceSaves, [was]: { ...save, expiresAtMs: save.expiresAtMs - NORMAL_INSTANCE_RESET_TIME_MS + RUN_HOLD_MS } };
+  const i = g.state.activity.findIndex((l, j) => j < 5 && l.endsWith('It resets in 30 minutes.'));
+  if (i >= 0) g.state.activity[i] = g.state.activity[i].replace('30 minutes', '2 hours');
+}
+
 function portalLines(app, def) {
   const bosses = def.encounters.filter((e) => e.kind === 'boss');
   const out = [bold(def.name), dim(`levels ${def.levelRange[0]}-${def.levelRange[1]}, requires ${def.minLevel}${isRaid(def) ? `, ${def.maxPlayers} players` : ''}`)];
   const lock = lockText(app, def);
   if (lock) out.push(lock);
+  const chk = entryCheck(app, def);
+  if (!chk.ok && !lock) out.push(red(chk.reason ?? 'You cannot enter yet.'));
   out.push('', cyan(`Bosses (${bosses.length})`), ...bosses.slice(0, 14).map((b) => `  ${b.name}`), ...(bosses.length > 14 ? [dim(`  and ${bosses.length - 14} more`)] : []));
   out.push('', dim('Enter: route, party and supplies, then go in'));
   return out;
@@ -102,7 +158,8 @@ function portalLines(app, def) {
 
 /** The card before the door: route density, party or raid, food and water, Enter. */
 export function entryDialog(app, def) {
-  const opts = { routeDensity: DEFAULT_ROUTE_DENSITY, asRaid: isRaid(def) };
+  const opts = { routeDensity: DEFAULT_ROUTE_DENSITY, asRaid: isRaid(def), door: null };
+  const doors = extraDoors(def);
   return {
     id: `enter-${def.id}`, title: def.name, hint: 'Enter: choose',
     rows(a) {
@@ -110,10 +167,13 @@ export function entryDialog(app, def) {
       const squad = g.state.squad ?? [];
       const rows = [H(`${bold(def.name)}  ${dim(`L${def.levelRange[0]}-${def.levelRange[1]}`)}  ${lockText(a, def)}`), H('')];
       const held = restoreSavedRun(g.state.instanceSaves, def.id, Date.now());
-      if (held) rows.push(H(yellow(`Your earlier run is held: ${held.defeated.length} stops cleared. Entering continues it.`)), H(''));
-      rows.push({ text: green(held ? 'Go back in' : 'Enter the dungeon'), detail: () => [bold('Enter'), '', `${opts.routeDensity === 'full' ? 'Every pack on the way' : 'Bosses and what guards them'}; ${opts.asRaid ? 'as a raid, the bench comes too' : `you and ${plural(squad.length, 'companion')}`}.`], act: () => enter(a, def, opts) });
+      const heldDone = held && isComplete(def, held);
+      if (heldDone) rows.push(H(green('You cleared it. The halls stay empty until it resets.')), H(''));
+      else if (held) rows.push(H(yellow(`Your earlier run is held: ${held.defeated.length} stops cleared. Entering continues it.`)), H(''));
+      rows.push({ text: heldDone ? dim('Go back in (nothing left to fight)') : green(held ? 'Go back in' : 'Enter the dungeon'), detail: () => [bold('Enter'), '', `${opts.routeDensity === 'full' ? 'Every pack on the way' : 'Bosses and what guards them'}; ${opts.asRaid ? 'as a raid, the bench comes too' : `you and ${plural(squad.length, 'companion')}`}.`], act: () => enter(a, def, opts) });
       const pace = (d) => ({ text: `Route: ${cyan(d === 'full' ? 'Full' : 'Bosses')}`, detail: () => [bold('Route density'), '', 'Bosses: the bosses and the packs that stand in their way.', 'Full: every pack in the dungeon.', '', dim('Enter: switch')], act: () => { opts.routeDensity = opts.routeDensity === 'full' ? 'bosses' : 'full'; } });
       rows.push(pace(opts.routeDensity));
+      if (doors.length) { const all = [null, ...doors]; rows.push({ text: `Door: ${cyan(opts.door?.name ?? 'Main entrance')}`, detail: () => [bold('Which door'), '', 'Some instances have more than one way in; each starts you at its own end of the route.', ...doors.map((d) => `  ${d.name}`), '', dim('Enter: next door')], act: () => { opts.door = all[(all.indexOf(opts.door) + 1) % all.length]; } }); }
       rows.push({ text: `Group: ${cyan(opts.asRaid ? 'Raid' : 'Party')}`, detail: () => [bold('Party or raid'), '', 'Party: you and the up to four companions you have seated.', `Raid: the bench comes too, up to ${(def.maxPlayers ?? 5) - 1} companions.`, '', dim('Enter: switch')], act: () => { opts.asRaid = !opts.asRaid; } });
       const walk = walkingIn(g, def, opts.asRaid);
       rows.push({ text: `Who walks in: ${cyan(`${walk.ids.length} of ${walk.cap}`)}${walk.picked ? '' : dim('  (auto)')}`, detail: () => [bold('Who walks in'), '', 'Pick from every companion you own, or Fill to match what this instance wants.', '', dim('Enter: pick')], act: () => a.push(rosterDialog(a, def, () => opts.asRaid)) });
@@ -131,7 +191,7 @@ export function entryDialog(app, def) {
 }
 
 function enter(app, def, opts) {
-  const r = app.g.enterInstance(def.id, Date.now(), { routeDensity: opts.routeDensity, asRaid: opts.asRaid });
+  const r = app.g.enterInstance(def.id, Date.now(), { routeDensity: opts.routeDensity, asRaid: opts.asRaid, ...(opts.door ? { entranceTriggerId: opts.door.id } : {}) });
   if (!app.result(r, `You enter ${def.name}.`)) return;
   app.dungeonPulls = [];
   app.stack = [];
@@ -141,17 +201,17 @@ function enter(app, def, opts) {
 // Food and water before the door: who is short, the vendor ladder, what it costs (runSupplyPanel.ts).
 function supplyRows(app) {
   const plan = app.g.runSupplyPlan();
-  const rows = [H(''), H(`Food and water ${dim(plan.mage ? '(a mage conjures both on the way)' : plan.rows.length ? `${moneyText(plan.cost)} for everyone` : 'everyone has enough')}`)];
+  const rows = [H(''), H(`Food and water ${dim(plan.mage ? '(a mage conjures both on the way)' : plan.rows.length ? `${coinText(plan.cost)} for everyone` : 'everyone has enough')}`)];
   if (plan.mage || !plan.rows.length) return rows;
   for (const r of plan.rows) {
     const rung = r.ladder[r.rung];
-    rows.push(H(`  ${fit(r.memberName, 12)} ${fit(r.kind, 6)} ${dim(`has ${r.have}, short ${r.short}`)}  ${itemText(rung?.item, '?')} x${r.units}  ${yellow(moneyText(r.cost))}`));
+    rows.push(H(`  ${fit(r.memberName, 12)} ${fit(r.kind, 6)} ${dim(`has ${r.have}, short ${r.short}`)}  ${itemText(rung?.item, '?')} x${r.units}  ${coinText(r.cost)}`));
   }
   const buys = supplyBuys(plan.rows, app.ch.gold, true);
   rows.push({
-    text: buys.length ? `Buy them ${yellow(`(${moneyText(buys.reduce((s, b) => s + b.cost, 0))})`)}` : dim('Buy them (not enough gold)'),
+    text: buys.length ? `Buy them ${yellow(`(${coinText(buys.reduce((s, b) => s + b.cost, 0))})`)}` : dim('Buy them (not enough gold)'),
     detail: () => [bold('Buy supplies'), '', 'The vendor price, straight into each member\'s own bags. What does not fit is left out.', ...(plan.full.length ? ['', yellow(`Bags full: ${plan.full.map((f) => f.name).join(', ')}`)] : [])],
-    act: () => { if (!buys.length) { app.flashMsg('Not enough gold for any of it.'); return; } const r = app.g.buyRunSupplies(buys); app.result(r, r.ok ? `Bought ${r.units} food and water for ${moneyText(r.spent)}.` : ''); },
+    act: () => { if (!buys.length) { app.flashMsg('Not enough gold for any of it.'); return; } const r = app.g.buyRunSupplies(buys); app.result(r, r.ok ? `Bought ${r.units} food and water for ${coinText(r.spent)}.` : ''); },
   });
   return rows;
 }
@@ -280,7 +340,7 @@ function openChest(app, pin) {
   app.say(`You open ${pin.name}.${r.loot.length ? '' : ' It is empty.'}`);
   if (took.ok) noteLoot(app, took.taken, took.copper);
   for (const d of took.ok ? took.taken : []) app.say(`  ${yellow('You receive')} ${app.itemLabel(d.item)}${d.count > 1 ? ` x${d.count}` : ''}`);
-  if (took.ok && took.copper) app.say(`  ${yellow('You receive')} ${moneyText(took.copper)}`);
+  if (took.ok && took.copper) app.say(`  ${yellow('You receive')} ${coinText(took.copper)}`);
   if (took.ok && took.remaining) app.say(red(`  ${plural(took.remaining, 'item')} did not fit in your bags.`));
   return true;
 }
@@ -362,7 +422,7 @@ export function runView(app) {
       F: { hint: 'finish instantly', fn: (a) => a.confirm('Run every remaining stop now, without watching?', () => finishInstantly(a)) },
       L: { hint: 'leave', fn: (a) => leaveRun(a) },
       P: { hint: 'blessings', fn: (a) => a.push(paladinDialog(a)) },
-      R: { hint: 'reset', fn: (a) => a.confirm('Reset the run? Every stop comes back.', () => { const id = a.g.state.instance?.dungeonId; if (a.result(a.g.resetInstance(), 'The dungeon resets.')) { a.dungeonPulls = []; a.floor = null; if (a.floorKills && id) delete a.floorKills[id]; } }) },
+      R: { hint: 'reset', fn: (a) => a.confirm('Reset the run? Every stop comes back.', () => { if (a.result(a.g.resetInstance(), 'The dungeon resets.')) { a.dungeonPulls = []; a.floor = null; } }) },
     },
     rows(a) {
       const g = a.g, run = g.state.instance, def = runDef(a);
@@ -391,7 +451,7 @@ export function runView(app) {
       }
       for (const o of objects.get('_') ?? []) rows.push({ ...objectRow(a, def, o), data: { object: o } });
       rows.push(H(''), { text: `Walk the floor  ${dim('go anywhere; patrols and packs you pass pull on their own (W)')}`, detail: () => [bold('The floor'), '', 'Instead of picking stops, walk the dungeon on its nav mesh. Patrols walk their routes, and whatever sees you on the way pulls.'], act: () => openFloor(a) });
-      rows.push({ text: dim('Leave the dungeon'), detail: () => [bold('Leave'), '', isRaid(def) ? 'A raid holds your progress until the lockout resets.' : 'A 5-man holds your progress for 30 minutes.'], act: () => leaveRun(a) });
+      rows.push({ text: dim('Leave the dungeon'), detail: () => [bold('Leave'), '', isRaid(def) ? 'A raid holds your progress until the lockout resets.' : 'A 5-man holds your progress for 2 hours.'], act: () => leaveRun(a) });
       return rows;
     },
   };
@@ -399,13 +459,15 @@ export function runView(app) {
 
 // ---- pulls ---------------------------------------------------------------------------------------------
 
-/** Pull one stop. `floor`: the continuous floor's pull (no sequential lock: you walked into it); `onDone(r)`
- *  runs after the fight with its outcome (null when you ran). */
-export function pullStop(app, def, enc, { floor = false, onDone, onTick } = {}) {
+/** Pull one stop. `floor`: the continuous floor's pull (no sequential lock: you walked into it); `ready`: buff
+ *  and rest first, a pull you chose (a floor pack that saw you is already on you); `onDone(r)` runs after the
+ *  fight with its outcome (null when you ran). */
+export function pullStop(app, def, enc, { floor = false, ready = !floor, onDone, onTick } = {}) {
   const run = app.g.state.instance;
   if (!run) return;
   if (isCleared(run, enc.id)) { app.flashMsg(`${enc.name} is already cleared.`); return; }
   if (!floor && !isUnlocked(def, run, enc.id)) { app.flashMsg(`${enc.name} is locked.`); return; }
+  if (ready) readyUp(app);
   for (const l of prePull(app.g, app.ds, app.cmds.buffPace)) app.say(cyan(l));
   let playerMax = 0, session = null;
   const f = startFight(app, enc.creatureEntry, {
@@ -458,16 +520,34 @@ function recordPull(app, def, enc, r, playerMax, session, downtimeSec) {
   });
 }
 
-/** Between pulls: eat and drink from the bags to the squad strategy's rest line, then sit (betweenPullRest.ts). */
-export function restBetween(app, seconds) {
+/** Eat and drink from the bags, then sit, up to the squad strategy's rest line (betweenPullRest.ts). */
+function eatAndDrink(app) {
   const g = app.g;
   const r = betweenPullConsumeLoop({ char: g.state.char, inventory: g.state.inventory, ds: app.ds, strategy: g.state.squadStrategy, deathFlow: g.state.deathFlow });
   g.state.char = r.char; g.state.inventory = r.inventory;
+  app.dungeonDowntime = (app.dungeonDowntime ?? 0) + r.seconds;
+  return r;
+}
+
+/** Between pulls: eat and drink to the rest line, then sit. */
+export function restBetween(app, seconds) {
+  const r = eatAndDrink(app);
   app.idleTick(seconds, true);
-  app.dungeonDowntime = (app.dungeonDowntime ?? 0) + r.seconds + seconds;
+  app.dungeonDowntime += seconds;
   app.say(dim(`The party rests${r.seconds ? ` and eats (${Math.round(r.seconds)} s)` : ''}.  HP ${app.hpText()}  ${app.pwText()}`));
 }
 
+/** Before a pull you chose: the buffs phase cast standing still, then eat and drink back to the rest line, as
+ *  runFullDungeon rests between pulls. Pulling on the mana the armour, Intellect and conjures just took sent
+ *  a level 20 mage in at 761 of 1966, and nothing between stops gave it back. */
+export function readyUp(app) {
+  const buffed = prepText(prepOoc(app.g, app.ds));
+  if (buffed) app.say(cyan(buffed));
+  const r = eatAndDrink(app);
+  if (r.seconds > 0) app.say(dim(`The party rests before the pull (${Math.round(r.seconds)} s).  HP ${app.hpText()}  ${app.pwText()}`));
+  for (const m of r.messages) if (/^Out of /.test(m)) app.say(yellow(`  ${m}.`));
+}
+
 /** Open gates that need no item, and route flags the density skipped (liveDungeonHeadless.ts autoFireGates). */
 function autoFireGates(app) {
   const g = app.g, ds = app.ds, inst = g.state.instance;
@@ -576,7 +656,7 @@ export function summaryView(app, s) {
       const deaths = s.pulls.filter((p) => p.outcome === 'defeat').length;
       const rows = [H(`${bold(s.dungeonName)}  ${tag}`), H('')];
       rows.push(H(`  ${s.encountersCleared}/${s.encounterTotal} stops, bosses ${s.bossesDown}/${s.bossTotal}, ${plural(s.pulls.length, 'pull')}, ${plural(deaths, 'wipe')}`));
-      rows.push(H(`  ${secondsText(s.combatMs)} fighting, ${secondsText(s.downtimeSec * 1000)} resting   +${s.totalXp} xp   ${moneyText(s.totalGold) || '0c'}`));
+      rows.push(H(`  ${secondsText(s.combatMs)} fighting, ${secondsText(s.downtimeSec * 1000)} resting   +${s.totalXp} xp   ${coinText(s.totalGold)}`));
       if (s.stopReason) rows.push(H(red(`  Stopped: ${s.stopReason}`)));
       if (s.memberTotals?.length) {
         const secs = Math.max(1, s.combatMs / 1000);

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`);