azeroth-shell 0.1.2 → 0.3.0

package/src/cli/tuiCreate.mjs

@@ -0,0 +1,230 @@
+// The character create screen: faction, race, class, gender, name and the five looks of the body on one form, the
+// hero drawn in the starting gear beside it, and under the form a card of what they start with (the race
+// and the class in a sentence, racials, pools and attributes at level 1, spells, gear). Left and Right
+// change the row under the cursor; Enter on Race or Class opens a list with each choice drawn; Enter on
+// Name types one; Enter on Create rolls the character. Esc goes back to the character list.
+import { bold, dim, green, red, wrapLines, fit } from './text.mjs';
+import { className, raceName } from '../domain/core/ids.ts';
+import { newGameState, newGameStateFromWorldBot, pickRandomWorldBot } from '../engine/game.ts';
+import { maxHealth, maxPower, knownUsableSpells } from '../domain/character/character.ts';
+import { effectiveStats, powerType } from '../domain/character/characterStats.ts';
+import { bodyOptions, clampAppearance, cycleAppearance, lowestSelectable, slotCount, APPEARANCE_SLOTS } from '../domain/character/appearance.ts';
+import { equippedEntry } from '../domain/items/itemInstance.ts';
+import { nativeDisplayId } from '../domain/character/displayForm.ts';
+import { creatureArt } from './modelArt.mjs';
+import { paperdollArt } from './paperdoll.mjs';
+import { characterNamesEqual } from '../domain/character/characterName.ts';
+
+// A sentence on each race and class, in the voice of the client's create screen; the racials, the start
+// zone and everything else on the card come from the data.
+const RACE_BLURB = {
+  1: 'The people of Stormwind, adaptable and diplomatic: their spirit runs deeper, reputation comes sooner, and they see through stealth a little further.',
+  2: 'The Horde of Thrall, hardy and fierce. Blood Fury hardens their attacks, stuns slide off them more often, their axes bite deeper, and their pets strike harder.',
+  3: 'The stout folk of Ironforge. Stoneform shrugs off poison, disease and bleeding; they resist frost, shoot guns truer, and can find treasure in the earth.',
+  4: 'The Kaldorei of Teldrassil, ancient and watchful. They melt into Shadowmeld, are harder to hit, resist nature, and walk as wisps when they fall.',
+  5: 'The Forsaken of the Undercity, free of the Lich King. Will of the Forsaken breaks fear, charm and sleep; they eat the dead to heal, breathe underwater longer, and resist shadow.',
+  6: 'The Shu\'halo of Mulgore, peaceful until roused. War Stomp stuns everything around them, they stand with more health, resist nature, and gather herbs faster.',
+  7: 'The tinkers of Gnomeregan, guests of Ironforge. Escape Artist slips any snare, their minds hold more mana, they resist arcane, and they are born engineers.',
+  8: 'The Darkspear, who followed Thrall from the Echo Isles. Berserking quickens blows and spells, they regenerate even in a fight, slay beasts harder, and throw and shoot bows truer.',
+};
+const CLASS_BLURB = {
+  1: 'Steel and rage. Warriors wear the heaviest armour, hold the line behind a shield or swing a two-hander, and build rage by hitting and being hit.',
+  2: 'The Light\'s champion in plate: a healer, a protector and a slow but sure fighter, with blessings for the party and a bubble for when it goes wrong.',
+  3: 'A ranger with a bow or gun and a pet tamed from the wild. The pet holds the foe while the hunter shoots, and the map shows what they track.',
+  4: 'A stealthy fighter who builds combo points with blades and spends them on finishing moves. Poisons, lockpicking and picking pockets come with the trade.',
+  5: 'The great healer, in cloth. Holy mends and shields the party; Shadow drains and torments from Shadowform, trading the healing for the dark.',
+  6: 'The Horde\'s keeper of the elements, in mail: totems, lightning and shocks, heals and weapon imbues, half melee and half spell at every turn.',
+  7: 'The master of frost, fire and arcane, fragile in cloth and lethal at range. Conjures food and water, sheeps a foe, and opens portals between cities.',
+  8: 'A wielder of fel magic in cloth: curses and damage over time, a demon summoned to tank or drain, and health, soul shards and healthstones traded for power.',
+  9: 'The shapeshifter: a bear to tank, a cat to claw, healing and nature magic in caster form, and travel form for the road.',
+};
+
+const NAME_RE = /^[A-Za-z]{2,12}$/;
+const properName = (s) => s[0].toUpperCase() + s.slice(1).toLowerCase();
+const rand = (n) => Math.floor(Math.random() * n);
+const newSeed = () => (Date.now() ^ (Math.random() * 0x7fffffff)) >>> 0;
+
+/** A random look within the body's legal choices (the create screen's shuffle; bald and hornless allowed where offered). */
+export function randomLook(race, gender) {
+  const look = {};
+  APPEARANCE_SLOTS.forEach((key, s) => {
+    const floor = lowestSelectable(race, gender, s), count = slotCount(race, gender, s);
+    look[key] = count > floor ? floor + rand(count - floor) : 0;
+  });
+  return clampAppearance(look, race, gender);
+}
+
+/** A name from the world bots' pool for the gender, fit for a character. */
+export function randomName(ds, gender) {
+  const pool = ds.botNames()[gender === 1 ? 'female' : 'male'];
+  for (let i = 0; i < 50 && pool.length; i++) { const n = pool[rand(pool.length)]; if (NAME_RE.test(n)) return properName(n); }
+  return gender === 1 ? 'Aalina' : 'Aalart';
+}
+
+/** The screen. `done(state)` gets the new character's game state; `onCancel` is Esc (back to the character list). */
+export function characterCreation(app, done, { onCancel } = {}) {
+  const ds = app.ds;
+  const races = ds.races();
+  const classesOf = (race) => race.classes.filter((c) => ds.createInfo(race.id, c));
+  const st = { race: races[0], cls: classesOf(races[0])[0], gender: 0, name: '', look: null };
+  st.look = randomLook(st.race.id, st.gender);
+  // The state a Create would make for a body and class, less the name and the look: its character carries the
+  // starting gear, pools and attributes the card and the drawing read. One per combination, kept.
+  const previews = new Map();
+  const previewOf = (race, cls, gender) => {
+    const key = `${race}-${cls}-${gender}`;
+    let p = previews.get(key);
+    if (!p) { p = newGameState(ds, race, cls, 'Preview', 1, gender); previews.set(key, p); }
+    return p;
+  };
+  const preview = () => previewOf(st.race.id, st.cls, st.gender);
+  const hero = (cls = st.cls) => ({ ...previewOf(st.race.id, cls, st.gender).char, name: st.name || 'Preview', appearance: st.look });
+  const setRace = (r) => { st.race = r; lastRace[r.faction] = r; const cs = classesOf(r); if (!cs.includes(st.cls)) st.cls = cs[0]; st.look = clampAppearance(st.look, r.id, st.gender); };
+  // Faction comes first: Race cycles and lists only its races, and flipping back returns to the race last chosen there.
+  const factions = [...new Set(races.map((r) => r.faction))];
+  const racesOf = (f) => races.filter((r) => r.faction === f);
+  const lastRace = { [st.race.faction]: st.race };
+  const setFaction = (f) => setRace(lastRace[f] ?? racesOf(f)[0]);
+  const setGender = (g) => { st.gender = g; st.look = clampAppearance(st.look, st.race.id, g); };
+  const cycle = (list, cur, dir) => list[(list.indexOf(cur) + dir + list.length) % list.length];
+  const genderName = () => (st.gender === 1 ? 'Female' : 'Male');
+  const factionName = (r) => (r.faction === 'horde' ? 'Horde' : 'Alliance');
+
+  const view = { id: 'create', title: 'New character', hint: 'Left Right: change   Enter: pick or type' + (onCancel ? '   Esc: character list' : '') };
+  const rowAt = (id) => app.rowsOf(view).findIndex((r) => r.id === id);
+  const goTo = (id) => { const i = rowAt(id); if (i >= 0) { view.cursor = i; app.ensureVisible(view, app.rowsOf(view)); } app.render(); };
+
+  // The hero drawn for the pane: the body in its starting gear with the look, or the bare body when the gear pack lacks it.
+  const drawn = (cls, maxCols, maxRows) => paperdollArt(hero(cls), maxCols, maxRows) ?? creatureArt(nativeDisplayId(st.race.id, st.gender), maxCols, maxRows);
+  const withBody = (text, art) => (art ? [...text, '', ...art] : text);
+
+  // Mail to an alt finds them by name, so two of yours may not share one. Read once as the screen opens.
+  let taken = [];
+  void Promise.resolve(app.repo?.list?.()).then((l) => { taken = (l ?? []).map((s) => s.name ?? ''); }).catch(() => {});
+  const nameTaken = (name) => taken.some((n) => characterNamesEqual(n, name));
+  const askName = () => app.prompt('Name (2-12 letters): ', (raw) => {
+    const name = raw.trim();
+    if (!NAME_RE.test(name)) { app.say(red('Letters only, 2 to 12 of them.')); askName(); return; } // said in the log: the prompt covers the hint line
+    if (nameTaken(name)) { app.say(red(`${properName(name)} is already one of your characters.`)); askName(); return; }
+    st.name = properName(name);
+    goTo('create'); // named: Enter again creates
+  }); // the line starts empty: Esc keeps the name they had
+  const rollName = () => { st.name = randomName(ds, st.gender); app.render(); };
+  const shuffle = () => { st.look = randomLook(st.race.id, st.gender); app.render(); };
+  const create = () => {
+    if (!st.name) { app.flashMsg('Give them a name first.'); goTo('name'); return; }
+    if (nameTaken(st.name)) { app.flashMsg(`${st.name} is already one of your characters. Pick another name.`); goTo('name'); return; }
+    done(newGameState(ds, st.race.id, st.cls, st.name, newSeed(), st.gender, st.look));
+  };
+  const randomCharacter = () => {
+    const seed = newSeed();
+    done(newGameStateFromWorldBot(ds, pickRandomWorldBot(ds, seed), seed));
+  };
+
+  // Enter on Race: the faction's races listed with each body drawn; on Class: every class this race may be, drawn in its gear.
+  const racePicker = () => {
+    const list = racesOf(st.race.faction);
+    const p = app.pick('Race', list.map((r) => ({
+      label: `${fit(r.name, 10)} ${dim(factionName(r))}`,
+      detail: () => {
+        const L = app.layout();
+        const text = [bold(r.name), dim(factionName(r)), `Starts in ${ds.zone(r.startZone)?.name ?? r.startZone}`, dim('Classes: ') + classesOf(r).map(className).join(', ')];
+        return withBody(text, creatureArt(nativeDisplayId(r.id, st.gender), L.detailW - 2, L.mainH - text.length - 1));
+      },
+      value: r,
+    })), (r) => { setRace(r); app.render(); }, { hint: 'Enter: choose' });
+    p.cursor = list.indexOf(st.race);
+  };
+  const classPicker = () => {
+    const classes = classesOf(st.race);
+    const p = app.pick('Class', classes.map((c) => ({
+      label: className(c),
+      detail: () => {
+        const L = app.layout();
+        const text = [bold(className(c)), ...wrapLines(dim(CLASS_BLURB[c] ?? ''), L.detailW - 2)];
+        return withBody(text, drawn(c, L.detailW - 2, L.mainH - text.length - 1));
+      },
+      value: c,
+    })), (c) => { st.cls = c; app.render(); }, { hint: 'Enter: choose' });
+    p.cursor = classes.indexOf(st.cls);
+  };
+
+  // A form row: the label, the value, and the arrows when Left and Right change it.
+  const field = (id, label, value, { cycle: cyc, act, arrows = true }) => ({ id, text: `${fit(label, 12)} ${fit(bold(value), 10)}${arrows ? ` ${dim('◂ ▸')}` : ''}`, cycle: cyc, act });
+  const H = (text = '', plain = false) => ({ text, header: true, plain });
+
+  // Under the form: what the race and the class are, and what a level 1 of them starts with.
+  const card = () => {
+    const L = app.layout();
+    const w = Math.max(24, (L.detailW ? L.listW : L.W) - 3);
+    const wrap = (t) => wrapLines(t, w).map((l) => H(l, true));
+    const r = st.race, p = preview(), ch = p.char;
+    const out = [H(`${r.name} · ${factionName(r)}`)];
+    if (RACE_BLURB[r.id]) out.push(...wrap(RACE_BLURB[r.id]));
+    out.push(...wrap(dim(`Starts in ${ds.zone(r.startZone)?.name ?? r.startZone}; home city ${r.city}.`)));
+    const racials = [...new Set(r.racials.map((id) => ds.spell(id)?.name).filter(Boolean))];
+    if (racials.length) out.push(...wrap(`${dim('Racials:')} ${racials.join(', ')}`));
+    out.push(H(), H(className(st.cls)));
+    if (CLASS_BLURB[st.cls]) out.push(...wrap(CLASS_BLURB[st.cls]));
+    const s = effectiveStats(ch, ds), pt = powerType(ch);
+    out.push(...wrap(`${dim('Level 1:')} ${maxHealth(ch, ds)} health, ${maxPower(ch, ds)} ${pt}`));
+    out.push(...wrap(`${dim('Str')} ${s.str}  ${dim('Agi')} ${s.agi}  ${dim('Sta')} ${s.sta}  ${dim('Int')} ${s.int}  ${dim('Spi')} ${s.spi}`));
+    const spells = [...new Set(knownUsableSpells(ch, p.spellbook, ds).map((sp) => sp.name))];
+    if (spells.length) out.push(...wrap(`${dim('Knows:')} ${spells.join(', ')}`));
+    const worn = new Set(Object.values(ch.equipped ?? {}).map(equippedEntry));
+    const wears = [], carries = [];
+    for (const it of ds.createInfo(r.id, st.cls)?.items ?? []) {
+      const def = ds.item(it.item);
+      if (def) (worn.has(it.item) ? wears : carries).push(it.amount > 1 ? `${def.name} ×${it.amount}` : def.name);
+    }
+    if (wears.length) out.push(...wrap(`${dim('Wears:')} ${wears.join(', ')}`));
+    if (carries.length) out.push(...wrap(`${dim('Carries:')} ${carries.join(', ')}`));
+    return out;
+  };
+
+  view.rows = () => {
+    const rows = [
+      field('faction', 'Faction', factionName(st.race), { cycle: (d) => setFaction(cycle(factions, st.race.faction, d)), act: () => { setFaction(cycle(factions, st.race.faction, 1)); app.render(); } }),
+      field('race', 'Race', st.race.name, { cycle: (d) => setRace(cycle(racesOf(st.race.faction), st.race, d)), act: racePicker }),
+      field('class', 'Class', className(st.cls), { cycle: (d) => { st.cls = cycle(classesOf(st.race), st.cls, d); }, act: classPicker }),
+      field('gender', 'Gender', genderName(), { cycle: () => setGender(st.gender === 1 ? 0 : 1), act: () => { setGender(st.gender === 1 ? 0 : 1); app.render(); } }),
+      { id: 'name', text: `${fit('Name', 12)} ${st.name ? bold(st.name) : dim('Enter: type one   n: a random one')}`, act: askName },
+      H(), H('Look'),
+    ];
+    // The body's own slots, by the names the client gives them (Horn Style, Tusks…); a slot with one choice is left out.
+    const body = bodyOptions(st.race.id, st.gender);
+    APPEARANCE_SLOTS.forEach((key, s) => {
+      const opt = body?.options[s];
+      if (!opt) return;
+      const floor = lowestSelectable(st.race.id, st.gender, s), count = opt.count;
+      if (count - floor <= 1) return;
+      const i = st.look[key];
+      const value = i === 0 && opt.none ? 'None' : `${i + 1 - floor} of ${count - floor}`;
+      rows.push(field(key, opt.name, value, { cycle: (d) => { st.look = cycleAppearance(st.look, st.race.id, st.gender, s, d); }, act: () => { st.look = cycleAppearance(st.look, st.race.id, st.gender, s, 1); app.render(); } }));
+    });
+    rows.push({ id: 'shuffle', text: `${fit('', 12)} ${dim('r: a random look')}`, act: shuffle });
+    rows.push(H());
+    rows.push({ id: 'create', text: green(bold(st.name ? `Create ${st.name}, ${genderName()} ${st.race.name} ${className(st.cls)}` : 'Create (needs a name)')), act: create });
+    rows.push({ id: 'random', text: `Random character  ${dim('a world bot at its own level, geared and named')}`, act: randomCharacter });
+    rows.push(H(), ...card());
+    return rows;
+  };
+  // The pane: the hero as they will stand on the Character tab, in the starting gear, as large as the pane allows.
+  view.detail = () => {
+    const L = app.layout();
+    const head = [`${st.name ? bold(st.name) : dim('Unnamed')}  ${dim(`${genderName()} ${raceName(st.race.id)} ${className(st.cls)}`)}`, ''];
+    const art = drawn(st.cls, L.detailW - 2, L.mainH - head.length);
+    return art ? [...head, ...art] : head;
+  };
+  view.keys = {
+    n: { hint: 'random name', fn: rollName },
+    r: { hint: 'random look', fn: shuffle },
+  };
+  view.onKey = (a, k, row) => {
+    if ((k === 'left' || k === 'right') && row?.cycle) { row.cycle(k === 'left' ? -1 : 1); a.render(); return true; }
+    if (k === 'escape') { onCancel?.(); return true; }
+    return false;
+  };
+  app.push(view);
+  return view;
+}

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,
 } 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';
