azeroth-shell 0.1.2 → 0.3.0

package/src/cli/tuiWiki.mjs

@@ -2,11 +2,10 @@
 // (items, spells, quests, NPCs, talents, recipes, zones, dungeons, objects, factions); Tab narrows to one kind.
 // A page lists what links to it (where an item drops, who sells it, which quest rewards it, who teaches a spell)
 // as rows: Enter follows a link, Esc goes back. Search and sources are phonecraft's own pure indexes.
-import { bold, dim, yellow, green, red, cyan, qualityPaint, wrapLines } from './text.mjs';
+import { bold, dim, yellow, green, red, cyan, qualityPaint, wrapLines, coinText } from './text.mjs';
 import { itemLines, spellLines, creatureLines, rewardLines } from './tuiViews.mjs';
 import { wikiIndex, wikiTokens, wikiSearch, WIKI_KINDS, WIKI_KIND_LABEL, WIKI_KIND_ONE } from './wikiIndex.ts';
 import { wikiSourceIndexSync } from './wikiSources.ts';
-import { moneyText } from '../domain/economy/money.ts';
 import { className } from '../domain/core/ids.ts';
 
 const H = (text) => ({ text, header: true });
@@ -135,7 +134,7 @@ function pageLinks(app, kind, id) {
       section('Reputation', (q.rewRep ?? []).filter((r) => r.value).map((r) => link(app, 'faction', r.faction, `${ds.faction(r.faction)?.name ?? r.faction} ${r.value > 0 ? '+' : ''}${r.value}`)));
       const chain = [q.prevQuest && ['Comes after', q.prevQuest], q.nextQuest && ['Leads to', q.nextQuest]].filter(Boolean);
       for (const [label, e] of chain) section(label, [link(app, 'quest', e, ds.quest(e)?.title ?? String(e))]);
-      rows.push(H(''), H(dim(`From ${q.starterName || '?'}, to ${q.enderName || '?'}${q.rewMoney ? `, ${moneyText(q.rewMoney)}` : ''}`)));
+      rows.push(H(''), H(dim(`From ${q.starterName || '?'}, to ${q.enderName || '?'}${q.rewMoney ? `, ${coinText(q.rewMoney)}` : ''}`)));
     }
   } else if (kind === 'recipe') {
     const r = ds.recipe(id);

package/src/cli/tuiWorld.mjs

@@ -1,14 +1,20 @@
 // World-tab extras that are not a creature fight, a quest or a vendor: pick pocket for rogues (P on a creature)
 // real-time journeys, riding (instructors, mounts), and the zone's objects (chests, books, quest objects).
-import { bold, dim, yellow, red, green, cyan, bar, wrapLines } from './text.mjs';
+import { bold, dim, yellow, red, green, cyan, bar, wrapLines, coinText } from './text.mjs';
 import { startFight } from './tuiFight.mjs';
 import { knownUsableSpells } from '../domain/character/characterSpells.ts';
 import { activeStealthAura } from '../domain/character/buildCombatant.ts';
+import { inferRole } from '../engine/combat.ts';
+import { countItem } from '../domain/items/inventory.ts';
+import { requiresSourceUseCredit } from '../domain/quests/questlog.ts';
+import { tamingRodByQuestId } from '../domain/quests/questTameRods.ts';
+import { pendingCorpseUseItem } from '../domain/quests/questCorpseUse.ts';
+import { pendingScriptItemUse } from '../domain/quests/questScriptItemUse.ts';
 import { pickpocketLootKey, canRestockPickpocket } from '../domain/professions/pickpocket.ts';
-import { moneyText } from '../domain/economy/money.ts';
 import { vendorPriceMultiplierFor, trainerSpellCost } from '../engine/game/vendorOffers.ts';
-import { questDialog } from './tuiViews.mjs';
+import { questDialog, npcLines } from './tuiViews.mjs';
 import { mailDialog } from './tuiCity.mjs';
+import { withWorldMap } from './tuiMap.mjs';
 import { autoLootOn, openLoot, takeAll } from './tuiLoot.mjs';
 import { zoneGameObjects, zoneGoListedForPlayer, makeGoPlayerVisibility, questReferencedGoEntries, questTargets } from '../world/world.ts';
 import { goQuestGiverOffer, goDialogMarkerFromOffer, questStatusFromLog } from '../domain/quests/questlog.ts';
@@ -54,6 +60,82 @@ export function pickPocketTag(app, creature) {
   return st === 'ready' ? dim('  P: pick pocket') : st === 'empty' ? dim('  pockets empty') : '';
 }
 
+// ---- taming ----------------------------------------------------------------------------------------------
+// The facade's tamePet is ungated, so the row gates it as phonecraft's worldView does: a hunter who has learned
+// Tame Beast (the pet quest's reward) and has no pet out. While a Taming the Beast quest is open, its rod takes
+// the place of the tame on the beast it names (useQuestItemOnTarget credits it). Ref worldView.ts:155.
+
+const HUNTER = 3;
+
+/** The Tame Beast rank you know, or undefined. */
+export function tameSpell(app) {
+  if (app.ch.cls !== HUNTER) return undefined;
+  return knownUsableSpells(app.ch, app.g.state.spellbook, app.ds).find((s) => (s.role ?? inferRole(s)) === 'pet_tame');
+}
+
+/** A quest item to use on a creature: the open Taming the Beast quest's rod (only on its beast), or a use-to-credit source item (on a tameable beast). */
+export function questUseItem(app) {
+  const inv = app.g.state.inventory;
+  for (const qs of app.g.state.questlog.quests) {
+    if (qs.status === 'turnedIn' || qs.status === 'complete') continue;
+    const rod = tamingRodByQuestId(qs.entry);
+    if (rod && countItem(inv, rod.item) >= 1) { const it = app.ds.item(rod.item); if (it) return { entry: it.entry, name: it.name, onlyCreature: rod.targetCreature }; }
+    const q = app.ds.quest(qs.entry);
+    if (!q || !requiresSourceUseCredit(q)) continue;
+    for (const t of q.sourceItemTargets ?? []) { if (countItem(inv, t.item) < 1) continue; const it = app.ds.item(t.item); if (it) return { entry: it.entry, name: it.name }; }
+  }
+  return undefined;
+}
+
+const useItemFits = (use, creature) => !!use && (use.onlyCreature != null ? creature.entry === use.onlyCreature : !!creature.tameable);
+
+/** What t on this creature does: 'use' (a quest item), 'tame', or why not ('' when it is not for t at all). */
+export function tameState(app, creature) {
+  if (useItemFits(questUseItem(app), creature)) return 'use';
+  if (app.ch.cls !== HUNTER || !creature.tameable) return '';
+  if (!tameSpell(app)) return 'unlearned';
+  return app.ch.pet ? 'pet' : 'tame';
+}
+
+export function tameTag(app, creature) {
+  const st = tameState(app, creature);
+  return st === 'use' ? dim(`  t: use ${questUseItem(app).name}`) : st === 'tame' ? dim('  t: tame') : '';
+}
+
+/** t on a creature: use the quest item on it, or tame it. */
+export function tame(app, creature) {
+  const st = tameState(app, creature);
+  if (st === 'use') {
+    const use = questUseItem(app);
+    app.result(app.g.useQuestItemOnTarget({ itemEntry: use.entry, targetCreatureEntry: creature.entry }), `You use ${use.name} on ${creature.name}.`);
+    return;
+  }
+  if (app.ch.cls !== HUNTER) { app.flashMsg('Only hunters tame beasts.'); return; }
+  if (!creature.tameable) { app.flashMsg(`${creature.name} cannot be tamed.`); return; }
+  if (st === 'unlearned') { app.flashMsg('Learn Tame Beast first: the hunter trainer sends you on the taming quests at level 10.'); return; }
+  if (st === 'pet') { app.flashMsg(`Dismiss or stable ${app.ch.pet.name} before taming another.`); return; }
+  app.result(app.g.tamePet(creature.entry), `You tame ${creature.name}.`);
+}
+
+// ---- right here: loot left behind, and quest items used on a corpse or a creature the list never offers -------
+// Ref worldView.ts:551-582. A corpse item (Bramble, a molt) goes on your last kill; a script item (Lazy Peons'
+// blackjack) goes on a civilian, who is never on the creature list.
+
+export function hereRows(app) {
+  const g = app.g, ds = app.ds, inv = g.state.inventory, rows = [];
+  const left = g.pendingLoot();
+  if (left && app.top()?.id !== 'loot') rows.push({ text: `${yellow('Loot')} ${left.title ?? 'what you left'}  ${dim('still lootable')}`, detail: () => [bold(left.title ?? 'Loot'), 'You closed it with things still in it.', '', dim('Enter: open it again')], act: () => openLoot(app) });
+  const active = g.state.questlog.quests.filter((qs) => qs.status === 'active').map((qs) => ({ qs, q: ds.quest(qs.entry) })).filter((x) => x.q);
+  const useRow = (item, target, q) => {
+    const it = ds.item(item), on = target ? ds.creature(target)?.name ?? `creature ${target}` : ds.creature(g.state.lastCorpse?.creatureEntry ?? 0)?.name ?? 'the corpse';
+    return { text: `${yellow('Use')} ${it?.name ?? `item ${item}`} on ${on}  ${dim(q.title)}`, icon: it?.icon, detail: () => [bold(`Use ${it?.name ?? 'item'} on ${on}`), `For ${q.title}.`, '', dim('Enter: use it')], act: () => app.result(g.useQuestItemOnTarget({ itemEntry: item, ...(target ? { targetCreatureEntry: target } : {}) }), `You use ${it?.name ?? 'it'} on ${on}.`) };
+  };
+  const corpse = active.map(({ q }) => ({ q, item: pendingCorpseUseItem(ds, q, inv, g.state.lastCorpse) })).find((x) => x.item);
+  if (corpse) rows.push(useRow(corpse.item, 0, corpse.q));
+  for (const { q, qs } of active) { const u = pendingScriptItemUse(ds, q, qs, inv, app.ch.zoneId); if (u) { rows.push(useRow(u.item, u.targetCreatureEntry, q)); break; } }
+  return rows.length ? [{ text: '', header: true }, { text: 'Here', header: true }, ...rows] : [];
+}
+
 // ---- journeys ------------------------------------------------------------------------------------------
 // With a real-time travel pace (Settings) a trip takes wall-clock time: the game loop calls journeyTick, the
 // header shows where you are headed, and the World and Travel tabs carry this card. Instant pace never gets here.
@@ -101,7 +183,8 @@ export function journeyRows(app) {
     { text: `${bar(st.progress.totalElapsedSeconds, total, 30, cyan)} ${mmss(st.progress.remainingSeconds)} left${app.travelPaused ? yellow('  paused') : ''}`, header: true },
     {
       text: `${leg ? `${leg.kind} ${app.ds.zone(leg.from)?.name ?? leg.from} → ${app.ds.zone(leg.to)?.name ?? leg.to}` : ''}  ${dim(`${st.timeScale}x   Enter: journey options`)}`,
-      detail: () => [bold(`To ${dest}`), '', ...st.legs.map((l, i) => `${i < st.progress.legIndex ? green('✓') : i === st.progress.legIndex ? cyan('▶') : dim('·')} ${l.kind} ${app.ds.zone(l.from)?.name ?? l.from} → ${app.ds.zone(l.to)?.name ?? l.to} ${dim(mmss(l.seconds))}`), '', dim('Enter: speed, pause, arrive now, turn back')],
+      // The legs, then the world map with the traveller walking the current one (tuiMap.mjs).
+      detail: () => withWorldMap(app, [bold(`To ${dest}`), '', ...st.legs.map((l, i) => `${i < st.progress.legIndex ? green('✓') : i === st.progress.legIndex ? cyan('▶') : dim('·')} ${l.kind} ${app.ds.zone(l.from)?.name ?? l.from} → ${app.ds.zone(l.to)?.name ?? l.to} ${dim(mmss(l.seconds))}`), '', dim('Enter: speed, pause, arrive now, turn back')]),
       act: (a) => journeyMenu(a),
     },
     { text: '', header: true },
@@ -130,7 +213,7 @@ export function ridingRows(app) {
     const name = app.ds.creature(entry)?.name ?? `Riding Instructor (${entry})`;
     return {
       text: `${name} ${dim('<Riding Instructor>')}${app.ch.ridingSkill ? dim(`  you ride at ${app.ch.ridingSkill}`) : ''}`,
-      detail: () => [bold(name), 'Riding instructor', `Your riding: ${app.ch.ridingSkill ?? 0}`, '', dim('Enter: learn to ride')],
+      detail: () => npcLines(app, entry, [bold(name), 'Riding instructor', `Your riding: ${app.ch.ridingSkill ?? 0}`, '', dim('Enter: learn to ride')]),
       act: (a) => ridingDialog(a, entry),
     };
   });
@@ -146,11 +229,11 @@ function ridingDialog(app, entry) {
     seen.add(sp.rank);
     const cost = trainerSpellCost(sp.cost, mod);
     const why = have >= sp.rank ? 'known' : sp.step > 1 && have < 75 ? 'needs Apprentice Riding' : app.ch.level < sp.reqLevel ? `level ${sp.reqLevel}` : app.ch.gold < cost ? 'not enough money' : '';
-    opts.push({ label: `${why ? dim(`Riding ${sp.rank}`) : green(`Riding ${sp.rank}`)}  ${dim(`level ${sp.reqLevel}, ${moneyText(cost)}`)}${why ? dim(`  ${why}`) : ''}`, value: sp.rank });
+    opts.push({ label: `${why ? dim(`Riding ${sp.rank}`) : green(`Riding ${sp.rank}`)}  ${dim(`level ${sp.reqLevel}, ${coinText(cost)}`)}${why ? dim(`  ${why}`) : ''}`, value: sp.rank });
   }
   app.pick(`${app.ds.creature(entry)?.name ?? 'Riding instructor'}`, opts, (rank) => {
     const r = app.g.trainRiding(entry, rank);
-    app.result(r, r.ok ? `You learn Riding (${r.rank}) for ${moneyText(r.spent)}.` : '');
+    app.result(r, r.ok ? `You learn Riding (${r.rank}) for ${coinText(r.spent)}.` : '');
   });
 }
 

