azeroth-shell 0.1.1 → 0.2.0

package/src/cli/tuiWorld.mjs

@@ -7,7 +7,7 @@ import { activeStealthAura } from '../domain/character/buildCombatant.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 { autoLootOn, openLoot, takeAll } from './tuiLoot.mjs';
 import { zoneGameObjects, zoneGoListedForPlayer, makeGoPlayerVisibility, questReferencedGoEntries, questTargets } from '../world/world.ts';
@@ -56,7 +56,7 @@ export function pickPocketTag(app, creature) {
 
 // ---- 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 tab opens on this card. Instant pace never gets here.
+// header shows where you are headed, and the World and Travel tabs carry this card. Instant pace never gets here.
 
 const PACES = ['instant', 1, 2, 4];
 export const paceLabel = (p) => (p === 'instant' ? 'instant' : `${p}x real time`);
@@ -86,8 +86,7 @@ export function journeyTick(app) {
   if (!app.g.state.char.journey) {
     app.say(green(`You arrive in ${app.zone()?.name ?? app.ch.zoneId}.`));
     app.journeyWas = null;
-    const world = app.tabs[0]?.view;
-    if (world) { world.cursor = 0; world.scroll = 0; }
+    for (const v of [app.tabs[0]?.view, app.top()]) if (v) { v.cursor = 0; v.scroll = 0; }
   }
 }
 
@@ -131,7 +130,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),
     };
   });

package/src/data/hd-art.json

@@ -0,0 +1,114 @@
+{
+  "tag": "art-1",
+  "base": "https://github.com/LienSimen/azsh/releases/download/art-1/",
+  "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": 5183379,
+      "sha256": "e92bb1e7fe58c1d5a13628cdd12beccf7254c9929dee216b773103452abb6bab"
+    },
+    {
+      "name": "gear-art-hd-dwarf-female.bin.br",
+      "path": "gear-art-hd/dwarf-female.bin.br",
+      "size": 3065094,
+      "sha256": "1c04ccce7f4c1ad24e2e437ca55a2081ad6eb2c589c2da8f05df36127d9729ca"
+    },
+    {
+      "name": "gear-art-hd-dwarf-male.bin.br",
+      "path": "gear-art-hd/dwarf-male.bin.br",
+      "size": 4447262,
+      "sha256": "7e1ff7f3a2f968034f14d53013d4e46c399314c9d3b9a2a242714a4d56b5a179"
+    },
+    {
+      "name": "gear-art-hd-gnome-female.bin.br",
+      "path": "gear-art-hd/gnome-female.bin.br",
+      "size": 3285698,
+      "sha256": "ddac7efdc36cc003ebb34b4811bfe49c86a6bad6c35fb7bb312fc2ad31054f11"
+    },
+    {
+      "name": "gear-art-hd-gnome-male.bin.br",
+      "path": "gear-art-hd/gnome-male.bin.br",
+      "size": 3748025,
+      "sha256": "3ba3e446a654ab2e2a394f60ea7e7d38d66991d1252e318d4e5060bbdf5a4357"
+    },
+    {
+      "name": "gear-art-hd-human-female.bin.br",
+      "path": "gear-art-hd/human-female.bin.br",
+      "size": 2183524,
+      "sha256": "036193451db30ed95cca8120158d5dc494c2210420f53835ba9bad3bcdd2887f"
+    },
+    {
+      "name": "gear-art-hd-human-male.bin.br",
+      "path": "gear-art-hd/human-male.bin.br",
+      "size": 2869717,
+      "sha256": "97fbd6604dec28c8bb68e6e301b1acc2f628a52d831a7c6f3cac3f7eab6d6883"
+    },
+    {
+      "name": "gear-art-hd-nightelf-female.bin.br",
+      "path": "gear-art-hd/nightelf-female.bin.br",
+      "size": 2000472,
+      "sha256": "321f9303ac0e48e71d09e1169a7f4f95e4c747012399da070b42d77e8a33920a"
+    },
+    {
+      "name": "gear-art-hd-nightelf-male.bin.br",
+      "path": "gear-art-hd/nightelf-male.bin.br",
+      "size": 2799028,
+      "sha256": "e9bbcedefb814729f746ae24bc80031627babf6c9bf89fe67ae6fc0783e3f420"
+    },
+    {
+      "name": "gear-art-hd-orc-female.bin.br",
+      "path": "gear-art-hd/orc-female.bin.br",
+      "size": 2639880,
+      "sha256": "65675608a4ef58ab0d19b79f712ce94c994ddadfa72371ec0503e83f1a6dc89f"
+    },
+    {
+      "name": "gear-art-hd-orc-male.bin.br",
+      "path": "gear-art-hd/orc-male.bin.br",
+      "size": 4227013,
+      "sha256": "09bf8130c09719ed0117b507f7baac3fa252bcfe189d2518cb4c4ad24042eff1"
+    },
+    {
+      "name": "gear-art-hd-tauren-female.bin.br",
+      "path": "gear-art-hd/tauren-female.bin.br",
+      "size": 2699924,
+      "sha256": "94cd59aad17351f3d44c338943f61143355f092e5a7a7961055fd46980a8c334"
+    },
+    {
+      "name": "gear-art-hd-tauren-male.bin.br",
+      "path": "gear-art-hd/tauren-male.bin.br",
+      "size": 3810060,
+      "sha256": "b0bd1bd0bdbc6d99846d9969d0136c7ca71fc70150527759cc3b424f1e5cbb33"
+    },
+    {
+      "name": "gear-art-hd-troll-female.bin.br",
+      "path": "gear-art-hd/troll-female.bin.br",
+      "size": 2053657,
+      "sha256": "af3a015cd97f3d37ee6401959a919254c768ea7305243251d1eaf9ffb2bcb8df"
+    },
+    {
+      "name": "gear-art-hd-troll-male.bin.br",
+      "path": "gear-art-hd/troll-male.bin.br",
+      "size": 2820001,
+      "sha256": "bef8de643988c386df9f2c125721692cfd8cda98670d6305f726c0e7f2413c3b"
+    },
+    {
+      "name": "gear-art-hd-undead-female.bin.br",
+      "path": "gear-art-hd/undead-female.bin.br",
+      "size": 2278891,
+      "sha256": "dc2dab19f7eda1af4e69a242509edc58c62a3ba0188ec28302dfa32a37d441e5"
+    },
+    {
+      "name": "gear-art-hd-undead-male.bin.br",
+      "path": "gear-art-hd/undead-male.bin.br",
+      "size": 2812557,
+      "sha256": "3a7d57acd0c824893cb346d7de782983a757b963791957311a6679b383c89545"
+    }
+  ]
+}

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))]!;
 }

