azeroth-shell 0.0.0-stage → 0.1.0

package/src/cli/tuiSettings.mjs

@@ -0,0 +1,151 @@
+// The Settings window (phonecraft panels/settingsPanel.ts, Loot tab): auto-loot, the equipment helper, automatic
+// disenchanting, the junk rules (what gets sold or destroyed on its own) and which gathering nodes the autopilot
+// takes. Enter flips or cycles a row. "Every character" settings live in ~/.azsh/prefs.json through the
+// createGame hooks; "this character" settings live in the save.
+import { bold, dim, yellow, green, red, cyan, qualityPaint } from './text.mjs';
+import { autoLootOn } from './tuiLoot.mjs';
+import { moneyText } from '../domain/economy/money.ts';
+import { JUNK_PROTECT_CATEGORIES } from '../domain/items/junkCategories.ts';
+import { autopilotSettingsDialog } from './tuiAutopilotSettings.mjs';
+import { paceLabel, nextPace } from './tuiWorld.mjs';
+
+const H = (text) => ({ text, header: true });
+const QUALITY_NAME = ['Poor', 'Common', 'Uncommon', 'Rare', 'Epic'];
+const DE_STEPS = [null, 2, 3, 4]; // off, then the ceiling
+const onOff = (v) => (v ? green('on') : dim('off'));
+const box = (v) => (v ? green('✓') : dim('·'));
+
+/** The `createGame` options that back the every-character layers (and account macros) with the prefs file. */
+export function globalSettingsOpts(prefs) {
+  return {
+    junkFilter: () => prefs.get('junkFilter'),
+    onJunkFilterChange: (cfg) => prefs.set('junkFilter', cfg),
+    autoDisenchant: () => prefs.get('autoDisenchant'),
+    onAutoDisenchantChange: (cfg) => prefs.set('autoDisenchant', cfg),
+    accountMacros: () => prefs.get('accountMacros') ?? [],
+    onAccountMacrosChange: (list) => prefs.set('accountMacros', list),
+  };
+}
+
+function deText(cfg) { return cfg.enabled ? `up to ${qualityPaint(cfg.maxQuality)(QUALITY_NAME[cfg.maxQuality])}` : dim('off'); }
+function nextDe(cfg) {
+  const i = DE_STEPS.indexOf(cfg.enabled ? cfg.maxQuality : null);
+  const q = DE_STEPS[(i + 1) % DE_STEPS.length];
+  return q == null ? { ...cfg, enabled: false } : { ...cfg, enabled: true, maxQuality: q };
+}
+
+/** The junk layer edits land on: this character's when it keeps its own rules, else every character's. */
+function junkLayer(g) {
+  const ch = g.characterJunkFilterConfig();
+  return ch.characterSpecific
+    ? { cfg: ch, set: (next) => g.setCharacterJunkFilterConfig({ ...ch, ...next }), scope: 'this character' }
+    : { cfg: g.globalJunkFilterConfig(), set: (next) => g.setGlobalJunkFilterConfig({ ...g.globalJunkFilterConfig(), ...next }), scope: 'every character' };
+}
+
+export function settingsDialog(app) {
+  return {
+    id: 'settings', title: 'Settings', hint: 'Enter: change',
+    rows(a) {
+      const g = a.g;
+      const rows = [{ text: `Autopilot settings  ${dim('resting, pulls, fighting, questing   (:autopilot)')}`, act: (a2) => a2.push(autopilotSettingsDialog(a2)) }, H(''), H(bold('Loot'))];
+      rows.push({ text: `Auto-loot                 ${onOff(autoLootOn(a))}`, detail: () => [bold('Auto-loot'), '', 'On: a corpse\'s drops and coin go straight into your bags.', 'Off: the loot window opens and you take what you want.'], act: (a2) => a2.prefs.set('autoLoot', !autoLootOn(a2)) });
+
+      const pace = a.prefs.get('travelPace') ?? 'instant';
+      rows.push(H(''), H(bold('Travel')));
+      rows.push({
+        text: `Travel pace               ${pace === 'instant' ? dim('instant') : cyan(paceLabel(pace))}`,
+        detail: () => [bold('Travel pace'), '', 'Instant: you arrive the moment you set off.', 'Real time: a trip takes as long as the road (1x), or half or a quarter of it. The header counts it down; the World tab has the journey card.'],
+        act: (a2) => {
+          const next = nextPace(pace);
+          a2.prefs.set('travelPace', next);
+          // Switching to instant lands a trip already underway, as phonecraft does.
+          if (next === 'instant' && g.state.char.journey) a2.arriveNow();
+        },
+      });
+
+      const eh = g.equipmentHelperConfig();
+      rows.push(H(''), H(bold('Equipment helper')));
+      rows.push({ text: `Helper                    ${onOff(eh.enabled)}`, detail: () => [bold('Equipment helper'), '', 'Scores what you pick up against what you wear and marks upgrades with ▲.'], act: (a2) => g.setEquipmentHelperConfig({ ...eh, enabled: !eh.enabled }) });
+      rows.push({ text: `Upgrades                  ${eh.mode === 'auto' ? green('put on as they drop') : cyan('suggest only')}`, detail: () => [bold('Upgrades'), '', 'Suggest: ▲ on the Gear and Bags tabs, u puts them on.', 'Put on: strict upgrades are worn the moment they land in your bags.'], act: () => g.setEquipmentHelperConfig({ ...eh, mode: eh.mode === 'auto' ? 'suggest' : 'auto' }) });
+
+      const deMine = g.characterAutoDisenchantConfig(), deAll = g.globalAutoDisenchantConfig();
+      rows.push(H(''), H(bold('Disenchant on its own')));
+      const deDetail = ['Gear that is not an upgrade breaks down into enchanting mats once someone in the group has the skill.', 'The higher of the two settings wins.'];
+      rows.push({ text: `This character            ${deText(deMine)}`, detail: () => [bold('Auto-disenchant, this character'), '', ...deDetail], act: () => g.setCharacterAutoDisenchantConfig(nextDe(deMine)) });
+      rows.push({ text: `Every character           ${deText(deAll)}`, detail: () => [bold('Auto-disenchant, every character'), '', ...deDetail], act: () => g.setGlobalAutoDisenchantConfig(nextDe(deAll)) });
+      rows.push({ text: `Keep companion upgrades   ${onOff(deMine.protectCompanionUpgrades)}`, detail: () => [bold('Keep companion upgrades'), '', 'Gear a companion would wear is never broken down or sold. Your own upgrades are always kept.'], act: () => g.setCharacterAutoDisenchantConfig({ ...deMine, protectCompanionUpgrades: !deMine.protectCompanionUpgrades }) });
+      rows.push({ text: green('Disenchant now'), detail: () => [bold('Disenchant now'), '', 'Runs the rule above over your bags once.'], act: (a2) => { const n = g.autoDisenchantUpgrades(); if (n) a2.say(green(`Disenchanted ${n} item${n === 1 ? '' : 's'}.`)); else a2.flashMsg(g.autoDisenchantConfig().enabled ? 'Nothing in your bags matches.' : 'Switch auto-disenchant on first.'); } });
+
+      const own = g.characterJunkFilterConfig().characterSpecific;
+      const { cfg: jf, set: setJunk, scope } = junkLayer(g);
+      rows.push(H(''), H(`${bold('Junk')}   ${dim(`editing the rules for ${scope}`)}`));
+      rows.push({ text: `Rules                     ${own ? cyan('this character\'s own') : dim('shared by every character')}`, detail: () => [bold('Whose junk rules'), '', 'Every character shares one set of junk rules unless this one keeps its own.', 'The keep, sell and destroy lists always apply from both.'], act: () => { const ch = g.characterJunkFilterConfig(); g.setCharacterJunkFilterConfig({ ...ch, characterSpecific: !ch.characterSpecific }); } });
+      rows.push({ text: `Sell junk at a vendor     ${onOff(jf.autoSell)}`, act: () => setJunk({ autoSell: !jf.autoSell }) });
+      for (let q = 0; q <= 4; q++) rows.push({ text: `  ${box(jf.sellQuality[q])} sell ${qualityPaint(q)(QUALITY_NAME[q])}`, act: () => setJunk({ sellQuality: { ...jf.sellQuality, [q]: !jf.sellQuality[q] } }) });
+      rows.push({ text: `Destroy junk              ${jf.autoDestroy ? red('on') : dim('off')}`, act: () => setJunk({ autoDestroy: !jf.autoDestroy }) });
+      for (let q = 0; q <= 4; q++) rows.push({ text: `  ${box(jf.destroyQuality[q])} destroy ${qualityPaint(q)(QUALITY_NAME[q])}`, act: () => setJunk({ destroyQuality: { ...jf.destroyQuality, [q]: !jf.destroyQuality[q] } }) });
+      const prot = new Set(jf.protectCategories);
+      rows.push({
+        text: `Never sell or destroy     ${dim(`${prot.size} of ${JUNK_PROTECT_CATEGORIES.length} kinds`)}`,
+        detail: () => [bold('Protected kinds'), '', ...JUNK_PROTECT_CATEGORIES.map((c) => `${box(prot.has(c.id))} ${c.label}`), '', dim('Enter: choose')],
+        act: (a2) => a2.push(protectDialog(a2)),
+      });
+      const lists = [['keepEntries', 'Always keep'], ['sellEntries', 'Always sell'], ['destroyEntries', 'Always destroy']];
+      for (const [key, label] of lists) {
+        const n = jf[key].length;
+        rows.push({ text: `${label.padEnd(26)}${n ? `${n} item${n === 1 ? '' : 's'}` : dim('none')}`, detail: () => [bold(label), '', ...(n ? jf[key].map((e) => a.itemLabel(e)) : [dim('Empty. m on a bag item adds to it.')]), '', dim('Enter: edit')], act: (a2) => a2.push(junkListDialog(a2, key, label)) });
+      }
+      rows.push({ text: green('Clear out junk now'), detail: () => [bold('Clear out junk now'), '', 'Sells (when a vendor is open or the rule allows) and destroys what the rules say, once.'], act: (a2) => { const r = g.runAutoJunk(); if (r.sold || r.destroyed) a2.say(green(`Junk: ${r.sold} sold${r.earned ? ` for ${moneyText(r.earned)}` : ''}, ${r.destroyed} destroyed.`)); else a2.flashMsg('Nothing in your bags is junk by these rules.'); } });
+
+      const gf = g.gatherFilterConfig();
+      rows.push(H(''), H(`${bold('Gathering')}   ${dim('which nodes the autopilot mines, picks and skins, by skill colour')}`));
+      for (const [c, paint] of [['orange', yellow], ['yellow', yellow], ['green', green], ['gray', dim]]) {
+        rows.push({ text: `  ${box(gf.takeColor[c])} ${paint(c)}`, act: () => g.setGatherFilterConfig({ ...gf, takeColor: { ...gf.takeColor, [c]: !gf.takeColor[c] } }) });
+      }
+      return rows;
+    },
+  };
+}
+
+function protectDialog(app) {
+  return {
+    id: 'junk-protect', title: 'Never sell or destroy', hint: 'Enter: on / off',
+    rows(a) {
+      const { cfg, set } = junkLayer(a.g);
+      const prot = new Set(cfg.protectCategories);
+      return [H(dim('These kinds are never junk, whatever the quality boxes say.')), H(''), ...JUNK_PROTECT_CATEGORIES.map((c) => ({
+        text: `${box(prot.has(c.id))} ${c.label}`, detail: () => [bold(c.label), '', c.hint ?? ''],
+        act: () => { if (prot.has(c.id)) prot.delete(c.id); else prot.add(c.id); set({ protectCategories: [...prot] }); },
+      }))];
+    },
+  };
+}
+
+function junkListDialog(app, key, label) {
+  return {
+    id: 'junk-list', title: label, hint: 'Enter: take it off the list',
+    empty: 'Empty. m on a bag item adds to it.',
+    rows(a) {
+      const { cfg, set } = junkLayer(a.g);
+      return cfg[key].map((e) => ({ text: a.itemLabel(e), act: () => set({ [key]: cfg[key].filter((x) => x !== e) }) }));
+    },
+  };
+}
+
+/** Bag item menu entries: put an item on one of the junk lists (or take it off). */
+export function junkListOptions(app, entry) {
+  const { cfg, set } = junkLayer(app.g);
+  const name = app.itemLabel(entry);
+  return [['keepEntries', 'Always keep'], ['sellEntries', 'Always sell'], ['destroyEntries', 'Always destroy']].map(([key, label]) => {
+    const on = cfg[key].includes(entry);
+    return {
+      label: on ? dim(`${label}: take it off`) : label,
+      value: () => {
+        const strip = (list) => list.filter((x) => x !== entry);
+        // An item sits on one list at most: keep beats sell beats destroy only by being the last one picked.
+        set(on ? { [key]: strip(cfg[key]) } : { keepEntries: strip(cfg.keepEntries), sellEntries: strip(cfg.sellEntries), destroyEntries: strip(cfg.destroyEntries), [key]: [...strip(cfg[key]), entry] });
+        app.say(dim(on ? `${name} is off the ${label.toLowerCase()} list.` : `${name}: ${label.toLowerCase()}.`));
+      },
+    };
+  });
+}

