@g3nomaly/g3n-mods 0.1.7 → 0.1.8

package/mods/agent-adventure/hooks/engine.ts

@@ -0,0 +1,1125 @@
+// packages/g3n-mods/mods/agent-adventure/hooks/engine.ts
+import type { ClassId, Effect, Fighter, Fx, Hero, LogLine, Run, SkillDef, StopKind, UnitView, ViewData, World } from '../types'
+import {
+  BOSSES, CLASSES, CLASS_IDS, ENEMIES, FRIEND_LINES, MAX_SKILLS, NAME_PARTS, REGIONS, REGION_IDS, RELICS, RIVAL_LINES,
+  SKILLS, TAVERN_LINES,
+} from './content'
+import type { EnemyDef } from './content'
+
+/**
+ * The game's rules as pure functions over a `World`. Each one copies the world, changes the copy and returns it, so
+ * the hooks module can run them inside `update`. Every roll comes from the world's own random state: the same world
+ * steps the same way twice. Nothing here reads the session, the code or the agents' work; the only inputs are which
+ * agents run, and the picks the model or an agent makes.
+ */
+
+/** Gauge a fighter needs to act; each fighter gains its speed every round of the gauge. */
+export const READY = 20
+/** Ticks an agent's hero stays in the party after its turn ends, so a quick reply does not send everyone home. */
+export const LINGER_TICKS = 15
+/** Most heroes in the guild; past it, a new agent borrows a free hero instead of signing up a new one. */
+export const MAX_ROSTER = 12
+/** Levels a party loses when every hero falls. */
+export const WIPE_PENALTY = 5
+/** An enemy's stats at level 0 and their growth per level, before its kind's multiples. */
+export const ENEMY_BASE = { hp: 14, hpGrowth: 4.5, atk: 3.5, atkGrowth: 1, def: 1, defGrowth: 0.5 }
+/** Rounds into a fight (an action per fighter) after which every fighter hits harder, so no fight stalls. */
+export const FATIGUE_AFTER = 12
+/** Bounds of the threat, the multiplier on enemy HP and attack that follows how the party fares. */
+export const THREAT_MIN = 0.25
+export const THREAT_MAX = 4
+/** Fighters on the field per action a tick: a fight of 10 takes 2 actions a tick. */
+const ACTORS_PER_ACTION = 5
+/** Ticks the party waits on a pick at a fork before going with its default. */
+export const FORK_WAIT = 8
+
+const LOG_KEEP = 30
+const FX_KEEP = 40
+
+/** A decision the game hands to the model; the hooks module answers it with `christen`, `learn` or `chooseRoute`. */
+export type Ask = { kind: 'christen'; heroId: string } | { kind: 'skill'; heroId: string } | { kind: 'route'; forkId: number }
+
+/** A changed world and the decisions it now waits on. */
+export type Outcome = { world: World; asks: Ask[] }
+
+// ---------------------------------------------------------------------------------------------------------------
+// Randomness and small helpers
+
+/** Hashes text to a 32-bit seed. */
+export function hash(text: string): number {
+  let h = 2166136261
+  for (let i = 0; i < text.length; i++) h = Math.imul(h ^ text.charCodeAt(i), 16777619)
+  return h >>> 0
+}
+
+/** Draws a number from 0 up to 1 from the world's random state (mulberry32) and advances it. */
+export function roll(w: World): number {
+  w.rng = (w.rng + 0x6d2b79f5) | 0
+  let t = w.rng
+  t = Math.imul(t ^ (t >>> 15), t | 1)
+  t ^= t + Math.imul(t ^ (t >>> 7), t | 61)
+  return ((t ^ (t >>> 14)) >>> 0) / 4294967296
+}
+
+/** Picks one item of a non-empty list with the world's random state. */
+function pick<T>(w: World, list: readonly T[]): T {
+  return list[Math.floor(roll(w) * list.length)] as T
+}
+
+const clamp = (n: number, low: number, high: number) => Math.max(low, Math.min(high, n))
+
+/**
+ * XP a hero needs to go from `level` to the next: as many fights as `4 + 2 × level`, at most 40, at the XP a fight of
+ * that level gives (see `fightXp`).
+ */
+export function xpToNext(level: number): number {
+  return Math.min(4 + 2 * level, 40) * (3 + level)
+}
+
+function log(w: World, text: string, tone: LogLine['tone'] = 'info'): void {
+  w.log.push({ id: w.seq++, text, tone })
+  if (w.log.length > LOG_KEEP) w.log.splice(0, w.log.length - LOG_KEEP)
+}
+
+function fx(w: World, event: Omit<Fx, 'id'>): void {
+  w.fx.push({ id: w.seq++, ...event })
+  if (w.fx.length > FX_KEEP) w.fx.splice(0, w.fx.length - FX_KEEP)
+}
+
+function heroById(w: World, id: string): Hero | undefined {
+  return w.heroes.find(hero => hero.id === id)
+}
+
+/** Copies a world, so a rule can change the copy freely. */
+function copy(w: World): World {
+  return JSON.parse(JSON.stringify(w)) as World
+}
+
+// ---------------------------------------------------------------------------------------------------------------
+// The guild: heroes, agents, and the picks the model or an agent makes
+
+/**
+ * Makes an empty world.
+ *
+ * @param heroes - Heroes read back from the store.
+ * @param run - The run read back from the store, or `null`.
+ * @param seed - Seed for the world's random state.
+ * @param runs - Runs started so far.
+ * @param threat - The threat read back from the store.
+ */
+export function newWorld(heroes: Hero[], run: Run | null, seed: number, runs = 0, threat = 1): World {
+  return { heroes, bindings: [], run, scene: { kind: 'tavern' }, fighters: [], turns: 0, log: [], fx: [], seq: 1, tick: 0, rng: seed | 0, runs, threat, isCalm: false }
+}
+
+/** Ids of the heroes in the party, in the order their agents started, christened ones only. */
+export function partyIds(w: World): string[] {
+  const ids: string[] = []
+  for (const binding of w.bindings) {
+    const hero = heroById(w, binding.heroId)
+    if (hero !== undefined && !hero.isRecruit && !ids.includes(hero.id)) ids.push(hero.id)
+  }
+  return ids
+}
+
+/** Makes a name from the game's name parts. */
+function gameName(w: World): string {
+  const taken = new Set(w.heroes.map(hero => hero.name))
+  for (let tries = 0; tries < 20; tries++) {
+    const name = pick(w, NAME_PARTS[0]) + pick(w, NAME_PARTS[1])
+    if (!taken.has(name)) return name
+  }
+  return `Hero ${w.heroes.length + 1}`
+}
+
+/** The class the guild has fewest of, ties broken by a roll. */
+function scarceClass(w: World): ClassId {
+  const counts = CLASS_IDS.map(cls => w.heroes.filter(hero => hero.cls === cls).length)
+  const fewest = Math.min(...counts)
+  return pick(w, CLASS_IDS.filter((_, i) => counts[i] === fewest))
+}
+
+/**
+ * @brief Puts a hero in the party for an agent that started: a free hero of its calling, else a new recruit, else
+ * any free hero. One agent never gets two heroes, and two agents never share one.
+ *
+ * @param world - Current world.
+ * @param agent - `main`, or the subagent's id.
+ * @param calling - What kind of agent it is: `main`, or a subagent type such as `Explore`.
+ * @param now - Milliseconds since the epoch, the new hero's creation time.
+ * @returns The world, and a `christen` ask when a recruit signed up.
+ */
+export function join(world: World, agent: string, calling: string, now: number): Outcome {
+  const w = copy(world)
+  const bound = w.bindings.find(binding => binding.agent === agent)
+  if (bound !== undefined) {
+    delete bound.leftAt
+    return { world: w, asks: [] }
+  }
+  const busy = new Set(w.bindings.map(binding => binding.heroId))
+  const free = w.heroes.filter(hero => !busy.has(hero.id)).sort((a, b) => b.level - a.level)
+  const own = free.find(hero => hero.calling === calling)
+  if (own !== undefined) {
+    w.bindings.push({ agent, heroId: own.id })
+    if (!own.isRecruit) log(w, `${own.name} joins the party.`)
+    return { world: w, asks: [] }
+  }
+  if (w.heroes.length < MAX_ROSTER) {
+    const hero: Hero = {
+      id: `h${now.toString(36)}${w.seq++}`,
+      name: gameName(w),
+      cls: scarceClass(w),
+      level: 1,
+      xp: 0,
+      bestLevel: 1,
+      skills: [],
+      calling,
+      feelings: {},
+      namedBy: 'game',
+      isRecruit: true,
+      trophies: [],
+      record: { runs: 0, wins: 0, wipes: 0, kills: 0 },
+      createdAt: now,
+    }
+    w.heroes.push(hero)
+    w.bindings.push({ agent, heroId: hero.id })
+    log(w, 'A new adventurer is signing up at the guild…')
+    return { world: w, asks: [{ kind: 'christen', heroId: hero.id }] }
+  }
+  const any = free.find(hero => !hero.isRecruit)
+  if (any !== undefined) {
+    w.bindings.push({ agent, heroId: any.id })
+    log(w, `${any.name} joins the party.`)
+  }
+  return { world: w, asks: [] }
+}
+
+/** Marks an agent's turn as ended; its hero leaves the party after `LINGER_TICKS`. */
+export function leave(world: World, agent: string): World {
+  const w = copy(world)
+  const bound = w.bindings.find(binding => binding.agent === agent)
+  if (bound !== undefined) bound.leftAt = w.tick
+  return w
+}
+
+/** Cleans a name or motto: letters, digits, spaces and light punctuation, cut to `max`. */
+export function cleanText(text: unknown, max: number): string | undefined {
+  if (typeof text !== 'string') return undefined
+  const clean = text.replace(/[^\p{L}\p{N} '.,!?-]/gu, '').replace(/\s+/g, ' ').trim().slice(0, max).trim()
+  return clean.length >= 2 ? clean : undefined
+}
+
+/**
+ * Finishes a recruit's sign-up with what the model picked, or the game's own picks for anything missing or invalid.
+ *
+ * @param world - Current world.
+ * @param heroId - The recruit.
+ * @param answer - The model's pick, or `undefined` when it gave none.
+ */
+export function christen(world: World, heroId: string, answer?: { name?: unknown; cls?: unknown; motto?: unknown }): World {
+  const w = copy(world)
+  const hero = heroById(w, heroId)
+  if (hero === undefined || !hero.isRecruit) return world
+  const name = cleanText(answer?.name, 16)
+  if (name !== undefined && !w.heroes.some(other => other.name === name)) {
+    hero.name = name
+    hero.namedBy = 'model'
+  }
+  const cls = CLASS_IDS.find(id => id === answer?.cls)
+  if (cls !== undefined) hero.cls = cls
+  const motto = cleanText(answer?.motto, 60)
+  if (motto !== undefined) hero.motto = motto
+  hero.isRecruit = false
+  log(w, `${hero.name} the ${CLASSES[hero.cls].name} joins the guild!`, 'good')
+  fx(w, { kind: 'say', at: hero.id, text: hero.motto ?? 'Reporting for duty!' })
+  return w
+}
+
+/**
+ * Teaches a hero one of the two skills it was offered. A hero with `MAX_SKILLS` gives up its oldest skill.
+ *
+ * @param world - Current world.
+ * @param heroId - The hero with a pending choice.
+ * @param choice - `0` or `1`, which of the two.
+ * @param why - The model's reason, said by the hero.
+ */
+export function learn(world: World, heroId: string, choice: number, why?: string): World {
+  const w = copy(world)
+  const hero = heroById(w, heroId)
+  const id = hero?.choice?.[choice === 1 ? 1 : 0]
+  const taught = id === undefined ? undefined : SKILLS[id]
+  if (hero === undefined || taught === undefined) return world
+  delete hero.choice
+  const dropped = hero.skills.length >= MAX_SKILLS ? hero.skills.shift() : undefined
+  hero.skills.push(taught.id)
+  const forgot = dropped === undefined ? '' : `, setting aside ${SKILLS[dropped]?.name ?? dropped}`
+  log(w, `${hero.name} learns ${taught.name}${forgot}.`, 'level')
+  fx(w, { kind: 'learn', at: hero.id, text: taught.name })
+  const line = cleanText(why, 60)
+  if (line !== undefined) fx(w, { kind: 'say', at: hero.id, text: line })
+  return w
+}
+
+/**
+ * Settles the route at a fork. Only the first pick for a fork counts.
+ *
+ * @param world - Current world.
+ * @param forkId - The fork's id, from its `route` ask.
+ * @param route - `safe` or `danger`.
+ * @param why - One line said by the hero who argued for it.
+ */
+export function chooseRoute(world: World, forkId: number, route: 'safe' | 'danger', why?: string): World {
+  if (world.scene.kind !== 'fork' || world.scene.id !== forkId || world.scene.route !== undefined) return world
+  const w = copy(world)
+  const party = partyIds(w)
+  const speaker = party.length === 0 ? undefined : heroById(w, pick(w, party))
+  const line = cleanText(why, 60)
+  w.scene = { ...(w.scene as Extract<World['scene'], { kind: 'fork' }>), route, ...(line === undefined ? {} : { why: line }), ...(speaker === undefined ? {} : { by: speaker.name }) }
+  if (speaker !== undefined && line !== undefined) fx(w, { kind: 'say', at: speaker.id, text: line })
+  return w
+}
+
+/**
+ * Applies what an agent asked of its own hero through the mod's tool: a name, a motto, a feeling about another hero.
+ *
+ * @param world - Current world.
+ * @param agent - `main`, or the calling subagent's id.
+ * @param request - The tool's input.
+ * @returns The world and a line saying what changed, or why nothing did.
+ */
+export function agentRequest(world: World, agent: string, request: { name?: unknown; motto?: unknown; feeling?: unknown }): { world: World; text: string } {
+  const w = copy(world)
+  const binding = w.bindings.find(one => one.agent === agent)
+  const hero = binding === undefined ? undefined : heroById(w, binding.heroId)
+  if (hero === undefined) return { world, text: 'You have no hero in the game right now; nothing changed.' }
+  const done: string[] = []
+  if (request.name !== undefined) {
+    const name = cleanText(request.name, 16)
+    if (name === undefined) done.push('name refused: use 2 to 16 letters')
+    else if (w.heroes.some(other => other.id !== hero.id && other.name === name)) done.push(`name refused: another hero is called ${name}`)
+    else {
+      log(w, `${hero.name} will now be known as ${name}.`)
+      hero.name = name
+      hero.namedBy = 'agent'
+      done.push(`name set to ${name}`)
+    }
+  }
+  if (request.motto !== undefined) {
+    const motto = cleanText(request.motto, 60)
+    if (motto === undefined) done.push('motto refused')
+    else {
+      hero.motto = motto
+      fx(w, { kind: 'say', at: hero.id, text: motto })
+      done.push('motto set')
+    }
+  }
+  if (typeof request.feeling === 'object' && request.feeling !== null) {
+    const { toward, value } = request.feeling as { toward?: unknown; value?: unknown }
+    const other = w.heroes.find(one => typeof toward === 'string' && one.name.toLowerCase() === toward.trim().toLowerCase())
+    if (other === undefined || other.id === hero.id || typeof value !== 'number') done.push('feeling refused: name another hero and a value from -2 to 2')
+    else {
+      hero.feelings[other.id] = clamp(Math.round(value), -2, 2)
+      done.push(`feeling toward ${other.name} set to ${hero.feelings[other.id]}`)
+    }
+  }
+  const status = `${hero.name}, level ${hero.level} ${CLASSES[hero.cls].name}`
+  return { world: w, text: done.length === 0 ? `${status}. Nothing asked, nothing changed.` : `${status}: ${done.join('; ')}.` }
+}
+
+// ---------------------------------------------------------------------------------------------------------------
+// Fighters
+
+/** A hero's stats at its level, with its passive skills and the run's relics. */
+export function heroFighter(hero: Hero, run: Run | null): Fighter {
+  const cls = CLASSES[hero.cls]
+  const grow = hero.level - 1
+  const bonus = { hp: 0, atk: 0, def: 0, spd: 0, crit: 0, evade: 0 }
+  const skills: SkillDef[] = []
+  for (const id of hero.skills) {
+    const known = SKILLS[id]
+    if (known === undefined) continue
+    if (known.kind === 'passive' && known.stat !== undefined) bonus[known.stat] += known.power
+    else skills.push(known)
+  }
+  let regen = 0
+  for (const id of run?.relics ?? []) {
+    const relic = RELICS[id]
+    if (relic === undefined) continue
+    bonus.atk += relic.atkPct ?? 0
+    bonus.def += relic.defPct ?? 0
+    bonus.spd += relic.spd ?? 0
+    bonus.crit += relic.crit ?? 0
+    regen += relic.regen ?? 0
+  }
+  const maxHp = Math.round((cls.base.hp + cls.growth.hp * grow) * (1 + bonus.hp))
+  const carried = run?.hp[hero.id]
+  return {
+    id: hero.id,
+    side: 'hero',
+    name: hero.name,
+    look: hero.cls,
+    level: hero.level,
+    hp: carried === undefined ? maxHp : clamp(carried, 0, maxHp),
+    maxHp,
+    atk: (cls.base.atk + cls.growth.atk * grow) * (1 + bonus.atk),
+    def: (cls.base.def + cls.growth.def * grow) * (1 + bonus.def),
+    spd: cls.base.spd + bonus.spd,
+    crit: cls.base.crit + bonus.crit,
+    evade: cls.base.evade + bonus.evade,
+    gauge: 0,
+    basic: cls.basic,
+    skills,
+    cooldowns: {},
+    effects: cls.opening === undefined ? [] : [{ kind: cls.opening.kind, turns: cls.opening.turns, power: 0.2 }],
+    regen,
+    rank: 'normal',
+    phase: 1,
+  }
+}
+
+/** An enemy at `level`, from the level baseline times its kind's multiples. */
+function enemyFighter(id: string, look: string, def: EnemyDef, level: number, rank: Fighter['rank'], threat: number, hpScale = 1): Fighter {
+  const maxHp = Math.round((ENEMY_BASE.hp + ENEMY_BASE.hpGrowth * level) * def.hp * hpScale * threat)
+  const special = def.special
+  return {
+    id,
+    side: 'enemy',
+    name: rank === 'elite' ? `Elite ${def.name}` : def.name,
+    look,
+    level,
+    hp: maxHp,
+    maxHp,
+    atk: (ENEMY_BASE.atk + ENEMY_BASE.atkGrowth * level) * def.atk * (rank === 'elite' ? 1.15 : 1) * Math.sqrt(threat),
+    def: (ENEMY_BASE.def + ENEMY_BASE.defGrowth * level) * def.def,
+    spd: def.spd,
+    crit: def.crit,
+    evade: def.evade,
+    gauge: 0,
+    basic: def.basic,
+    skills: special === undefined ? [] : [special],
+    cooldowns: special === undefined ? {} : { [special.id]: 1 },
+    effects: [],
+    regen: 0,
+    rank,
+    phase: 1,
+  }
+}
+
+const living = (list: Fighter[]) => list.filter(one => one.hp > 0)
+/** Rounds fought so far: actions taken over the fighters in the fight. */
+const rounds = (w: World) => Math.floor(w.turns / Math.max(1, w.fighters.length))
+const sideOf = (w: World, side: Fighter['side']) => w.fighters.filter(one => one.side === side)
+const effectPower = (f: Fighter, kind: Effect['kind']) => f.effects.filter(one => one.kind === kind).reduce((top, one) => Math.max(top, one.power), 0)
+const hasEffect = (f: Fighter, kind: Effect['kind']) => f.effects.some(one => one.kind === kind)
+const share = (f: Fighter) => f.hp / f.maxHp
+
+/** Puts an effect on a fighter, replacing a weaker or shorter one of its kind. */
+function addEffect(f: Fighter, effect: Effect): void {
+  f.effects = [...f.effects.filter(one => one.kind !== effect.kind), effect]
+}
+
+// ---------------------------------------------------------------------------------------------------------------
+// Runs and stops
+
+/** Generates a new run: a few fights, a fork, a few more, a fork, a camp and the boss. */
+function newRun(w: World): void {
+  const region = pick(w, REGION_IDS)
+  const path: StopKind[] = []
+  for (let segment = 0; segment < 2; segment++) {
+    const fights = roll(w) < 0.4 ? 3 : 2
+    for (let i = 0; i < fights; i++) path.push('fight')
+    path.push('fork', 'fight')
+  }
+  path.push('fight', 'camp', 'boss')
+  w.runs += 1
+  w.run = { number: w.runs, region, path, at: 0, fought: 0, relics: [], potions: 1, hp: {}, isFeatherUsed: false, isDaring: false }
+  for (const id of partyIds(w)) {
+    const hero = heroById(w, id)
+    if (hero !== undefined) hero.record.runs += 1
+  }
+  log(w, `Run ${w.runs}: the party sets out for the ${REGIONS[region].name}.`, 'info')
+}
+
+/** Average level of the party's heroes, 1 when empty. */
+function partyLevel(w: World): number {
+  const levels = partyIds(w).map(id => heroById(w, id)?.level ?? 1)
+  return levels.length === 0 ? 1 : levels.reduce((a, b) => a + b, 0) / levels.length
+}
+
+/** Starts the fight at the current stop, scaled by the party's level and size and how deep the run is. */
+function startFight(w: World, kind: 'fight' | 'elite' | 'boss'): void {
+  const run = w.run
+  if (run === null) return
+  const region = REGIONS[run.region]
+  const party = partyIds(w)
+  const n = Math.max(1, party.length)
+  const tier = Math.max(1, Math.round(partyLevel(w) - 1 + Math.floor(run.fought / 3)))
+  const enemies: Fighter[] = []
+  const add = (look: string, def: EnemyDef, level: number, rank: Fighter['rank'], hpScale = 1) =>
+    enemies.push(enemyFighter(`e${w.seq++}`, look, def, level, rank, rank === 'normal' ? w.threat : Math.sqrt(w.threat), hpScale))
+
+  if (kind === 'boss') {
+    const boss = BOSSES[region.boss]
+    if (boss !== undefined) add(region.boss, boss, tier + 1, 'boss', 2.6 + 1.8 * (n - 1))
+    for (let i = 0; i < Math.floor(n / 2); i++) {
+      const look = pick(w, region.enemies)
+      add(look, ENEMIES[look] as EnemyDef, tier, 'normal')
+    }
+  } else if (kind === 'elite') {
+    const look = pick(w, region.elites)
+    add(look, ENEMIES[look] as EnemyDef, tier + 1, 'elite', 2)
+    for (let i = 0; i < n - 1; i++) {
+      const other = pick(w, region.enemies)
+      add(other, ENEMIES[other] as EnemyDef, tier, 'normal')
+    }
+  } else {
+    const count = clamp(n + (roll(w) < (n === 1 ? 0.3 : 0.5) ? 1 : 0), 1, 6)
+    for (let i = 0; i < count; i++) {
+      const look = pick(w, region.enemies)
+      add(look, ENEMIES[look] as EnemyDef, tier, 'normal')
+    }
+  }
+
+  const heroes = party.map(id => heroById(w, id)).filter((hero): hero is Hero => hero !== undefined).map(hero => heroFighter(hero, run))
+  w.fighters = [...heroes, ...enemies]
+  w.turns = 0
+  w.scene = { kind: 'fight' }
+  run.fought += 1
+  const names = enemies.map(one => one.name)
+  const lead = enemies[0]
+  if (kind === 'boss' && lead !== undefined) log(w, `${lead.name} blocks the way!`, 'bad')
+  else log(w, `${names.length === 1 ? 'A' : names.length} ${names.length === 1 ? names[0] : 'foes'} ${names.length === 1 ? 'appears' : 'appear'}: ${[...new Set(names)].join(', ')}.`)
+}
+
+/** Enters the stop the run is at. */
+function enterStop(w: World, asks: Ask[]): void {
+  const run = w.run
+  if (run === null) return
+  const stop = run.path[run.at]
+  if (stop === 'fight' || stop === 'elite' || stop === 'boss') {
+    startFight(w, stop)
+  } else if (stop === 'fork') {
+    const id = w.seq++
+    w.scene = { kind: 'fork', wait: FORK_WAIT, id }
+    log(w, 'The path forks: a quiet trail, or a dark one with treasure behind it.')
+    asks.push({ kind: 'route', forkId: id })
+  } else if (stop === 'camp') {
+    for (const id of partyIds(w)) {
+      const hero = heroById(w, id)
+      if (hero === undefined) continue
+      const max = heroFighter(hero, { ...run, hp: {} }).maxHp
+      run.hp[id] = Math.min(max, (run.hp[id] ?? max) + Math.round(max * 0.6))
+    }
+    run.potions += 1
+    w.scene = { kind: 'camp', wait: 5 }
+    log(w, 'The party makes camp before the boss. Wounds mended, +1 potion.', 'loot')
+  } else {
+    w.scene = { kind: 'cleared', wait: 6 }
+  }
+}
+
+/** Moves to the next stop, or ends the run after the last. */
+function advance(w: World): void {
+  const run = w.run
+  if (run === null) return
+  run.at += 1
+  if (run.at >= run.path.length) {
+    w.scene = { kind: 'cleared', wait: 6 }
+    for (const id of partyIds(w)) {
+      const hero = heroById(w, id)
+      if (hero !== undefined) hero.record.wins += 1
+    }
+    log(w, `Run ${run.number} cleared! The party heads home with its trophies.`, 'good')
+    return
+  }
+  w.scene = { kind: 'travel', wait: 2 }
+}
+
+/** Share of its max HP a hero carries into the run's next fight; 1 outside a run. */
+export function hpShare(w: World, heroId: string): number {
+  const hero = heroById(w, heroId)
+  if (w.run === null || hero === undefined) return 1
+  const max = heroFighter(hero, { ...w.run, hp: {} }).maxHp
+  return (w.run.hp[heroId] ?? max) / max
+}
+
+/** The route the party takes when nobody picked one: daring when it is in good shape. */
+export function defaultRoute(w: World): 'safe' | 'danger' {
+  if (w.run === null) return 'safe'
+  const shares = partyIds(w).map(id => hpShare(w, id))
+  const average = shares.length === 0 ? 1 : shares.reduce((a, b) => a + b, 0) / shares.length
+  return average >= 0.75 ? 'danger' : 'safe'
+}
+
+/** Sets the stop after a fork by the route taken. */
+function takeRoute(w: World, route: 'safe' | 'danger'): void {
+  const run = w.run
+  if (run === null) return
+  run.path[run.at + 1] = route === 'danger' ? 'elite' : 'fight'
+  if (route === 'danger') {
+    run.isDaring = true
+    log(w, 'The party takes the dark path. Double XP and a relic await… if they survive.', 'loot')
+  } else {
+    run.potions += 1
+    log(w, 'The party takes the quiet trail and finds a potion on the way.', 'loot')
+  }
+}
+
+// ---------------------------------------------------------------------------------------------------------------
+// Fighting
+
+/** Gives a hero XP, levelling it up as often as it fills, and offers a skill at each new tenth level. */
+function grantXp(w: World, hero: Hero, xp: number, asks: Ask[]): void {
+  hero.xp += xp
+  while (hero.xp >= xpToNext(hero.level)) {
+    hero.xp -= xpToNext(hero.level)
+    hero.level += 1
+    fx(w, { kind: 'level', at: hero.id, text: `Level ${hero.level}!` })
+    if (hero.level > hero.bestLevel) {
+      hero.bestLevel = hero.level
+      if (hero.level % 10 === 0) offerSkills(w, hero, asks)
+    }
+  }
+}
+
+/** Offers a hero two skills of its class it does not know yet. */
+function offerSkills(w: World, hero: Hero, asks: Ask[]): void {
+  if (hero.choice !== undefined) return
+  const open = CLASSES[hero.cls].pool.filter(one => !hero.skills.includes(one.id))
+  if (open.length < 2) return
+  const first = pick(w, open)
+  const second = pick(w, open.filter(one => one !== first))
+  hero.choice = [first.id, second.id]
+  log(w, `${hero.name} reached level ${hero.level} and may learn ${first.name} or ${second.name}.`, 'level')
+  asks.push({ kind: 'skill', heroId: hero.id })
+}
+
+/** Adds heroes who joined mid-fight and takes out those whose agents left, keeping their HP for the run. */
+function reconcile(w: World): void {
+  const run = w.run
+  const party = partyIds(w)
+  for (const f of sideOf(w, 'hero')) {
+    if (!party.includes(f.id)) {
+      if (run !== null) run.hp[f.id] = f.hp
+      log(w, `${f.name} heads back to the tavern.`)
+    }
+  }
+  w.fighters = w.fighters.filter(f => f.side === 'enemy' || party.includes(f.id))
+  for (const id of party) {
+    if (w.fighters.some(f => f.id === id)) continue
+    const hero = heroById(w, id)
+    if (hero === undefined) continue
+    w.fighters.splice(sideOf(w, 'hero').length, 0, heroFighter(hero, run))
+    log(w, `${hero.name} rushes into the fight!`)
+  }
+}
+
+/** Picks the fighter who acts next: everyone gains speed until one holds the most gauge at `READY` or above. */
+function nextActor(w: World): Fighter | undefined {
+  const alive = living(w.fighters)
+  if (alive.length === 0) return undefined
+  for (let guard = 0; guard < 100; guard++) {
+    const top = alive.reduce((best, f) => (f.gauge > best.gauge ? f : best), alive[0] as Fighter)
+    if (top.gauge >= READY) {
+      top.gauge -= READY
+      return top
+    }
+    for (const f of alive) f.gauge += f.spd
+  }
+  return alive[0]
+}
+
+/** Applies damage to `target`: a miss on evasion, a crit by chance, softened by defense and shields. Returns it. */
+function strikeOnce(w: World, actor: Fighter, target: Fighter, power: number): number {
+  if (roll(w) < target.evade) {
+    fx(w, { kind: 'miss', at: target.id })
+    return 0
+  }
+  const fatigue = Math.max(0, rounds(w) - FATIGUE_AFTER) * 0.08
+  const atk = actor.atk * (1 + effectPower(actor, 'rally')) * (1 + effectPower(actor, 'enrage')) * (1 + fatigue)
+  let raw = atk * power * (0.85 + 0.3 * roll(w))
+  const isCrit = roll(w) < actor.crit
+  if (isCrit) raw *= 1.75
+  // Defense is weighed against the attacker's level, so a matchup plays the same at level 5 and level 50.
+  const pierce = 10 + 3 * actor.level
+  const amount = Math.max(1, Math.round(raw * (pierce / (pierce + target.def)) * (1 - effectPower(target, 'shield'))))
+  hurt(w, target, amount, actor, isCrit)
+  return amount
+}
+
+/** Takes HP from a fighter, downs it at 0, and moves a boss to its second phase below half. */
+function hurt(w: World, target: Fighter, amount: number, by: Fighter | undefined, isCrit = false): void {
+  target.hp = Math.max(0, target.hp - amount)
+  fx(w, { kind: 'hit', at: target.id, amount, isCrit })
+  if (target.hp === 0) {
+    target.effects = []
+    fx(w, { kind: 'down', at: target.id })
+    log(w, target.side === 'hero' ? `${target.name} is knocked out!` : `${target.name} is defeated.`, target.side === 'hero' ? 'bad' : 'good')
+    if (by?.side === 'hero' && target.side === 'enemy') {
+      const hero = heroById(w, by.id)
+      if (hero !== undefined) hero.record.kills += 1
+    }
+    return
+  }
+  if (target.rank === 'boss' && target.phase === 1 && target.hp < target.maxHp / 2) {
+    target.phase = 2
+    const boss = Object.values(BOSSES).find(one => one.name === target.name)
+    if (boss !== undefined) {
+      addEffect(target, { kind: 'enrage', turns: 999, power: boss.phase2.atkPct })
+      target.skills = [boss.phase2.special]
+      target.cooldowns = { [boss.phase2.special.id]: 0 }
+      fx(w, { kind: 'phase', at: target.id, text: 'Phase 2' })
+      log(w, boss.phase2.line, 'bad')
+    }
+  }
+}
+
+function heal(w: World, target: Fighter, amount: number): number {
+  const healed = Math.min(target.maxHp - target.hp, Math.round(amount))
+  if (healed > 0) {
+    target.hp += healed
+    fx(w, { kind: 'heal', at: target.id, amount: healed })
+  }
+  return healed
+}
+
+/** The enemy a hero aims a single-target skill at: the weakest, to finish it off. */
+function focus(list: Fighter[]): Fighter | undefined {
+  return living(list).sort((a, b) => a.hp - b.hp)[0]
+}
+
+/** The hero an enemy attacks: a taunting one if any, else a random one. */
+function enemyTarget(w: World, heroes: Fighter[]): Fighter | undefined {
+  const alive = living(heroes)
+  const taunting = alive.filter(f => hasEffect(f, 'taunt'))
+  if (taunting.length > 0) return pick(w, taunting)
+  return alive.length === 0 ? undefined : pick(w, alive)
+}
+
+/** Tells whether using `skill` now helps, so the fighter keeps it for when it does. */
+function isUseful(skill: SkillDef, actor: Fighter, allies: Fighter[], foes: Fighter[]): boolean {
+  const alive = living(allies)
+  const hurt = alive.filter(f => share(f) < 0.55)
+  switch (skill.kind) {
+    case 'revive': return allies.some(f => f.hp === 0)
+    case 'heal': return hurt.length > 0
+    case 'healAll': return alive.filter(f => share(f) < 0.7).length >= 2 || hurt.length > 0
+    case 'healSelf': return share(actor) < 0.45
+    case 'shield': return !alive.some(f => hasEffect(f, 'shield')) && alive.some(f => share(f) < 0.8)
+    case 'taunt': return !hasEffect(actor, 'taunt')
+    case 'rally': return !alive.some(f => hasEffect(f, 'rally'))
+    case 'cleave': return living(foes).length >= 2
+    case 'burn': return living(foes).some(f => !hasEffect(f, 'burn'))
+    default: return living(foes).length > 0
+  }
+}
+
+/** Uses a skill or basic action. Returns a short phrase of what happened for the log. */
+function use(w: World, actor: Fighter, skill: SkillDef, allies: Fighter[], foes: Fighter[]): string {
+  fx(w, { kind: 'act', at: actor.id, from: actor.id, text: skill.cd > 0 ? skill.name : undefined })
+  const target = actor.side === 'hero' ? focus(foes) : enemyTarget(w, foes)
+  switch (skill.kind) {
+    case 'strike': {
+      if (target === undefined) return ''
+      const dealt = strikeOnce(w, actor, target, skill.power)
+      return dealt === 0 ? `misses ${target.name}` : `hits ${target.name} for ${dealt}`
+    }
+    case 'multi': {
+      let total = 0
+      for (let i = 0; i < (skill.hits ?? 2); i++) {
+        const alive = living(foes)
+        if (alive.length === 0) break
+        total += strikeOnce(w, actor, pick(w, alive), skill.power)
+      }
+      return `strikes ${skill.hits ?? 2} times for ${total}`
+    }
+    case 'cleave': {
+      const total = living(foes).reduce((sum, foe) => sum + strikeOnce(w, actor, foe, skill.power), 0)
+      return `hits every foe for ${total} in all`
+    }
+    case 'stun': {
+      if (target === undefined) return ''
+      const dealt = strikeOnce(w, actor, target, skill.power)
+      if (target.hp > 0 && dealt > 0) {
+        const resists = target.rank === 'boss' || (target.rank === 'elite' && roll(w) < 0.5)
+        if (!resists) {
+          addEffect(target, { kind: 'stun', turns: 1, power: 0 })
+          fx(w, { kind: 'buff', at: target.id, text: 'Stunned' })
+          return `stuns ${target.name}`
+        }
+        return `hits ${target.name}, who shrugs off the stun`
+      }
+      return `hits ${target.name} for ${dealt}`
+    }
+    case 'burn': {
+      const fresh = living(foes).find(f => !hasEffect(f, 'burn')) ?? target
+      if (fresh === undefined) return ''
+      strikeOnce(w, actor, fresh, 0.6)
+      if (fresh.hp > 0) addEffect(fresh, { kind: 'burn', turns: skill.turns ?? 3, power: Math.max(1, Math.round(actor.atk * skill.power)) })
+      return `sets ${fresh.name} burning`
+    }
+    case 'drain': {
+      if (target === undefined) return ''
+      const dealt = strikeOnce(w, actor, target, skill.power)
+      heal(w, actor, dealt / 2)
+      return `drains ${dealt} from ${target.name}`
+    }
+    case 'mend': {
+      // Alone, a healer mends only when it must; with allies it keeps everyone topped up.
+      const below = living(allies).length > 1 ? 0.7 : 0.45
+      const hurt = living(allies).filter(f => share(f) < below).sort((a, b) => share(a) - share(b))[0]
+      if (hurt !== undefined) return `mends ${hurt.name} for ${heal(w, hurt, hurt.maxHp * skill.power)}`
+      if (target === undefined) return ''
+      const dealt = strikeOnce(w, actor, target, 1.1)
+      return `smites ${target.name} for ${dealt}`
+    }
+    case 'heal': {
+      const hurt = living(allies).sort((a, b) => share(a) - share(b))[0]
+      return hurt === undefined ? '' : `heals ${hurt.name} for ${heal(w, hurt, hurt.maxHp * skill.power)}`
+    }
+    case 'healSelf': return `recovers ${heal(w, actor, actor.maxHp * skill.power)} HP`
+    case 'healAll': {
+      const total = living(allies).reduce((sum, f) => sum + heal(w, f, f.maxHp * skill.power), 0)
+      return `heals the party for ${total}`
+    }
+    case 'revive': {
+      const fallen = allies.find(f => f.hp === 0)
+      if (fallen === undefined) return ''
+      fallen.hp = Math.max(1, Math.round(fallen.maxHp * skill.power))
+      fx(w, { kind: 'heal', at: fallen.id, amount: fallen.hp })
+      return `raises ${fallen.name}!`
+    }
+    case 'shield': {
+      for (const f of living(allies)) {
+        addEffect(f, { kind: 'shield', turns: skill.turns ?? 2, power: skill.power })
+        fx(w, { kind: 'buff', at: f.id, text: 'Shielded' })
+      }
+      return 'shields the party'
+    }
+    case 'taunt': {
+      addEffect(actor, { kind: 'taunt', turns: skill.turns ?? 3, power: 0 })
+      addEffect(actor, { kind: 'shield', turns: skill.turns ?? 3, power: skill.power })
+      fx(w, { kind: 'buff', at: actor.id, text: 'Taunting' })
+      return 'draws every attack'
+    }
+    case 'rally': {
+      for (const f of living(allies)) addEffect(f, { kind: 'rally', turns: skill.turns ?? 3, power: skill.power })
+      fx(w, { kind: 'buff', at: actor.id, text: skill.name })
+      return 'rallies the party'
+    }
+    case 'passive': return ''
+  }
+}
+
+/**
+ * Runs one fighter's turn: its effects, a potion when a hero is low, then its best useful skill or its basic action.
+ */
+function takeTurn(w: World, actor: Fighter): void {
+  const run = w.run
+  for (const id of Object.keys(actor.cooldowns)) actor.cooldowns[id] = Math.max(0, (actor.cooldowns[id] ?? 0) - 1)
+  if (actor.regen > 0) heal(w, actor, actor.maxHp * actor.regen)
+  const burn = actor.effects.find(one => one.kind === 'burn')
+  if (burn !== undefined) hurt(w, actor, burn.power, undefined)
+  const isStunned = hasEffect(actor, 'stun')
+  actor.effects = actor.effects.map(one => ({ ...one, turns: one.turns - 1 })).filter(one => one.turns > 0)
+  if (actor.hp === 0) return
+  if (isStunned) {
+    log(w, `${actor.name} is stunned and loses a turn.`)
+    return
+  }
+  const allies = sideOf(w, actor.side)
+  const foes = sideOf(w, actor.side === 'hero' ? 'enemy' : 'hero')
+
+  if (actor.side === 'hero' && run !== null && run.potions > 0 && share(actor) < 0.3) {
+    run.potions -= 1
+    heal(w, actor, actor.maxHp * 0.45)
+    log(w, `${actor.name} drinks a potion.`, 'loot')
+  }
+
+  const ready = actor.skills.find(one => (actor.cooldowns[one.id] ?? 0) === 0 && isUseful(one, actor, allies, foes))
+  const chosen = ready ?? actor.basic
+  if (ready !== undefined) actor.cooldowns[ready.id] = ready.cd + 1
+  const what = use(w, actor, chosen, allies, foes)
+  if (what !== '') log(w, `${actor.name} ${chosen.cd > 0 ? `uses ${chosen.name} and ` : ''}${what}.`, actor.side === 'hero' ? 'info' : 'bad')
+}
+
+/** XP each hero gets for a won fight: more for stronger and more foes, split by party size, doubled when daring. */
+function fightXp(w: World, enemies: Fighter[]): number {
+  const level = Math.min(...enemies.map(f => f.level))
+  const rank = enemies.some(f => f.rank === 'boss') ? 4 : enemies.some(f => f.rank === 'elite') ? 2 : 1
+  return Math.round((3 + level) * rank * (w.run?.isDaring === true ? 2 : 1))
+}
+
+/**
+ * Moves the threat by how the fight went: up when the party ended it quickly with most of its HP, down when it barely
+ * made it or the fight dragged on. A wipe lowers it more, in `loseFight`.
+ */
+function adapt(w: World, heroes: Fighter[]): void {
+  const left = heroes.reduce((sum, f) => sum + share(f), 0) / Math.max(1, heroes.length)
+  const long = rounds(w)
+  const before = w.threat
+  if (left > 0.8 && long < 8) w.threat = Math.min(THREAT_MAX, w.threat * 1.03)
+  else if (left < 0.45 || long > 10) w.threat = Math.max(THREAT_MIN, w.threat * 0.93)
+  if (Math.floor(before * 10) !== Math.floor(w.threat * 10)) log(w, w.threat > before ? 'The dungeon stirs; its monsters grow bolder.' : 'The monsters grow wary.')
+}
+
+/** Ends a won fight: XP, loot, trophies, and HP carried to the next stop. */
+function winFight(w: World, asks: Ask[]): void {
+  const run = w.run
+  if (run === null) return
+  const heroes = sideOf(w, 'hero')
+  const enemies = sideOf(w, 'enemy')
+  const xp = fightXp(w, enemies)
+  adapt(w, heroes)
+  const boss = enemies.find(f => f.rank === 'boss')
+  const elite = enemies.some(f => f.rank === 'elite')
+  for (const f of heroes) {
+    run.hp[f.id] = f.hp === 0 ? Math.round(f.maxHp * 0.3) : Math.min(f.maxHp, f.hp + Math.round(f.maxHp * 0.3))
+    const hero = heroById(w, f.id)
+    if (hero === undefined) continue
+    grantXp(w, hero, xp, asks)
+    if (boss !== undefined && !hero.trophies.includes(boss.name)) hero.trophies.push(boss.name)
+  }
+  log(w, `Victory! +${xp} XP each.`, 'good')
+  if (boss !== undefined) log(w, `${boss.name} falls. A trophy for the tavern wall!`, 'loot')
+  if (elite) {
+    const open = Object.keys(RELICS).filter(id => !run.relics.includes(id))
+    if (open.length > 0) {
+      const found = pick(w, open)
+      run.relics.push(found)
+      log(w, `Found a relic: ${RELICS[found]?.icon} ${RELICS[found]?.name} (${RELICS[found]?.blurb}).`, 'loot')
+    }
+  } else if (boss === undefined && roll(w) < 0.3) {
+    run.potions += 1
+    log(w, 'Found a potion.', 'loot')
+  }
+  run.isDaring = false
+  w.fighters = []
+  w.scene = { kind: 'victory', wait: 3 }
+}
+
+/** Ends a lost fight: a feather raises the party once a run; otherwise everyone loses `WIPE_PENALTY` levels. */
+function loseFight(w: World): void {
+  const run = w.run
+  const heroes = sideOf(w, 'hero')
+  if (run !== null && run.relics.includes('feather') && !run.isFeatherUsed) {
+    run.isFeatherUsed = true
+    for (const f of heroes) {
+      f.hp = Math.round(f.maxHp * 0.4)
+      fx(w, { kind: 'heal', at: f.id, amount: f.hp })
+    }
+    log(w, 'The Phoenix Feather bursts into flame and the party rises again!', 'loot')
+    return
+  }
+  for (const f of heroes) {
+    const hero = heroById(w, f.id)
+    if (hero === undefined) continue
+    hero.level = Math.max(1, hero.level - WIPE_PENALTY)
+    hero.xp = 0
+    hero.record.wipes += 1
+  }
+  w.threat = Math.max(THREAT_MIN, w.threat * 0.7)
+  log(w, `The party is defeated. Everyone loses ${WIPE_PENALTY} levels and wakes up in the tavern.`, 'bad')
+  w.fighters = []
+  w.scene = { kind: 'wipe', wait: 6 }
+}
+
+/** Runs one action of the fight in progress, and ends the fight when one side is down. */
+function fightStep(w: World, asks: Ask[]): void {
+  reconcile(w)
+  // A crowded fight takes several actions a tick, so it moves about as fast as a small one.
+  const actions = Math.max(1, Math.ceil(w.fighters.length / ACTORS_PER_ACTION))
+  for (let i = 0; i < actions; i++) {
+    const actor = nextActor(w)
+    const before = rounds(w)
+    w.turns += 1
+    if (before < FATIGUE_AFTER && rounds(w) >= FATIGUE_AFTER) log(w, 'Everyone is tiring; blows land harder now.')
+    if (actor !== undefined) takeTurn(w, actor)
+    if (living(sideOf(w, 'enemy')).length === 0) return winFight(w, asks)
+    if (living(sideOf(w, 'hero')).length === 0) return loseFight(w)
+  }
+}
+
+// ---------------------------------------------------------------------------------------------------------------
+// The tick
+
+/** Sends the party home: the fight in progress is dropped and every hero rests to full. */
+function goHome(w: World): void {
+  if (w.scene.kind === 'wipe' || w.scene.kind === 'cleared') w.run = null
+  // A won fight or a camp already happened: the party comes back to the stop after it.
+  if (w.run !== null && (w.scene.kind === 'victory' || w.scene.kind === 'camp')) {
+    w.run.at += 1
+    if (w.run.at >= w.run.path.length) w.run = null
+  }
+  if (w.run !== null) w.run.hp = {}
+  w.fighters = []
+  w.scene = { kind: 'tavern' }
+  log(w, 'The party heads back to the tavern to rest.')
+}
+
+/** A hero in the tavern says something now and then. */
+function chatter(w: World): void {
+  const heroes = w.heroes.filter(hero => !hero.isRecruit)
+  if (heroes.length === 0 || roll(w) > 0.35) return
+  const hero = pick(w, heroes)
+  const friends = Object.entries(hero.feelings).filter(([, v]) => v >= 1).map(([id]) => heroById(w, id)).filter(one => one !== undefined)
+  const rivals = Object.entries(hero.feelings).filter(([, v]) => v <= -1).map(([id]) => heroById(w, id)).filter(one => one !== undefined)
+  const r = roll(w)
+  let text = pick(w, TAVERN_LINES)
+  if (friends.length > 0 && r < 0.35) text = pick(w, FRIEND_LINES).replace('{friend}', pick(w, friends).name)
+  else if (rivals.length > 0 && r < 0.5) text = pick(w, RIVAL_LINES).replace('{friend}', pick(w, rivals).name)
+  else if (hero.motto !== undefined && r < 0.65) text = hero.motto
+  fx(w, { kind: 'say', at: hero.id, text })
+}
+
+/**
+ * @brief Advances the game by one tick: who is in the party, then one step of whatever the party is doing.
+ *
+ * With nobody in the party the heroes go to the tavern and chat. Otherwise they travel, fight one action at a time,
+ * wait at a fork, camp, and start a new run after a cleared run or a wipe.
+ *
+ * @param world - Current world.
+ * @returns The next world and the decisions it waits on.
+ */
+export function step(world: World): Outcome {
+  const w = copy(world)
+  const asks: Ask[] = []
+  w.tick += 1
+  w.bindings = w.bindings.filter(binding => binding.leftAt === undefined || w.tick - binding.leftAt <= LINGER_TICKS)
+  const party = partyIds(w)
+
+  if (party.length === 0) {
+    if (w.scene.kind !== 'tavern') goHome(w)
+    else chatter(w)
+    return { world: w, asks }
+  }
+
+  const scene = w.scene
+  switch (scene.kind) {
+    case 'tavern':
+      if (w.run === null) newRun(w)
+      else log(w, `The party heads back into the ${REGIONS[w.run.region].name}.`)
+      w.scene = { kind: 'travel', wait: 3 }
+      break
+    case 'travel':
+      if (--scene.wait <= 0) enterStop(w, asks)
+      break
+    case 'fight':
+      fightStep(w, asks)
+      break
+    case 'victory':
+    case 'camp':
+      if (--scene.wait <= 0) advance(w)
+      break
+    case 'fork':
+      if (scene.route !== undefined) scene.wait = Math.min(scene.wait, 3)
+      if (--scene.wait <= 0) {
+        takeRoute(w, scene.route ?? defaultRoute(w))
+        advance(w)
+      }
+      break
+    case 'wipe':
+    case 'cleared':
+      if (--scene.wait <= 0) {
+        w.run = null
+        newRun(w)
+        w.scene = { kind: 'travel', wait: 3 }
+      }
+      break
+  }
+  return { world: w, asks }
+}
+
+// ---------------------------------------------------------------------------------------------------------------
+// What the pane draws
+
+const TAGS: Readonly<Record<Effect['kind'], string>> = {
+  stun: 'stunned', shield: 'shielded', burn: 'burning', taunt: 'taunting', rally: 'rallied', enrage: 'enraged',
+}
+
+/** The pane's caption for the scene. */
+function caption(w: World): string {
+  const region = w.run === null ? '' : REGIONS[w.run.region].name
+  switch (w.scene.kind) {
+    case 'tavern': return w.heroes.length === 0 ? 'The tavern is empty. Heroes sign up when agents start working.' : 'Resting at the tavern'
+    case 'travel': return `Travelling through the ${region}…`
+    case 'fight': return sideOf(w, 'enemy').some(f => f.rank === 'boss') ? 'Boss fight!' : `Fighting in the ${region}`
+    case 'victory': return 'Victory!'
+    case 'fork': return w.scene.route === undefined
+      ? 'The party argues about the route…'
+      : `${w.scene.by ?? 'The party'} picks the ${w.scene.route === 'danger' ? 'dark path' : 'quiet trail'}`
+    case 'camp': return 'Camping before the boss'
+    case 'wipe': return 'Defeated… waking up in the tavern'
+    case 'cleared': return 'Run cleared!'
+  }
+}
+
+/** Turns the world into what the pane draws. */
+export function toView(w: World): ViewData {
+  const run = w.run
+  const active = new Set(partyIds(w))
+  const fighting = w.fighters.length > 0
+  const heroUnits: UnitView[] = fighting
+    ? sideOf(w, 'hero').map(f => {
+        const hero = heroById(w, f.id)
+        return { ...unit(f), title: CLASSES[f.look as ClassId]?.name ?? f.look, isActive: true, xpShare: hero === undefined ? 0 : hero.xp / xpToNext(hero.level) }
+      })
+    : w.heroes
+        .filter(hero => !hero.isRecruit && (w.scene.kind === 'tavern' || active.has(hero.id)))
+        .map(hero => {
+          const f = heroFighter(hero, w.scene.kind === 'tavern' ? null : run)
+          return {
+            ...unit(f),
+            title: CLASSES[hero.cls].name,
+            isActive: active.has(hero.id),
+            xpShare: hero.xp / xpToNext(hero.level),
+            skills: hero.skills.map(id => SKILLS[id]?.name ?? id),
+            ...(hero.motto === undefined ? {} : { motto: hero.motto }),
+            trophies: hero.trophies.length,
+          }
+        })
+  const recruits = w.heroes.filter(hero => hero.isRecruit).map(hero => ({
+    id: hero.id, name: 'Recruit', look: 'recruit', side: 'hero' as const, level: 1, hp: 1, maxHp: 1, rank: 'normal' as const,
+    isDown: false, tags: [], title: 'Signing up…', isActive: true,
+  }))
+  return {
+    scene: w.scene.kind,
+    region: run === null ? null : { id: run.region, name: REGIONS[run.region].name },
+    runNumber: run?.number ?? w.runs,
+    stops: run === null ? [] : run.path.map((kind, i) => ({ kind, state: i < run.at ? 'done' : i === run.at ? 'here' : 'ahead' })),
+    heroes: [...heroUnits, ...recruits],
+    enemies: sideOf(w, 'enemy').map(f => ({ ...unit(f), title: f.rank === 'boss' ? 'Boss' : f.rank === 'elite' ? 'Elite' : '' })),
+    log: w.log.slice(-6),
+    fx: w.fx,
+    relics: (run?.relics ?? []).map(id => RELICS[id]).filter(one => one !== undefined).map(one => ({ name: one.name, icon: one.icon, blurb: one.blurb })),
+    potions: run?.potions ?? 0,
+    caption: caption(w),
+    isCalm: w.isCalm,
+    trophies: new Set(w.heroes.flatMap(hero => hero.trophies)).size,
+    roster: w.heroes.filter(hero => !hero.isRecruit).sort((a, b) => b.level - a.level).map(hero => ({
+      id: hero.id,
+      name: hero.name,
+      look: hero.cls,
+      title: CLASSES[hero.cls].name,
+      level: hero.level,
+      xpShare: hero.xp / xpToNext(hero.level),
+      skills: hero.skills.map(id => SKILLS[id]?.name ?? id),
+      ...(hero.motto === undefined ? {} : { motto: hero.motto }),
+      trophies: hero.trophies.length,
+      isActive: active.has(hero.id),
+      record: [
+        `${hero.record.runs} run${hero.record.runs === 1 ? '' : 's'}`,
+        `${hero.record.wins} cleared`,
+        `${hero.record.kills} foes`,
+        hero.record.wipes > 0 ? `${hero.record.wipes} wipe${hero.record.wipes === 1 ? '' : 's'}` : '',
+      ].filter(Boolean).join(' · '),
+    })),
+    threat: Math.round(w.threat * 100),
+  }
+}
+
+function unit(f: Fighter): Omit<UnitView, 'title'> {
+  return {
+    id: f.id, name: f.name, look: f.look, side: f.side, level: f.level, hp: f.hp, maxHp: f.maxHp, rank: f.rank,
+    isDown: f.hp === 0, tags: [...new Set(f.effects.map(one => TAGS[one.kind]))],
+  }
+}