package/src/domain/bg/strategies.ts

@@ -27,6 +27,19 @@ const enemyBase = (view: BgView): BgPos => {
   return { x: g.x, y: g.y };
 };
 
+// Each side's flag runs keep to one edge of the field, past the brawl at the mid point: Alliance
+// along the north side, Horde along the south, so the two runs never cross each other either.
+// A run straight through mid put the carrier inside the mid fight's 30 yd shard every time.
+const LANE_DY: Record<BgTeam, number> = { alliance: 90, horde: -90 };
+const laneWaypoint = (team: BgTeam): BgPos => ({ x: WSG_GEOMETRY.mid.x, y: WSG_GEOMETRY.mid.y + LANE_DY[team] });
+/** Toward `to` by the lane: the lane point while it is still ahead on the way, then `to` itself. */
+const viaLane = (unit: BgUnitView, team: BgTeam, to: BgPos): BgPos => {
+  const wp = laneWaypoint(team);
+  const dir = Math.sign(to.x - unit.pos.x);
+  if (dir !== 0 && Math.sign(wp.x - unit.pos.x) === dir && Math.abs(wp.x - unit.pos.x) > 15) return wp;
+  return to;
+};
+
 const ourFlag = (view: BgView) => view.objectives.find((o) => o.id === flagObjectiveId(view.team));
 const theirFlag = (view: BgView) =>
   view.objectives.find((o) => o.id === flagObjectiveId(OTHER_TEAM[view.team]));
@@ -37,6 +50,21 @@ const ourCarrier = (view: BgView): BgUnitView | undefined =>
 const theirCarrier = (view: BgView): BgUnitView | undefined =>
   view.enemies.find((u) => u.carryingFlag && u.alive);
 