package/src/cli/tuiSimLab.mjs

@@ -0,0 +1,80 @@
+// The target dummy (phonecraft rotation/rotationSimLab.ts): run the rotation on screen against a stunned dummy
+// many times over and read the parse. The dummy never dies, so the numbers measure the rotation and nothing else;
+// every one comes from the same combat engine the game fights in (domain/sim/dummySim.ts).
+import { bold, dim, yellow, green, red, cyan, fit, bar } from './text.mjs';
+import { createDummySim } from '../domain/sim/dummySim.ts';
+import { DUMMY_TARGETS, DEFAULT_DUMMY_ENTRY, dummyTarget } from '../domain/sim/targetDummy.ts';
+
+const FIGHT_SECS = [20, 30, 60, 120];
+const ITERATIONS = [20, 50, 100, 200];
+const STEP_MS = 40; // engine time per timer tick, so the screen keeps drawing while it runs
+const H = (text) => ({ text, header: true });
+const nf = (v) => (v >= 1000 ? Math.round(v).toLocaleString('en-US') : String(v));
+const cycle = (list, v) => list[(list.indexOf(v) + 1) % list.length];
+
+/** `owner()` gives `{ name, who, rotation, char, spellbook }` for whoever the Rotation tab is editing
+ *  (`name` is possessive, "Your" / "Milto's"; `who` is the subject, "You" / "Milto"). */
+export function simLabDialog(app, owner) {
+  const s = { entry: DEFAULT_DUMMY_ENTRY, fightSecs: 20, iterations: 50, run: null, report: null, timer: null };
+  const stop = () => { if (s.timer) app.term.clearInterval(s.timer); s.timer = null; if (s.run) s.report = s.run.report(); };
+  const start = (a) => {
+    stop();
+    const o = owner();
+    const state = { ...a.g.state, char: o.char, spellbook: o.spellbook };
+    s.report = null;
+    s.run = createDummySim(a.ds, state, o.rotation, { entry: s.entry, iterations: s.iterations, fightSecs: s.fightSecs, seed: 1337 }, () => performance.now());
+    s.timer = a.term.setInterval(() => {
+      s.run.step(STEP_MS);
+      if (s.run.done) { stop(); a.say(green(`Dummy parse done: ${nf(s.report.dps.avg)} DPS.`)); }
+      a.render();
+    }, 50);
+  };
+  const view = {
+    id: 'sim-lab', title: 'Target dummy', hint: 'Enter: change / run', noDetail: true,
+    sim: s,
+    onClose: () => stop(),
+    keys: { G: { hint: 'run', fn: (a) => start(a) } },
+    rows(a) {
+      const o = owner();
+      const t = dummyTarget(s.entry);
+      const busy = !!s.timer;
+      const rows = [H(`${bold(`${o.name} rotation`)} ${dim('against a dummy that stands still and never dies')}`), H('')];
+      const setting = (label, value, fn) => ({ text: `${fit(label, 10)} ${value}`, act: () => { if (busy) return; fn(); s.report = null; } });
+      rows.push(setting('Dummy', `${t?.label ?? s.entry}  ${dim(t?.note ?? '')}`, () => { s.entry = cycle(DUMMY_TARGETS.map((d) => d.entry), s.entry); }));
+      rows.push(setting('Fight', `${s.fightSecs} s`, () => { s.fightSecs = cycle(FIGHT_SECS, s.fightSecs); }));
+      rows.push(setting('Fights', `${s.iterations}  ${dim(`${nf(s.iterations * s.fightSecs * 10)} rounds of combat`)}`, () => { s.iterations = cycle(ITERATIONS, s.iterations); }));
+      rows.push({ text: busy ? yellow('Stop') : green(s.report ? 'Run again' : 'Run the parse'), act: (a2) => { if (busy) { stop(); } else start(a2); } });
+      rows.push(H(''));
+      if (busy && s.run) {
+        rows.push(H(`${bar(s.run.completed, s.run.iterations, 30, cyan)} ${dim(`fight ${Math.min(s.run.iterations, s.run.completed + 1)} of ${s.run.iterations}`)}`));
+        return rows;
+      }
+      if (s.report) rows.push(...reportRows(s.report, o.who));
+      return rows;
+    },
+  };
+  return view;
+}
+
+function reportRows(r, who) {
+  if (r.refusedReason) return [H(red(`The dummy could not be pulled: ${r.refusedReason}`))];
+  const powerLabel = r.power.type === 'mana' ? 'mana' : r.power.type === 'rage' ? 'rage' : 'energy';
+  const out = [
+    H(`${who} vs ${r.target.name}, level ${r.target.level}, ${nf(r.target.armor)} armor. ${r.iterations} fights of ${r.fightSecs} s.`),
+    H(''),
+    H(`${bold(green(`${nf(r.dps.avg)} DPS`))}  ${dim(`median ${nf(r.dps.median)}, lowest ${nf(r.dps.min)}, highest ${nf(r.dps.max)}, spread ±${nf(r.dps.stdev)}`)}`),
+    H(`${nf(r.totals.castsPerMin)} casts a minute, ${r.totals.idlePct}% idle.   ${r.power.damagePerPoint > 0 ? `${r.power.damagePerPoint} damage per ${powerLabel}, ` : ''}${dim(`${nf(r.power.spent)} spent, ${nf(r.power.regained)} back per fight`)}`),
+  ];
+  if (r.deaths > 0) out.push(H(yellow(`${r.deaths} of ${r.iterations} fights ended in your death; the DPS is over the seconds you were alive.`)));
+  if (r.power.oomFights > 0) out.push(H(yellow(`${r.power.oomFights} fights ended under 5% ${powerLabel}.`)));
+  if (r.totals.idlePct >= 25) out.push(H(yellow(`The rotation had nothing to press on ${r.totals.idlePct}% of rounds.`)));
+  out.push(H(''), H(cyan(`${fit('Ability', 24)} ${fit('Damage', 9, true)} ${fit('Share', 6, true)} ${fit('Casts', 6, true)} ${fit('Avg', 7, true)} ${fit('Crit', 6, true)} ${fit('Miss', 6, true)}`)));
+  if (!r.abilities.length) out.push(H(dim('The rotation cast nothing. Check range, power and the rule conditions.')));
+  for (const ab of r.abilities) {
+    out.push(H(`${fit(ab.name, 24)} ${fit(nf(ab.damage), 9, true)} ${fit(`${ab.damagePct}%`, 6, true)} ${fit(String(ab.casts), 6, true)} ${fit(nf(ab.avgHit), 7, true)} ${fit(`${ab.critPct}%`, 6, true)} ${fit(`${ab.missPct}%`, 6, true)}${ab.uptimeSec > 0 ? dim(`  up ${ab.uptimeSec}s`) : ''}`));
+  }
+  const t = r.totals;
+  const parts = [['hits', t.hits], ['crits', t.crits], ['misses', t.misses], ['dodges', t.dodges], ['parries', t.parries], ['blocks', t.blocks], ['resists', t.resists], ['glancing', t.glancing], ['crushing', t.crushing]].filter(([, n]) => n > 0);
+  out.push(H(''), H(dim(parts.length ? parts.map(([l, n]) => `${nf(n)} ${l}`).join(', ') : 'Nothing landed.')));
+  return out;
+}

