azeroth-shell 0.2.0 → 0.4.0

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;
+}

package/src/cli/tuiPaperdoll.mjs

@@ -1,4 +1,4 @@
-// The Gear tab as a character sheet: you in your gear in the middle, the worn pieces' icons down both sides
+// The Character tab as a sheet: you in your gear in the middle, the worn pieces' icons down both sides
 // the way the client's paperdoll lays them out (head to wrists on the left, hands to trinkets on the right,
 // the weapons and the bag bar underneath), each framed in its quality colour. Arrows move between the
 // slots (Up and Down in order, Shift+arrows across the picture), the detail pane is the piece's tooltip, and Enter, x and r act on the slot as they do in the list.
@@ -35,7 +35,7 @@ function sheetSize(w, h, extras) {
   return null;
 }
 
-/** Will the Gear tab draw as the sheet right now? `extras` is how many rows follow the slots. */
+/** Will the Character tab draw as the sheet right now? `extras` is how many rows follow the slots. */
 export function paperdollPlan(app, extras) {
   if (!iconsOn()) return null;
   const L = app.layout();
@@ -44,9 +44,10 @@ export function paperdollPlan(app, extras) {
 
 /**
  * The sheet's lines for the gear view's `rows` in a `W` x `H` pane, with `body(cols, lines)` drawing the
- * character (playerArt), plus where the arrows go; null when it does not fit.
+ * character (playerArt) and `title` heading it, plus where the arrows go; null when it does not fit. `hint`
+ * replaces the keys line (a companion's sheet has no repair or outfits).
  */
-export function paperdollGrid(app, rows, W, H, body) {
+export function paperdollGrid(app, rows, W, H, body, title, hint) {
   const extraRows = rows.map((r, i) => ({ r, i })).filter(({ r }) => !r.cell && !r.header);
   const plan = iconsOn() ? sheetSize(W, H, extraRows.length) : null;
   if (!plan) return null;
@@ -58,7 +59,7 @@ export function paperdollGrid(app, rows, W, H, body) {
   const top = 2, colH = SIDE * ch;
 
   const ups = rows.filter((r) => r.cell?.up).length;
-  cv.text(1, 0, `${bold('Equipment')}   ${ups ? green(`▲ ${plural(ups, 'upgrade')} in your bags   u: put on all`) : dim(`Shift+arrows: move on the sheet   Enter: change${plan.extras ? '' : '   R: repair all   o: outfits'}`)}`);
+  cv.text(1, 0, `${title ?? bold('Equipment')}   ${ups ? green(`▲ ${plural(ups, 'upgrade')} in your bags   u: put on all`) : dim(hint ?? `s: stats   Shift+arrows: move   Enter: change${plan.extras ? '' : '   R: repair all   o: outfits'}`)}`);
 
   // Labels take a share of the width beside each column; the body gets the middle.
   const lw = Math.max(0, Math.min(22, Math.floor((W - 2 * cw) * 0.28)));

package/src/cli/tuiPartyStage.mjs

@@ -10,7 +10,7 @@ import { dim, gray, fit } from './text.mjs';
 import { SIZES, canvas, put, putLines, putRight, floorLine, narrowPlate, narrowState, auraRows, putMissiles, putPopsAbove, POP_MS, LUNGE_MS } from './tuiStage.mjs';
 import { creatureArt, artWidth } from './modelArt.mjs';
 import { paperdollArt } from './paperdoll.mjs';
-import { playerArt } from './tuiViews.mjs';
+import { playerArt, wornNow, wornArt } from './tuiViews.mjs';
 import { iconsOn } from './iconArt.mjs';
 import { allyIndexOfSide } from '../engine/core/events.ts';
 import { combatDistanceYd, DEFAULT_OPEN_YD, MELEE_CONTACT_YD } from '../engine/combat/combatGeometry.ts';
@@ -19,6 +19,7 @@ const GAP = 1;        // columns between two columns of the same side
 const LANE = 6;       // columns kept open between a party column and a foe column, for the glyphs that cross
 const PLATE_MIN = 9;  // a plate's narrowest: a 5-cell bar and "100%"
 const PLATE_FULL = 14; // and its widest when the stage has width to spare: a 10-cell bar, a 12-letter name
+const SWAP_YD = 2;    // how much clearer of a neighbour a unit must be, in yards, before the two trade places
 const SIZE_ORDER = ['xs', 's', 'm', 'l'];
 // Who stands nearest the foes among units on the same spot (the melee pile opens on one): the healer last.
 const ROLE_RANK = { healer: 0, damage: 2, tank: 3 };
@@ -31,12 +32,13 @@ function companionOf(app, v) {
   return byIndex?.name === v.name ? byIndex : squad.find((c) => c.name === v.name) ?? byIndex;
 }
 
-/** A unit's sprite in a box: you in your gear, a creature by its display id, a companion in its gear. */
+/** A unit's sprite in a box: you or a companion in your form or gear, a creature by its display id. */
 function spriteOf(app, u, cols, rows) {
-  if (u.isPlayer) return playerArt(app, cols, rows)?.lines ?? null;
+  if (u.isPlayer) return playerArt(app, cols, rows, u.v)?.lines ?? null;
   if (u.v.creatureEntry != null) return creatureArt(app.ds.creature(u.v.creatureEntry)?.displayId, cols, rows);
   const comp = u.friend ? companionOf(app, u.v) : null;
-  return comp ? paperdollArt(comp, cols, rows) : null;
+  if (!comp) return null;
+  return wornArt(wornNow(app.ds, comp, u.v), cols, rows) ?? paperdollArt(comp, cols, rows);
 }
 
 /** The box a unit gets when the big ones get `size`: pets a size under, a boss a size over. */
@@ -106,8 +108,10 @@ export function partyStage(app, ctl, W, H, { inline }) {
   // a mob that runs onto the healer crosses to the lane while the healer stays put, and a mage walking into
   // range slides in while its mob stands. Melee units park all round a mob, so this is read off distances, not
   // bearings: a rogue behind its target still stands on the party's side.
+  // A corpse, or a body with nobody living left to measure against (the last foe falls, the win holds), stays
+  // where it last stood: without this the whole party walks back to where it opened under the loot.
   const posOf = (u) => s.unitPosYd?.(u.key);
-  mem.openPos ??= new Map(); mem.openD ??= new Map();
+  mem.openPos ??= new Map(); mem.openD ??= new Map(); mem.lastC ??= new Map();
   const nearest = (u) => {
     let best = null;
     for (const o of units) {
@@ -131,7 +135,12 @@ export function partyStage(app, ctl, W, H, { inline }) {
     const c0 = 1 - frac(mem.openD.get(u.key));
     return Math.max(0, Math.min(1, c0 + (1 - frac(n.d) - c0) * share));
   };
-  for (const col of cols) col.c = closingOf(col);
+  for (const col of cols) {
+    const held = mem.lastC.get(col.key);
+    if (held != null && (col.v.hp <= 0 || !near.get(col.key))) { col.c = held; continue; }
+    col.c = closingOf(col);
+    mem.lastC.set(col.key, col.c);
+  }
   // The party's half and the pack's, the free width shared by head count, the lane between. In each half the
   // columns stand by their closing, the nearest to the lane innermost; on the same spot the healer, the
   // ranged, the melee, then the tank, and the foe you face before the rest. Then nobody overlaps: a column
@@ -145,6 +154,26 @@ export function partyStage(app, ctl, W, H, { inline }) {
   const q = (col) => Math.round(col.c * 50);
   friends.sort((a, b) => q(a) - q(b) || a.order - b.order);
   foes.sort((a, b) => q(b) - q(a) || a.order - b.order);
+  // The lineup holds: two neighbours trade places only when one is more than SWAP_YD clearer of the other, so a
+  // melee pile that jitters by a yard does not flicker. A newcomer takes its sorted slot; the rest keep last
+  // frame's order among theirs, then adjacent pairs out of order by more than the leeway swap until none are.
+  mem.lineup ??= new Map();
+  const leeway = SWAP_YD / Math.max(1, mem.openYd - MELEE_CONTACT_YD);
+  const hold = (list, key) => {
+    const known = list.filter((col) => mem.lineup.has(col.key)).sort((a, b) => mem.lineup.get(a.key) - mem.lineup.get(b.key));
+    let k = 0;
+    for (let i = 0; i < list.length; i++) if (mem.lineup.has(list[i].key)) list[i] = known[k++];
+    for (let swapped = true; swapped;) {
+      swapped = false;
+      for (let i = 0; i + 1 < list.length; i++) {
+        if (key(list[i]) - key(list[i + 1]) <= leeway) continue;
+        [list[i], list[i + 1]] = [list[i + 1], list[i]]; swapped = true;
+      }
+    }
+    list.forEach((col, i) => mem.lineup.set(col.key, i));
+  };
+  hold(friends, (col) => col.c);
+  hold(foes, (col) => -col.c);
   const place = (list, L, R) => {
     for (const col of list) col.x = col.friend ? L + col.c * (R - col.cw - L) : R - col.cw - col.c * (R - col.cw - L);
     for (let i = 1; i < list.length; i++) list[i].x = Math.max(list[i].x, list[i - 1].x + list[i - 1].cw + GAP);
@@ -164,7 +193,7 @@ export function partyStage(app, ctl, W, H, { inline }) {
       putLines(c, col.ax, col.top, col.art);
     }
     putLines(c, col.x, zone, narrowPlate(app, v, { ...col, dead, w: col.cw }));
-    const state = narrowState(v, now, col.cw);
+    const state = narrowState(v, now, col.cw, mem.casts?.get(col.key));
     if (state) put(c, col.x, stateRow, state);
     if (showAuras && !col.small && !dead) putLines(c, col.x, auraTop, auraRows(app, mem, v, col.key, col.cw, icons));
     putPopsAbove(c, col, (mem.pops.get(col.key) ?? []).filter((p) => now - p.t < POP_MS), now, zone);

package/src/cli/tuiPet.mjs

@@ -1,9 +1,8 @@
 // Your pet (hunter, warlock): the page with command, react, food and abilities; the stable; the pet trainer.
 // Ports phonecraft playChrome.ts's feed modal, render/petBar.ts, panels/stablePanel.ts and the pet trainer rows.
-import { bold, dim, cyan, yellow, green, red, itemText } from './text.mjs';
+import { bold, dim, cyan, yellow, green, red, itemText, coinText } from './text.mjs';
 import { itemLines, spellLines } from './tuiViews.mjs';
-import { moneyText } from '../domain/economy/money.ts';
-import { LOYALTY_NAMES, petHasHappiness, petKnownSpells, petAutocastOn } from '../domain/pet/pet.ts';
+import { LOYALTY_NAMES, HAPPINESS_MAX, petHasHappiness, petKnownSpells, petAutocastOn } from '../domain/pet/pet.ts';
 import { MAX_PET_STABLES, STABLE_SLOT_PRICES } from '../domain/pet/petStable.ts';
 import { zonePetTrainers } from '../world/world.ts';
 import { MAX_SOUL_SHARD_CAP } from '../autopilot/config.ts';
@@ -15,7 +14,7 @@ export const hasPetClass = (app) => app.ch.cls === HUNTER || app.ch.cls === WARL
 function petStatus(app, pet) {
   const cdef = app.ds.creature(pet.creature);
   const bits = [`${pet.health <= 0 ? red('dead') : `${pet.health} health`}`];
-  if (cdef && petHasHappiness(cdef)) bits.push(`happiness ${pet.happiness}%`, LOYALTY_NAMES[pet.loyalty ?? 1] ?? '');
+  if (cdef && petHasHappiness(cdef)) bits.push(`happiness ${Math.round((pet.happiness / HAPPINESS_MAX) * 100)}%`, LOYALTY_NAMES[pet.loyalty ?? 1] ?? '');
   if (pet.trainingPoints != null) bits.push(`${pet.trainingPoints} training points`);
   return bits.filter(Boolean).join(', ');
 }
@@ -81,7 +80,7 @@ function stableRows(app) {
     rows.push({ text: `  Slot ${i + 1}: ${p ? `${p.name} ${dim(app.ds.creature(p.creature)?.name ?? '')}` : dim('empty')}`, detail: () => [bold(`Stable slot ${i + 1}`), '', p ? `Enter: call ${p.name}${ch.pet ? `, stabling ${ch.pet.name} in its place` : ''}.` : 'Empty.'], act: () => { if (p) app.result(g.callStabledPet(i + 1), `${p.name} comes to you.`); } });
   }
   if (ch.pet || ch.storedPet) rows.push({ text: `Stable ${(ch.pet ?? ch.storedPet).name}`, act: () => { const r = g.stablePet(); app.result(r, r.ok ? `Stabled in slot ${r.slot}.` : ''); } });
-  if (slots < MAX_PET_STABLES) rows.push({ text: `Buy a stable slot ${yellow(moneyText(STABLE_SLOT_PRICES[slots] ?? 0))}`, act: () => { const r = g.buyStableSlot(); app.result(r, r.ok ? `A stable slot for ${moneyText(r.spent)}.` : ''); } });
+  if (slots < MAX_PET_STABLES) rows.push({ text: `Buy a stable slot ${coinText(STABLE_SLOT_PRICES[slots] ?? 0)}`, act: () => { const r = g.buyStableSlot(); app.result(r, r.ok ? `A stable slot for ${coinText(r.spent)}.` : ''); } });
   return rows;
 }
 
@@ -99,13 +98,22 @@ export function petTrainerDialog(app, trainer) {
     id: `pettrainer-${trainer.entry}`, title: trainer.name, hint: 'Enter: buy the rank',
     rows(a) {
       const known = new Set(a.ch.petSpells ?? []);
-      const rows = [H(`${bold(trainer.name)} ${dim('<Pet Trainer>')}   ${yellow(moneyText(a.ch.gold) || '0c')}`), H(dim('A rank bought here is yours for good; Beast Training teaches it to whichever pet is out.')), H('')];
+      const rows = [H(`${bold(trainer.name)} ${dim('<Pet Trainer>')}   ${coinText(a.ch.gold)}`), H(dim('A rank bought here is yours for good; Beast Training teaches it to whichever pet is out.')), H('')];
+      const pet = a.ch.pet, untrainCost = a.g.untrainPetCost();
+      if (pet && untrainCost != null) {
+        const taught = pet.taughtSpells?.length ?? 0;
+        rows.push({
+          text: `Untrain ${pet.name}  ${coinText(untrainCost)}${taught ? '' : dim('  nothing taught')}`,
+          detail: () => [bold('Untrain pet'), '', `${pet.name} forgets the ${taught} abilit${taught === 1 ? 'y' : 'ies'} you taught it and gets every training point back to spend again. Its innate abilities stay, and the ranks you bought stay in Beast Training.`, '', `Cost: ${coinText(untrainCost)}. It climbs with each untrain, up to 10 gold, and falls back to 10 silver a day later.`, '', dim('Enter: untrain')],
+          act: () => a.confirm(`Untrain ${pet.name} for ${coinText(untrainCost)}?`, () => { const r = a.g.untrainPet(trainer.entry); a.result(r, r.ok ? `${pet.name} forgets its training: ${a.ch.pet?.trainingPoints ?? 0} training points to spend.` : ''); }),
+        }, H(''));
+      }
       const list = trainer.spells.map((ts) => ({ ts, sp: a.ds.spell(ts.spell) })).filter((x) => x.sp).sort((x, y) => x.ts.reqLevel - y.ts.reqLevel || x.sp.name.localeCompare(y.sp.name));
       for (const { ts, sp } of list) {
         const have = known.has(sp.id), low = ts.reqLevel > a.ch.level;
         rows.push({
-          text: `${have ? green('✓ ') : '  '}${low || have ? dim(sp.name) : sp.name}${sp.rank ? dim(` (Rank ${sp.rank})`) : ''}  ${yellow(moneyText(ts.cost) || 'free')}${low ? red(`  level ${ts.reqLevel}`) : ''}`,
-          detail: () => spellLines(a, sp, ['', `Cost: ${yellow(moneyText(ts.cost) || 'free')}`]),
+          text: `${have ? green('✓ ') : '  '}${low || have ? dim(sp.name) : sp.name}${sp.rank ? dim(` (Rank ${sp.rank})`) : ''}  ${coinText(ts.cost, 'free')}${low ? red(`  level ${ts.reqLevel}`) : ''}`,
+          detail: () => spellLines(a, sp, ['', `Cost: ${coinText(ts.cost, 'free')}`]),
           act: () => { if (!have) a.result(a.g.buyPetSpell(trainer.entry, sp.id), `You learn ${sp.name} for your pets.`); },
         });
       }