+// Both flags carried: neither side can score until the other carrier dies and the flag returns. Left to
+// escorting and holding, both teams sat on their own carrier at home and a 25-minute match had two
+// pickups. The field goes to kill their carrier; the defenders stay with ours.
+const doubleCarry = (view: BgView): boolean => !!ourCarrier(view) && !!theirCarrier(view);
+
+const nearestOf = <T extends { pos: BgPos }>(from: BgPos, list: readonly T[]): T | undefined => {
+  let best: T | undefined;
+  let bd = Infinity;
+  for (const o of list) {
+    const d = dist(from, o.pos);
+    if (d < bd) { bd = d; best = o; }
+  }
+  return best;
+};
+
 const nearestVisibleEnemy = (unit: BgUnitView, view: BgView): BgUnitView | undefined => {
   let best: BgUnitView | undefined;
   let bd = Infinity;
@@ -55,7 +83,7 @@ const runFlagHome: BgAction = {
   name: 'runFlagHome',
   relevance: () => 100,
   available: (unit) => !!unit.carryingFlag,
-  order: (_unit, view) => ({ kind: 'move', to: homeBase(view) }),
+  order: (unit, view) => ({ kind: 'move', to: viaLane(unit, view.team, homeBase(view)) }),
 };
 
 // Our own flag is on the ground: touching it returns it. Urgent — a dropped flag returns itself in 10 s,
@@ -70,18 +98,38 @@ const returnOurFlag: BgAction = {
   },
 };
 
+/** How far the flag runner will step aside to help kill the enemy carrier; beyond it they keep running. */
+const RUNNER_PEEL_YD = 60;
+/** An enemy carrier this close pulls a body out of the fight it is in. */
+const CARRIER_PEEL_YD = 60;
+/** A carrier of ours this close does too. */
+const CARRIER_HELP_YD = 100;
+
 // Chase whoever has our flag. Its FLOOR must stay above holdOurBase (70): at 50, defenders
 // preferred an already-safe base over retrieving the flag, and both teams sat at 0-0 forever.