package/src/cli/tuiTalents.mjs

@@ -0,0 +1,60 @@
+// Talent builds for the Talents tab (B): the premade playerbot specs for your class, loadouts you saved, a pasted
+// talent string (Wowhead-style digits or a classicdb link), and your own string to copy. Applying any of them
+// is a respec at the usual price when points are already spent.
+import { bold, dim, yellow, green, red, cyan } from './text.mjs';
+import { moneyText } from '../domain/economy/money.ts';
+import { talentLinkFromTalents } from '../domain/character/talentLink.ts';
+import { linkFromClassicdbHash } from '../domain/character/talentImport.ts';
+
+function applied(app, r) {
+  app.result(r, r.ok ? `Your talents are now ${r.name}${r.cost ? ` (respec ${moneyText(r.cost)})` : ''}.` : '');
+}
+
+/** Spent points cost a respec; say the price before doing it. */
+function withRespec(app, label, run) {
+  const cost = app.g.respecCost();
+  if (cost > 0) app.confirm(`Switch to ${label}? The respec costs ${moneyText(cost)}.`, () => applied(app, run()));
+  else applied(app, run());
+}
+
+export function myTalentLink(app) {
+  return talentLinkFromTalents(app.ch.talents ?? {}, app.ch.cls, app.ds);
+}
+
+/** A pasted string: bare digits ("3030502-05"), or a classicdb talent URL / hash. */
+function parseLink(app, raw) {
+  const text = raw.trim();
+  if (/^[0-9-]+$/.test(text)) return text;
+  const hash = text.includes('?') ? text.slice(text.lastIndexOf('?') + 1) : text.includes('#') ? text.slice(text.lastIndexOf('#') + 1) : text;
+  const fromDb = linkFromClassicdbHash(hash, app.ds);
+  if (fromDb && fromDb.cls !== app.ch.cls) return { error: 'That build is for another class.' };
+  return fromDb?.link ?? { error: 'Not a talent string. Paste digits like 30305-0505 or a classicdb talent link.' };
+}
+
+export function talentBuildsMenu(app) {
+  const g = app.g, cls = app.ch.cls;
+  const specs = app.ds.botSpecs(cls) ?? [];
+  const saved = (g.state.talentBuilds ?? []).filter((b) => b.cls === cls);
+  const mine = myTalentLink(app);
+  const opts = [
+    ...specs.map((s, i) => ({ label: `${dim('premade ')} ${s.name}`, value: () => withRespec(app, s.name, () => g.applyPremadeSpec(i)) })),
+    ...saved.map((b) => ({ label: `${cyan('saved   ')} ${b.name}${b.link === mine ? green('  ● current') : ''}`, detail: () => [bold(b.name), dim(b.link)], value: () => savedMenu(app, b) })),
+    { label: green('Save my talents as a build'), value: () => app.prompt('Name: ', (name) => { const r = g.saveTalentBuild(name, cls, mine); app.result(r, r.ok ? `Saved ${r.name}.` : ''); app.afterAction(); }) },
+    { label: 'Paste a talent string', value: () => app.prompt('Talent string or classicdb link: ', (raw) => {
+      const link = parseLink(app, raw);
+      if (typeof link !== 'string') { app.say(red(link.error)); app.afterAction(); return; }
+      withRespec(app, 'that build', () => g.applyTalentLink(link));
+      app.afterAction();
+    }) },
+    { label: `Show my talent string  ${dim(mine || 'nothing spent')}`, value: () => app.say(`Your talents: ${yellow(mine || '(none)')}`) },
+  ];
+  app.pick('Talent builds', opts, (fn) => fn());
+}
+
+function savedMenu(app, b) {
+  app.pick(b.name, [
+    { label: 'Use this build', value: () => withRespec(app, b.name, () => app.g.applyTalentBuild(b.id)) },
+    { label: `Show its string  ${dim(b.link)}`, value: () => app.say(`${b.name}: ${yellow(b.link)}`) },
+    { label: red('Delete it'), value: () => app.confirm(`Delete the ${b.name} build?`, () => app.result(app.g.deleteTalentBuild(b.id), `${b.name} deleted.`)) },
+  ], (fn) => fn());
+}