package/src/data/hd-art.json

@@ -0,0 +1,114 @@
+{
+  "tag": "art-2",
+  "base": "https://github.com/LienSimen/azsh/releases/download/art-2/",
+  "files": [
+    {
+      "name": "model-art-hd.bin.br",
+      "path": "model-art-hd.bin.br",
+      "size": 19637101,
+      "sha256": "347fffd9272586dff2eeec7b6763ae0814701906fdcb3bb6217046130240acc8"
+    },
+    {
+      "name": "icon-art-hd.bin.br",
+      "path": "icon-art-hd.bin.br",
+      "size": 5183918,
+      "sha256": "fc66716b4403d443f7a22da6bf956464220923c5faa80245070bd4ca1e556501"
+    },
+    {
+      "name": "gear-art-hd-dwarf-female.bin.br",
+      "path": "gear-art-hd/dwarf-female.bin.br",
+      "size": 10001585,
+      "sha256": "a96907c4ecf9dfb1d9cf9d5614fb06a1e09998e70bbfd17e55c6e79a6ad8b4ad"
+    },
+    {
+      "name": "gear-art-hd-dwarf-male.bin.br",
+      "path": "gear-art-hd/dwarf-male.bin.br",
+      "size": 14404864,
+      "sha256": "e096f75a13261756312d2472130d43e09f90cfeaa2327a4b4f8d9c96d6b52c1c"
+    },
+    {
+      "name": "gear-art-hd-gnome-female.bin.br",
+      "path": "gear-art-hd/gnome-female.bin.br",
+      "size": 11048883,
+      "sha256": "cdbb81d645ecd01c48c25d06982e372e6f697ad29862c72dac9fcfb59fd4d16c"
+    },
+    {
+      "name": "gear-art-hd-gnome-male.bin.br",
+      "path": "gear-art-hd/gnome-male.bin.br",
+      "size": 11875475,
+      "sha256": "c4440b1475ecb73d290140619eb99196d32f3417e27d2e04384b5378cf49730d"
+    },
+    {
+      "name": "gear-art-hd-human-female.bin.br",
+      "path": "gear-art-hd/human-female.bin.br",
+      "size": 7089810,
+      "sha256": "5c4d7d3d39a445bdbf7ff43d7e412a0a8679a841f2376eb1dc7aa54f16995bd2"
+    },
+    {
+      "name": "gear-art-hd-human-male.bin.br",
+      "path": "gear-art-hd/human-male.bin.br",
+      "size": 9311191,
+      "sha256": "207abf704dd8efea247efc2a51a466715b89c55381ce5efb4915377a53dd45ee"
+    },
+    {
+      "name": "gear-art-hd-nightelf-female.bin.br",
+      "path": "gear-art-hd/nightelf-female.bin.br",
+      "size": 6381920,
+      "sha256": "0b7bf823059d380bfb7f72a18863a17e44023aba87b219d2416a7e4b6583e055"
+    },
+    {
+      "name": "gear-art-hd-nightelf-male.bin.br",
+      "path": "gear-art-hd/nightelf-male.bin.br",
+      "size": 9122533,
+      "sha256": "3711a86d14fa788ab5ecdf49dcd9eae30409a7a30bd59ed1849672ed52f01794"
+    },
+    {
+      "name": "gear-art-hd-orc-female.bin.br",
+      "path": "gear-art-hd/orc-female.bin.br",
+      "size": 8417526,
+      "sha256": "eb3ba4150f9146725ed530798e56d47128d67be79ae597db267c087fa9786688"
+    },
+    {
+      "name": "gear-art-hd-orc-male.bin.br",
+      "path": "gear-art-hd/orc-male.bin.br",
+      "size": 13171006,
+      "sha256": "2c41e7fea6ab2db7e5b1c64990dc9d963240610d7bfe52e5ec496da9cd392f5b"
+    },
+    {
+      "name": "gear-art-hd-tauren-female.bin.br",
+      "path": "gear-art-hd/tauren-female.bin.br",
+      "size": 8849291,
+      "sha256": "fe7f37cd80abfcbab36e54cfd50311833457f6b98a1cea34e87ae031965bc35a"
+    },
+    {
+      "name": "gear-art-hd-tauren-male.bin.br",
+      "path": "gear-art-hd/tauren-male.bin.br",
+      "size": 12346906,
+      "sha256": "b718b1abdf972a602636a5b3ccf15ce9eb6f9714b8d29e8c78682fa4e0962c05"
+    },
+    {
+      "name": "gear-art-hd-troll-female.bin.br",
+      "path": "gear-art-hd/troll-female.bin.br",
+      "size": 6684064,
+      "sha256": "f1bef8c28ad0d267a14118b830309f952cc40acd95bb79954e3a720f5e2916ef"
+    },
+    {
+      "name": "gear-art-hd-troll-male.bin.br",
+      "path": "gear-art-hd/troll-male.bin.br",
+      "size": 8909278,
+      "sha256": "f58f08e62a6f23295b887a3b97657eb4f3e097e47e17aa0f3e94111500b69f26"
+    },
+    {
+      "name": "gear-art-hd-undead-female.bin.br",
+      "path": "gear-art-hd/undead-female.bin.br",
+      "size": 7500090,
+      "sha256": "d99136b4fa6edef4fdc676dbb5e988e4bf3b65a125ce1de8b84b889ae17d06a9"
+    },
+    {
+      "name": "gear-art-hd-undead-male.bin.br",
+      "path": "gear-art-hd/undead-male.bin.br",
+      "size": 9072949,
+      "sha256": "d421f1719d60abcbe466775bc724710d5adc0049e89dbbc29fd0c64151351f2b"
+    }
+  ]
+}