+// The flag runner is the exception: a cross-carry is how a stalemate breaks, so they only peel onto
+// a carrier who runs past them.
 const chaseEnemyCarrier: BgAction = {
   name: 'chaseEnemyCarrier',
   relevance: (unit, view) => {
     const c = theirCarrier(view);
     if (!c) return 0;
-    // Closer chasers care more, so the whole team does not peel onto one runner — but even
-    // the furthest chaser outranks holding a base.
-    return 95 - Math.min(20, dist(unit.pos, c.pos) / 40);
+    if (unit.role === 'flag-carrier') return 90;
+    // A carrier passing close outranks everything but the flag actions; a far one still outranks
+    // holding a base (70), but not the fight this body is in (82): with every mid fighter peeling
+    // onto a carrier 200 yd away, the whole brawl migrated and the runs always died in it.
+    return dist(unit.pos, c.pos) < CARRIER_PEEL_YD ? 95 : 75;
+  },
+  available: (unit, view) => {
+    if (unit.carryingFlag) return false;
+    const c = theirCarrier(view);
+    if (!c) return false;
+    const d = dist(unit.pos, c.pos);
+    if (unit.role === 'flag-carrier') return d < RUNNER_PEEL_YD;
+    // In a double carry a defender guards our carrier instead of crossing the map.
+    if (unit.role === 'defense' && doubleCarry(view)) return d < CARRIER_PEEL_YD;
+    return true;
   },
-  available: (unit, view) => !unit.carryingFlag && !!theirCarrier(view),
   // `follow`, NOT attack-move to a position: the strategy layer runs at 1 Hz, so a position order
   // sends an equal-speed chaser to where the carrier was a second ago and never closes.
   order: (_unit, view) => {
@@ -92,13 +140,18 @@ const chaseEnemyCarrier: BgAction = {
 
 // Stay on our carrier and kill what touches them. Open to every non-defense role: with escorts
 // alone a carrier ran 620 yd through the enemy team by itself and died within ~50 yd every time.
+// A carrier within reach outranks the fight a body is in (82), as a passing enemy carrier does;
+// one far away does not, so the mid fight is not abandoned for a run on the other side of the map.
 const escortCarrier: BgAction = {
   name: 'escortCarrier',
-  relevance: () => 80,
+  relevance: (unit, view) => {
+    const c = ourCarrier(view);
+    return c && dist(unit.pos, c.pos) < CARRIER_HELP_YD ? 84 : 80;
+  },
   available: (unit, view) => {
     if (unit.carryingFlag) return false;
     if (unit.role === 'defense') return false;
-    return !!ourCarrier(view);
+    return !!ourCarrier(view) && !theirCarrier(view);
   },
   order: (_unit, view) => {
     const c = ourCarrier(view);
@@ -106,18 +159,73 @@ const escortCarrier: BgAction = {
   },
 };
 
-/** Go take their flag. */
+// Our flag runner, alive and not yet carrying: the body the escorts walk in with.
+const ourRunner = (view: BgView): BgUnitView | undefined =>
+  view.own.find((u) => u.role === 'flag-carrier' && u.alive && !u.carryingFlag);
+
+// Walk in with the runner. Escorts used to wait at mid for a carrier to exist, so the runner went
+// into the enemy flag room alone, picked up, and died to the two defenders before anyone arrived.
+const escortRunner: BgAction = {
+  name: 'escortRunner',
+  relevance: () => 58,
+  available: (unit, view) => !unit.carryingFlag && !ourCarrier(view) && !!ourRunner(view) && ourRunner(view)!.id !== unit.id,
+  order: (_unit, view) => {
+    const r = ourRunner(view);
+    return r ? { kind: 'follow', target: r.id } : null;
+  },
+};
+
+/** An escort this close is with the runner; farther, the runner goes back for them. */
+const ESCORT_WITH_YD = 25;
+/** An escort farther than this from the runner is somebody the runner should wait for. */
+const ESCORT_FAR_YD = 40;
+
+/** Our living escorts who are not carrying anything. */
+const ourEscorts = (view: BgView): BgUnitView[] =>
+  view.own.filter((u) => u.role === 'fc-escort' && u.alive && !u.carryingFlag);
+
+// The runner does not walk into the enemy flag room alone. With escorts alive but elsewhere (held in
+// a fight at mid, or just back from the graveyard) the runner goes to the nearest one; once an escort
+// is beside them, grabEnemyFlag takes over and the group walks in together. Alone, a level-22 runner
+// picked up and died to the two defenders in nine seconds, sixteen times in a row: 0-0 after 20 min.
+const waitForEscort: BgAction = {
+  name: 'waitForEscort',
+  relevance: () => 86,
+  available: (unit, view) => {
+    if (unit.role !== 'flag-carrier' || unit.carryingFlag) return false;
+    const escorts = ourEscorts(view).filter((e) => e.id !== unit.id);
+    if (!escorts.length) return false;
+    if (escorts.some((e) => dist(e.pos, unit.pos) < ESCORT_WITH_YD)) return false;
+    return escorts.some((e) => dist(e.pos, unit.pos) > ESCORT_FAR_YD);
+  },
+  order: (unit, view) => {
+    const e = nearestOf(unit.pos, ourEscorts(view).filter((o) => o.id !== unit.id));
+    return e ? { kind: 'follow', target: e.id } : null;
+  },
+};
+
+/** A dropped flag this close is anyone's to pick up before it returns itself in 10 s. */
+const GROUND_FLAG_REACH_YD = 60;
+
+// Go take their flag. The runner walks across the map for it; a fighter in reach of a dropped one
+// picks it up (a pass, in WSG terms); everyone else only takes it from the ground when it is near.
 const grabEnemyFlag: BgAction = {
   name: 'grabEnemyFlag',
-  relevance: (unit) => (unit.role === 'flag-carrier' ? 85 : unit.role === 'offense' ? 60 : 20),
+  relevance: (unit, view) => {
+    const f = theirFlag(view);
+    if (f?.state === 'ground' && unit.role !== 'defense' && dist(unit.pos, f.pos) < GROUND_FLAG_REACH_YD) return 90;
+    return unit.role === 'flag-carrier' ? 85 : unit.role === 'offense' ? 42 : 20;
+  },
   available: (unit, view) => {
     if (unit.carryingFlag) return false;
     const f = theirFlag(view);
     return f?.state === 'base' || f?.state === 'ground';
   },
-  order: (_unit, view) => {
+  order: (unit, view) => {
     const f = theirFlag(view);
-    return f ? { kind: 'attack-move', to: f.pos } : { kind: 'attack-move', to: enemyBase(view) };
+    const to = f ? f.pos : enemyBase(view);
+    // The runner walks the lane in; a dropped flag is wherever it fell, so it is walked to straight.
+    return { kind: 'attack-move', to: unit.role === 'flag-carrier' && f?.state !== 'ground' ? viaLane(unit, view.team, to) : to };
   },
 };
 
@@ -138,21 +246,38 @@ const holdOurBase: BgAction = {
   },
 };
 
-/** Contest the middle — where the two flag runs cross. */
+/** Standing this close to the mid point is holding it. */
+const MID_HELD_YD = 40;
+
+// Contest the middle — where the two flag runs cross. Walking there outranks an enemy in reach;
+// once there, an enemy in reach outranks standing on the point, or two groups stood 50 yd apart
+// at mid for a whole match and watched each other's runners walk past.
 const contestMid: BgAction = {
   name: 'contestMid',
-  relevance: (unit) => (unit.role === 'mid' ? 55 : 25),
+  relevance: (unit) => {
+    if (unit.role !== 'mid') return 25;
+    return dist(unit.pos, WSG_GEOMETRY.mid) > MID_HELD_YD ? 55 : 30;
+  },
   available: (unit) => !unit.carryingFlag,
   order: () => ({ kind: 'attack-move', to: { ...WSG_GEOMETRY.mid } }),
 };
 
-/** Fight what is in front of you. The floor action — always available, always lowest. */
+/** Touching distance: a fight you are in. */
+const ENGAGE_CONTACT_YD = 25;
+/** An enemy this close is worth walking over to. */
+const ENGAGE_REACH_YD = 60;
+
+// Fight what is in front of you. In contact it outranks escorting (80) and the offense grab (42), so
+// a body finishes the fight it is in instead of walking off mid-swing with the enemy on its back; it
+// stays under the runner's grab (85), the carrier chase and the flag actions. In reach it outranks
+// holding mid; far away it is the floor.
 const engageNearest: BgAction = {
   name: 'engageNearest',
   relevance: (unit, view) => {
     const foe = nearestVisibleEnemy(unit, view);
     if (!foe) return 0;
-    return dist(unit.pos, foe.pos) < 25 ? 50 : 10;
+    const d = dist(unit.pos, foe.pos);
+    return d < ENGAGE_CONTACT_YD ? 82 : d < ENGAGE_REACH_YD ? 45 : 10;
   },
   available: (unit, view) => !unit.carryingFlag && !!nearestVisibleEnemy(unit, view),
   // Same reason as chaseEnemyCarrier: track the unit, not a one-second-old point.
@@ -174,7 +299,7 @@ const carrierDisengage: BgAction = {
     );
     return !helpNear;
   },
-  order: (_unit, view) => ({ kind: 'retreat', to: homeBase(view) }),
+  order: (unit, view) => ({ kind: 'retreat', to: viaLane(unit, view.team, homeBase(view)) }),
 };
 
 // ---- Arathi Basin: nodes, not flags ----------------------------------------
@@ -192,16 +317,6 @@ const takeableNodes = (view: BgView) =>
 const nodesUnderAssault = (view: BgView) =>
   nodes(view).filter((o) => o.state === 'assaulted' && o.prevOwner === view.team);
 
-const nearestOf = <T extends { pos: BgPos }>(from: BgPos, list: readonly T[]): T | undefined => {
-  let best: T | undefined;
-  let bd = Infinity;
-  for (const o of list) {
-    const d = dist(from, o.pos);
-    if (d < bd) { bd = d; best = o; }
-  }
-  return best;
-};
-
 const abHome = (view: BgView): BgPos => {
   const s = AB_GEOMETRY.start[view.team];
   return { x: s.x, y: s.y };
@@ -475,7 +590,7 @@ export const AV_MID: BgPos = { ...AV_GEOMETRY.mid };
 export const BG_STRATEGIES = {
   'wsg.offense': {
     name: '~wsg.offense',
-    actions: [runFlagHome, carrierDisengage, escortCarrier, chaseEnemyCarrier, grabEnemyFlag, engageNearest, contestMid],
+    actions: [runFlagHome, carrierDisengage, escortCarrier, chaseEnemyCarrier, waitForEscort, grabEnemyFlag, engageNearest, contestMid],
   },
   'wsg.defense': {
     name: '~wsg.defense',
@@ -483,11 +598,11 @@ export const BG_STRATEGIES = {
   },
   'wsg.fc-escort': {
     name: '~wsg.fc-escort',
-    actions: [runFlagHome, carrierDisengage, escortCarrier, chaseEnemyCarrier, engageNearest, contestMid],
+    actions: [runFlagHome, carrierDisengage, escortCarrier, chaseEnemyCarrier, grabEnemyFlag, escortRunner, engageNearest, contestMid],
   },
   'wsg.mid': {
     name: '~wsg.mid',
-    actions: [returnOurFlag, chaseEnemyCarrier, escortCarrier, contestMid, engageNearest],
+    actions: [runFlagHome, carrierDisengage, returnOurFlag, chaseEnemyCarrier, escortCarrier, grabEnemyFlag, contestMid, engageNearest],
   },
   // Arathi Basin. No flag actions at all: the WSG bundles walk to WSG_GEOMETRY, which is map 489,
   // so an AB unit on one of them marched off the plate and never touched a banner.

package/src/domain/bg/types.ts

@@ -75,6 +75,8 @@ export interface BgUnit {
   order: BgOrder;
   /** Combat spec — only needed when a shard is folded into a real createSession. */
   spec?: CombatantSpec;
+  /** Does this seat heal? The attrition resolver reads it; absent, it falls back to the class. */
+  heals?: boolean;
   /** Movement speed, yards/second. */
   speedYd: number;
   /** Set while this unit carries an enemy flag (the aura id, 23333 / 23335). */