@@ -53,6 +55,15 @@ 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);
@@ -78,10 +89,11 @@ export function portalRows(app) {
   if (!portals.length) return rows;
   rows.push(H(''), H(`Dungeons (${portals.length})`));
   for (const def of portals) {
-    const low = ch.level < def.minLevel;
+    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)} ${dim(`L${def.levelRange[0]}-${def.levelRange[1]}${isRaid(def) ? `  ${def.maxPlayers}-man raid` : ''}`)}${low && !lock ? red(`  ${chk.reason ?? `requires ${def.minLevel}`}`) : ''}${lock ? `  ${lock}` : ''}`,
       data: { dungeon: def },
       detail: () => portalLines(app, def),
       act: () => app.push(entryDialog(app, def)),
@@ -95,6 +107,8 @@ function portalLines(app, def) {
   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 +116,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) {
@@ -114,6 +129,7 @@ export function entryDialog(app, def) {
       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 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 +147,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 +157,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 +296,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;
 }
@@ -314,7 +330,7 @@ function objectRow(app, def, o) {
   const name = spawn.name ?? ds.creature(spawn.entry)?.name ?? `npc ${spawn.entry}`;
   const marks = `${quests.turnIn.length ? green(' ?') : ''}${quests.offer.length ? yellow(' !') : ''}${quests.escort.length ? cyan(' escort') : ''}`;
   return {
-    text: `${dim('☺')} ${name}${marks}`,
+    text: `${dim('•')} ${name}${marks}`,
     detail: () => [bold(name), ...quests.offer.map((q) => `${yellow('!')} ${q.title}`), ...quests.turnIn.map((q) => `${green('?')} ${q.title}`), ...quests.escort.map((q) => `${cyan('escort')} ${q.title}`), '', dim('Enter: speak with them')],
     act: () => npcDialog(app, spawn.entry, name),
   };
@@ -362,7 +378,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);
@@ -399,13 +415,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 +476,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 +612,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);