package/src/data/rotations/pve/paladin/retribution.json

@@ -394,7 +394,7 @@
     ],
     "pull": [
       {
-        "spell": "Seal of Righteousness",
+        "spell": "Seal of Command / Seal of Righteousness",
         "when": "buff absent",
         "conditions": [
           {
@@ -520,7 +520,7 @@
         ]
       },
       {
-        "spell": "Seal of Righteousness",
+        "spell": "Seal of Command / Seal of Righteousness",
         "when": "buff absent",
         "conditions": [
           {

package/src/domain/bg/match.ts

@@ -128,7 +128,7 @@ export class BgMatch {
           // Guard on "already registered dead", NOT alive(): a unit the resolver just took to 0 hp
           // is already !alive, so that guard skipped kill() and the roster piled up as corpses.
           if (!u || u.deadUntilMs != null) continue;
-          this.world.kill(u, this.respawnMs);
+          this.world.kill(u, this.respawnWaitMs());
           this.deaths++;
         }
       }
@@ -136,6 +136,19 @@ export class BgMatch {
 
   }
 
+  // The spirit healer raises everyone waiting at once, every respawnMs on the match clock; a body that
+  // fell just before the wave has not released yet and waits for the next. Cite: BattleGround.cpp
+  // RESURRECTION_INTERVAL, m_LastResurrectTime. Per-death timers made the dead trickle back one at a
+  // time, each walking alone into the side that had just killed them: 95 deaths, 0-0 after 20 minutes.
+  respawnWaitMs(): number {
+    const cycle = this.respawnMs;
+    if (!(cycle > 0)) return 0;
+    const t = this.world.t;
+    let wait = cycle - (((t % cycle) + cycle) % cycle);
+    if (wait < RELEASE_MS) wait += cycle;
+    return wait;
+  }
+
   stats(): BgMatchStats {
     return {
       ticks: this.ticks,
@@ -153,18 +166,57 @@ export class BgMatch {
   }
 }
 
+/** A body that fell this close to the wave misses it: the ghost has not released yet. */
+const RELEASE_MS = 3000;
+
 /** Classes that can hold someone up: paladin, priest, druid, shaman. Cite: domain/ids CLASS. */
 const HEALER_CLASSES = new Set([2, 5, 7, 11]);
 
-// A deliberately simple shard resolver for probes and auto-resolve: units in contact chip the
-// nearest enemy and healers top up allies. Without the healing half, 112 pickups gave 2 captures.
+// A seat heals if its roster role says so; a seat with no role falls back to the class. The class
+// alone made six of ten bodies a side "healers" on a real roster (every paladin, priest, shaman and
+// druid), so four attackers chipped at six healers and a 10v10 ran minutes without a death.
+const isHealer = (u: BgUnit): boolean => u.heals ?? HEALER_CLASSES.has(u.cls);
+
+// The body the flat rates were tuned on: a level-60 seat. Damage and healing scale with the FIELD's
+// average pool, so a level-20 field of 560-hp bodies trades as a level-60 field of 3,000 does, while
+// a 970-hp warrior on it still outlasts a 380-hp warlock. Flat 60 dps killed a level-22 flag carrier
+// in nine seconds, so every pickup was a drop and a 12-minute match ended 0-0. Scaling by the
+// target's own pool was the first fix and made every body die in the same time, hp or no hp.
+export const ATTRITION_REF_HP = 3000;
+
+/** The field's mean max hp over the reference, recomputed once per match tick. */
+function poolScale(world: BgWorld, cache: { t: number; scale: number }): number {
+  if (cache.t === world.t) return cache.scale;
+  let sum = 0;
+  let n = 0;
+  for (const u of world.units.values()) { sum += u.maxHp; n++; }
+  cache.t = world.t;
+  cache.scale = n ? (sum / n) / ATTRITION_REF_HP : 1;
+  return cache.scale;
+}
+
+// A deliberately simple shard resolver for probes and auto-resolve: each side focuses one enemy (the
+// flag carrier if one is in the shard, else the most hurt) and healers top up allies. Without the
+// healing half, 112 pickups gave 2 captures; with "nearest" targeting instead of a focus, two healers
+// a side out-healed a 10v10 indefinitely.
 export function attritionResolver(dpsPerSecond = 60, hpsPerSecond = dpsPerSecond * 0.55): ShardResolver {
+  // Who each attacker hit last tick, so a side stays on its target until it drops.
+  const lastTarget = new WeakMap<BgUnit, BgUnit>();
+  const pool = { t: NaN, scale: 1 };
   return (world, shard, dtMs, rng) => {
+    const scale = poolScale(world, pool);
     const dead: BgUnitId[] = [];
     const units = shard.units.map((id) => world.units.get(id)!).filter((u) => world.alive(u));
     const dt = dtMs / 1000;
+    const focus: Record<BgTeam, BgUnit | null> = {
+      alliance: pickFocus(world, 'alliance', units, rng, lastTarget),
+      horde: pickFocus(world, 'horde', units, rng, lastTarget),
+    };
     for (const u of units) {
-      if (HEALER_CLASSES.has(u.cls)) {
+      // Dropped earlier this tick: no dead man's swing. The side iterated first used to take one from
+      // every body it killed, since the corpse's own turn still came round.
+      if (u.hp <= 0) continue;
+      if (isHealer(u)) {
         // Heal the most hurt friendly in the shard, self included.
         let target: BgUnit | null = null;
         let worst = Infinity;
@@ -174,13 +226,16 @@ export function attritionResolver(dpsPerSecond = 60, hpsPerSecond = dpsPerSecond
           if (pct < worst) { worst = pct; target = o; }
         }
         if (target && worst < 1) {
-          target.hp = Math.min(target.maxHp, target.hp + hpsPerSecond * dt);
+          target.hp = Math.min(target.maxHp, target.hp + hpsPerSecond * dt * scale);
           continue; // healing IS this unit's action for the tick
         }
       }
-      const foe = pickFoe(world, u, units, rng);
+      // The focus fell this tick: the rest of the side turns to the next one.
+      let foe = focus[u.team];
+      if (foe && !world.alive(foe)) foe = focus[u.team] = pickFocus(world, u.team, units, rng, lastTarget);
       if (!foe) continue;
-      foe.hp -= dpsPerSecond * dt;
+      lastTarget.set(u, foe);
+      foe.hp -= dpsPerSecond * dt * scale;
       if (foe.hp <= 0 && !dead.includes(foe.id)) {
         dead.push(foe.id);
         // `u` landed the killing chip — the only place the killer is known, and what the
@@ -192,24 +247,30 @@ export function attritionResolver(dpsPerSecond = 60, hpsPerSecond = dpsPerSecond
   };
 }
 
-/** Yards within which two foes count as equally close, so the pick is a real choice. */
-const FOE_TIE_YD = 8;
-
-// Nearest enemy, with ties broken from the seeded stream. The tie-break is what makes the seed mean
-// anything: strict nearest-first never touched the rng, so five seeds produced one identical match.
-function pickFoe(world: BgWorld, u: BgUnit, pool: BgUnit[], rng: Rng): BgUnit | null {
-  let bd = Infinity;
-  for (const o of pool) {
-    if (o.team === u.team || !world.alive(o)) continue;
-    const d = world.distance(u, o);
-    if (d < bd) bd = d;
-  }
-  if (!Number.isFinite(bd)) return null;
-  const close: BgUnit[] = [];
-  for (const o of pool) {
-    if (o.team === u.team || !world.alive(o)) continue;
-    if (world.distance(u, o) <= bd + FOE_TIE_YD) close.push(o);
+/** Health fraction within which two foes count as equally hurt, so the pick is a real choice. */
+const FOCUS_TIE_PCT = 0.1;
+
+// One side's target in a shard: the enemy carrying a flag; else the target the side was already on,
+// while it stands; else the most hurt enemy, ties broken from the seeded stream. The tie-break is
+// what makes the seed mean anything: a strict pick never touched the rng, so five seeds produced one
+// identical match. Sticking matters as much as focusing: re-picking "most hurt" every tick with a
+// tie band spread the damage over every body in reach, so a 10v10 ran 70 s with no death and then
+// seven bodies fell in the same five seconds.
+function pickFocus(world: BgWorld, team: BgTeam, pool: BgUnit[], rng: Rng, lastTarget: WeakMap<BgUnit, BgUnit>): BgUnit | null {
+  const foes = pool.filter((o) => o.team !== team && world.alive(o));
+  if (!foes.length) return null;
+  const carriers = foes.filter((o) => o.carryingFlag);
+  if (!carriers.length) {
+    for (const u of pool) {
+      if (u.team !== team || !world.alive(u)) continue;
+      const held = lastTarget.get(u);
+      if (held && foes.includes(held)) return held;
+    }
   }
+  const among = carriers.length ? carriers : foes;
+  let worst = Infinity;
+  for (const o of among) worst = Math.min(worst, o.hp / Math.max(1, o.maxHp));
+  const close = among.filter((o) => o.hp / Math.max(1, o.maxHp) <= worst + FOCUS_TIE_PCT);
   if (close.length <= 1) return close[0] ?? null;
   return close[Math.min(close.length - 1, Math.floor(rng.next() * close.length))]!;
 }