terminal-mmo 0.1.0

package/dist/cli.js

@@ -0,0 +1,2274 @@
+#!/usr/bin/env bun
+// @bun
+
+// ../shared/src/constants.ts
+var WORLD = { w: 240, h: 40 };
+var GROUND_TOP = WORLD.h - 3;
+var BOX = { w: 5, h: 5 };
+var PHYS = {
+  speed: 22,
+  jump: 34,
+  grav: 90,
+  maxDt: 0.05
+};
+var COMBAT = {
+  meleeReach: 6,
+  meleeDamage: 8,
+  attackCooldown: 0.35,
+  iframes: 0.6
+};
+var MONSTER = {
+  chaserHp: 24,
+  chaserSpeed: 12,
+  chaserAggro: 22,
+  chaserDeadzone: 2,
+  contactDamage: 6
+};
+var SHOOTER = {
+  hp: 16,
+  speed: 9,
+  aggro: 46,
+  keepDist: 20,
+  fireCooldown: 1.4,
+  projSpeed: 36,
+  projLife: 2.4,
+  projDamage: 7
+};
+var PROJECTILE = { w: 1, h: 1 };
+var PROGRESSION = { levelCap: 30 };
+var SPAWN = { x: 10, y: GROUND_TOP - BOX.h };
+var TOWN = { w: 80 };
+var TOWN_SPAWN = { x: 12, y: GROUND_TOP - BOX.h };
+var RESPAWN = { delaySec: 5 };
+var XP_PER_KILL = 12;
+var CHAT_MAX_LEN = 120;
+
+// ../shared/src/combat.ts
+function entityBox(e) {
+  return { x: e.x, y: e.y, w: BOX.w, h: BOX.h };
+}
+function meleeHitbox(p) {
+  const w = COMBAT.meleeReach;
+  return {
+    x: p.facing === 1 ? p.x + BOX.w : p.x - w,
+    y: p.y,
+    w,
+    h: BOX.h
+  };
+}
+function aabbOverlap(a, b) {
+  return a.x < b.x + b.w && a.x + a.w > b.x && a.y < b.y + b.h && a.y + a.h > b.y;
+}
+// ../shared/src/rng.ts
+function rngNext(state) {
+  const s = state + 1831565813 | 0;
+  let t = s;
+  t = Math.imul(t ^ t >>> 15, t | 1);
+  t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+  const value = ((t ^ t >>> 14) >>> 0) / 4294967296;
+  return { value, state: s };
+}
+
+// ../shared/src/loot.ts
+var BASES = [
+  { name: "Rusty Sword", slot: "weapon" },
+  { name: "Iron Sword", slot: "weapon" },
+  { name: "Leather Vest", slot: "armor" },
+  { name: "Chain Mail", slot: "armor" },
+  { name: "Copper Ring", slot: "accessory" },
+  { name: "Jade Amulet", slot: "accessory" }
+];
+var RARITIES = [
+  { name: "common", weight: 60, affixes: 1 },
+  { name: "uncommon", weight: 25, affixes: 2 },
+  { name: "rare", weight: 10, affixes: 3 },
+  { name: "epic", weight: 4, affixes: 4 },
+  { name: "legendary", weight: 1, affixes: 5 }
+];
+var AFFIXES = ["str", "dex", "int", "hp", "crit", "haste"];
+function rollItem(state, level) {
+  let r = rngNext(state);
+  state = r.state;
+  const total = RARITIES.reduce((a, b) => a + b.weight, 0);
+  let roll = r.value * total;
+  let rar = RARITIES[0];
+  for (const x of RARITIES) {
+    if (roll < x.weight) {
+      rar = x;
+      break;
+    }
+    roll -= x.weight;
+  }
+  r = rngNext(state);
+  state = r.state;
+  const base = BASES[Math.floor(r.value * BASES.length)];
+  const affixes = [];
+  for (let i = 0;i < rar.affixes; i++) {
+    r = rngNext(state);
+    state = r.state;
+    const stat = AFFIXES[Math.floor(r.value * AFFIXES.length)];
+    r = rngNext(state);
+    state = r.state;
+    const value = 1 + Math.floor(r.value * (level + 1));
+    affixes.push({ stat, value });
+  }
+  return {
+    item: {
+      id: 0,
+      base: base.name,
+      slot: base.slot,
+      rarity: rar.name,
+      affixes
+    },
+    state
+  };
+}
+// ../shared/src/terrain.ts
+function isSolid(t, cx, cy) {
+  if (cx < 0 || cx >= t.w)
+    return true;
+  if (cy < 0)
+    return false;
+  if (cy >= t.h)
+    return true;
+  return t.cells[cy * t.w + cx] === 1;
+}
+function makeStarterField(seed = 1337) {
+  const { w, h } = WORLD;
+  const cells = new Uint8Array(w * h);
+  for (let y = GROUND_TOP;y < h; y++)
+    for (let x = 0;x < w; x++)
+      cells[y * w + x] = 1;
+  let s = seed;
+  const next = () => {
+    const r = rngNext(s);
+    s = r.state;
+    return r.value;
+  };
+  for (let i = 0;i < 70; i++) {
+    const px = Math.floor(next() * (w - 16)) + 2;
+    const py = GROUND_TOP - 4 - Math.floor(next() * 18);
+    const len = 6 + Math.floor(next() * 12);
+    for (let x = px;x < Math.min(px + len, w); x++)
+      cells[py * w + x] = 1;
+  }
+  return { w, h, cells };
+}
+function makeTownTerrain() {
+  const w = TOWN.w;
+  const h = WORLD.h;
+  const cells = new Uint8Array(w * h);
+  const solid = (x, y) => {
+    if (x >= 0 && x < w && y >= 0 && y < h)
+      cells[y * w + x] = 1;
+  };
+  for (let y = GROUND_TOP;y < h; y++)
+    for (let x = 0;x < w; x++)
+      solid(x, y);
+  for (let y = GROUND_TOP - 12;y < GROUND_TOP; y++) {
+    solid(0, y);
+    solid(w - 1, y);
+  }
+  const daisY = GROUND_TOP - 3;
+  for (let x = Math.floor(w / 2) - 6;x <= Math.floor(w / 2) + 6; x++)
+    solid(x, daisY);
+  return { w, h, cells };
+}
+
+// ../shared/src/physics.ts
+function stepEntity(t, src, ctl, dt) {
+  const e = { ...src };
+  e.vx = ctl.moveX * e.speed;
+  if (e.vx > 0)
+    e.facing = 1;
+  else if (e.vx < 0)
+    e.facing = -1;
+  if (ctl.jump && e.onGround) {
+    e.vy = -PHYS.jump;
+    e.onGround = false;
+  }
+  let hitWall = false;
+  e.x += e.vx * dt;
+  const top = Math.floor(e.y);
+  const bot = Math.ceil(e.y + BOX.h) - 1;
+  if (e.vx > 0) {
+    const r2 = Math.ceil(e.x + BOX.w) - 1;
+    for (let cy = top;cy <= bot; cy++)
+      if (isSolid(t, r2, cy)) {
+        e.x = r2 - BOX.w;
+        e.vx = 0;
+        hitWall = true;
+        break;
+      }
+  } else if (e.vx < 0) {
+    const l2 = Math.floor(e.x);
+    for (let cy = top;cy <= bot; cy++)
+      if (isSolid(t, l2, cy)) {
+        e.x = l2 + 1;
+        e.vx = 0;
+        hitWall = true;
+        break;
+      }
+  }
+  e.vy += PHYS.grav * dt;
+  e.y += e.vy * dt;
+  const l = Math.floor(e.x);
+  const r = Math.ceil(e.x + BOX.w) - 1;
+  e.onGround = false;
+  if (e.vy > 0) {
+    const feet = Math.ceil(e.y + BOX.h) - 1;
+    for (let cx = l;cx <= r; cx++)
+      if (isSolid(t, cx, feet)) {
+        e.y = feet - BOX.h;
+        e.vy = 0;
+        e.onGround = true;
+        break;
+      }
+  } else if (e.vy < 0) {
+    const head = Math.floor(e.y);
+    for (let cx = l;cx <= r; cx++)
+      if (isSolid(t, cx, head)) {
+        e.y = head + 1;
+        e.vy = 0;
+        break;
+      }
+  }
+  return { e, hitWall };
+}
+// ../shared/src/progression.ts
+function xpToNext(level) {
+  if (level >= PROGRESSION.levelCap)
+    return Infinity;
+  return 20 + level * level * 4;
+}
+function maxHpForLevel(level) {
+  return 80 + (level - 1) * 12;
+}
+function applyXp(p, amount) {
+  let level = p.level;
+  let xp = p.xp + amount;
+  let leveled = 0;
+  while (level < PROGRESSION.levelCap && xp >= xpToNext(level)) {
+    xp -= xpToNext(level);
+    level++;
+    leveled++;
+  }
+  if (level >= PROGRESSION.levelCap)
+    xp = 0;
+  return { progress: { level, xp, gold: p.gold }, leveled };
+}
+
+// ../shared/src/player.ts
+function spawnAvatar(x, y) {
+  return {
+    id: 1,
+    type: "player",
+    x,
+    y,
+    vx: 0,
+    vy: 0,
+    speed: PHYS.speed,
+    facing: 1,
+    onGround: false,
+    hp: maxHpForLevel(1),
+    maxHp: maxHpForLevel(1),
+    hurtT: 0,
+    attackT: 0
+  };
+}
+function spawnPlayerState(zoneId, x, y, seed = 1) {
+  return {
+    avatar: spawnAvatar(x, y),
+    progress: { level: 1, xp: 0, gold: 0 },
+    inventory: [],
+    zoneId,
+    log: ["Welcome. Hunt the chasers (j to attack)."],
+    nextId: 1,
+    rngState: seed,
+    class: "warrior",
+    skillCooldowns: {}
+  };
+}
+// ../shared/src/projectile.ts
+function projectileBox(p) {
+  return { x: p.x, y: p.y, w: PROJECTILE.w, h: PROJECTILE.h };
+}
+function spawnProjectile(id, owner, dir) {
+  return {
+    id,
+    x: dir === 1 ? owner.x + BOX.w : owner.x - PROJECTILE.w,
+    y: owner.y + Math.floor((BOX.h - PROJECTILE.h) / 2),
+    vx: dir * SHOOTER.projSpeed,
+    vy: 0,
+    life: SHOOTER.projLife,
+    damage: SHOOTER.projDamage,
+    ownerId: owner.id
+  };
+}
+function stepProjectile(t, p, dt) {
+  const life = p.life - dt;
+  if (life <= 0)
+    return null;
+  const x = p.x + p.vx * dt;
+  const y = p.y + p.vy * dt;
+  if (isSolid(t, Math.floor(x), Math.floor(y)))
+    return null;
+  return { ...p, x, y, life };
+}
+// ../shared/src/protocol.ts
+var PROTOCOL_VERSION = 1;
+var textEncoder = new TextEncoder;
+var textDecoder = new TextDecoder;
+
+class Writer {
+  buf = new Uint8Array(64);
+  view = new DataView(this.buf.buffer);
+  pos = 0;
+  ensure(n) {
+    if (this.pos + n <= this.buf.length)
+      return;
+    let len = this.buf.length;
+    while (len < this.pos + n)
+      len *= 2;
+    const next = new Uint8Array(len);
+    next.set(this.buf);
+    this.buf = next;
+    this.view = new DataView(this.buf.buffer);
+  }
+  u8(v) {
+    this.ensure(1);
+    this.view.setUint8(this.pos, v);
+    this.pos += 1;
+  }
+  i8(v) {
+    this.ensure(1);
+    this.view.setInt8(this.pos, v);
+    this.pos += 1;
+  }
+  u16(v) {
+    this.ensure(2);
+    this.view.setUint16(this.pos, v);
+    this.pos += 2;
+  }
+  u32(v) {
+    this.ensure(4);
+    this.view.setUint32(this.pos, v);
+    this.pos += 4;
+  }
+  i32(v) {
+    this.ensure(4);
+    this.view.setInt32(this.pos, v);
+    this.pos += 4;
+  }
+  f64(v) {
+    this.ensure(8);
+    this.view.setFloat64(this.pos, v);
+    this.pos += 8;
+  }
+  bool(v) {
+    this.u8(v ? 1 : 0);
+  }
+  str(s) {
+    const bytes = textEncoder.encode(s);
+    this.u32(bytes.length);
+    this.ensure(bytes.length);
+    this.buf.set(bytes, this.pos);
+    this.pos += bytes.length;
+  }
+  finish() {
+    return this.buf.subarray(0, this.pos);
+  }
+}
+
+class Reader {
+  buf;
+  view;
+  pos = 0;
+  constructor(buf) {
+    this.buf = buf;
+    this.view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+  }
+  u8() {
+    const v = this.view.getUint8(this.pos);
+    this.pos += 1;
+    return v;
+  }
+  i8() {
+    const v = this.view.getInt8(this.pos);
+    this.pos += 1;
+    return v;
+  }
+  u16() {
+    const v = this.view.getUint16(this.pos);
+    this.pos += 2;
+    return v;
+  }
+  u32() {
+    const v = this.view.getUint32(this.pos);
+    this.pos += 4;
+    return v;
+  }
+  i32() {
+    const v = this.view.getInt32(this.pos);
+    this.pos += 4;
+    return v;
+  }
+  f64() {
+    const v = this.view.getFloat64(this.pos);
+    this.pos += 8;
+    return v;
+  }
+  bool() {
+    return this.u8() !== 0;
+  }
+  str() {
+    const len = this.u32();
+    const bytes = this.buf.subarray(this.pos, this.pos + len);
+    this.pos += len;
+    return textDecoder.decode(bytes);
+  }
+  remaining() {
+    return this.buf.byteLength - this.pos;
+  }
+}
+var CLIENT_TAG = { hello: 1, input: 2, chat: 3 };
+function encodeClientMessage(msg) {
+  const w = new Writer;
+  switch (msg.t) {
+    case "hello":
+      w.u8(CLIENT_TAG.hello);
+      w.str(msg.handle);
+      w.u16(msg.protocol);
+      break;
+    case "input":
+      w.u8(CLIENT_TAG.input);
+      w.f64(msg.x);
+      w.f64(msg.y);
+      w.f64(msg.vx);
+      w.f64(msg.vy);
+      w.i8(msg.facing);
+      w.bool(msg.onGround);
+      w.bool(msg.attack);
+      w.bool(msg.interact);
+      w.u8(msg.skill ?? 0);
+      break;
+    case "chat":
+      w.u8(CLIENT_TAG.chat);
+      w.str(msg.text);
+      break;
+  }
+  return w.finish();
+}
+var SERVER_TAG = { welcome: 1, snapshot: 2, chat: 3, reject: 4 };
+var ENTITY_TYPES = ["player", "chaser", "shooter"];
+var SLOTS = ["weapon", "armor", "accessory"];
+var RARITIES2 = [
+  "common",
+  "uncommon",
+  "rare",
+  "epic",
+  "legendary"
+];
+function readAvatar(r) {
+  return {
+    sessionId: r.u32(),
+    handle: r.str(),
+    x: r.f64(),
+    y: r.f64(),
+    vx: r.f64(),
+    vy: r.f64(),
+    facing: r.i8(),
+    onGround: r.bool(),
+    hp: r.f64(),
+    maxHp: r.f64(),
+    hurtT: r.f64()
+  };
+}
+function readMonster(r) {
+  return {
+    id: r.u32(),
+    type: ENTITY_TYPES[r.u8()],
+    x: r.f64(),
+    y: r.f64(),
+    vx: r.f64(),
+    vy: r.f64(),
+    facing: r.i8(),
+    onGround: r.bool(),
+    hp: r.f64(),
+    maxHp: r.f64(),
+    hurtT: r.f64()
+  };
+}
+function readProjectile(r) {
+  return {
+    id: r.u32(),
+    x: r.f64(),
+    y: r.f64(),
+    vx: r.f64(),
+    vy: r.f64(),
+    life: r.f64(),
+    damage: r.f64(),
+    ownerId: r.u32()
+  };
+}
+function readItem(r) {
+  const id = r.u32();
+  const base = r.str();
+  const slot = SLOTS[r.u8()];
+  const rarity = RARITIES2[r.u8()];
+  const n = r.u32();
+  const affixes = [];
+  for (let i = 0;i < n; i++)
+    affixes.push({ stat: r.str(), value: r.i32() });
+  return { id, base, slot, rarity, affixes };
+}
+function decodeServerMessage(buf) {
+  const r = new Reader(buf);
+  const tag = r.u8();
+  switch (tag) {
+    case SERVER_TAG.welcome:
+      return {
+        t: "welcome",
+        sessionId: r.u32(),
+        zoneId: r.str(),
+        tickRate: r.u16()
+      };
+    case SERVER_TAG.snapshot: {
+      const tick = r.u32();
+      const zoneId = r.str();
+      const avatars = [];
+      for (let i = r.u32();i > 0; i--)
+        avatars.push(readAvatar(r));
+      const monsters = [];
+      for (let i = r.u32();i > 0; i--)
+        monsters.push(readMonster(r));
+      const projectiles = [];
+      for (let i = r.u32();i > 0; i--)
+        projectiles.push(readProjectile(r));
+      const progress = {
+        level: r.u32(),
+        xp: r.u32(),
+        gold: r.u32()
+      };
+      const inventory = [];
+      for (let i = r.u32();i > 0; i--)
+        inventory.push(readItem(r));
+      const log = [];
+      for (let i = r.u32();i > 0; i--)
+        log.push(r.str());
+      return {
+        t: "snapshot",
+        tick,
+        zoneId,
+        avatars,
+        monsters,
+        projectiles,
+        progress,
+        inventory,
+        log
+      };
+    }
+    case SERVER_TAG.chat:
+      return { t: "chat", sessionId: r.u32(), handle: r.str(), text: r.str() };
+    case SERVER_TAG.reject:
+      return { t: "reject", reason: r.str() };
+    default:
+      throw new Error(`unknown server message tag ${tag}`);
+  }
+}
+// ../shared/src/skills.ts
+var POWER_STRIKE = {
+  id: "power-strike",
+  name: "Power Strike",
+  unlockLevel: 1,
+  cooldown: 2.5,
+  damage: 20,
+  reach: 9
+};
+var WARRIOR_SKILLS = [POWER_STRIKE];
+var SKILLS_BY_CLASS = {
+  warrior: WARRIOR_SKILLS
+};
+function skillForSlot(cls, slot) {
+  return SKILLS_BY_CLASS[cls]?.[slot - 1];
+}
+function skillUnlocked(skill, level) {
+  return level >= skill.unlockLevel;
+}
+function skillHitbox(e, skill) {
+  return {
+    x: e.facing === 1 ? e.x + BOX.w : e.x - skill.reach,
+    y: e.y,
+    w: skill.reach,
+    h: BOX.h
+  };
+}
+
+// ../shared/src/world.ts
+function activeZone(world, zoneId) {
+  return world.zones[zoneId];
+}
+function spawnMonster(type, id, x, y, spawnIndex) {
+  const hp = type === "shooter" ? SHOOTER.hp : MONSTER.chaserHp;
+  const speed = type === "shooter" ? SHOOTER.speed : MONSTER.chaserSpeed;
+  return {
+    id,
+    type,
+    x,
+    y,
+    vx: 0,
+    vy: 0,
+    speed,
+    facing: 1,
+    onGround: false,
+    hp,
+    maxHp: hp,
+    hurtT: 0,
+    attackT: 0,
+    spawnIndex
+  };
+}
+function makeFieldZone(id, seed = 1337) {
+  const terrain = makeStarterField(seed);
+  const spawns = [];
+  for (let i = 0;i < 8; i++) {
+    const x = 40 + i * 22;
+    const type = i % 3 === 2 ? "shooter" : "chaser";
+    spawns.push({ type, x, y: GROUND_TOP - BOX.h });
+  }
+  let mid = 2;
+  const monsters = spawns.map((s, i) => spawnMonster(s.type, mid++, s.x, s.y, i));
+  return {
+    id,
+    type: "field",
+    terrain,
+    monsters,
+    projectiles: [],
+    nextProjectileId: 1,
+    spawns,
+    respawns: [],
+    nextMonsterId: mid,
+    portals: [
+      {
+        x: 24,
+        y: GROUND_TOP - 7,
+        w: 4,
+        h: 7,
+        target: "town-01",
+        arrival: { x: 12, y: GROUND_TOP - BOX.h }
+      }
+    ]
+  };
+}
+function makeTownZone(id) {
+  return {
+    id,
+    type: "town",
+    terrain: makeTownTerrain(),
+    monsters: [],
+    projectiles: [],
+    nextProjectileId: 1,
+    spawns: [],
+    respawns: [],
+    nextMonsterId: 1,
+    portals: [
+      {
+        x: TOWN.w - 16,
+        y: GROUND_TOP - 7,
+        w: 4,
+        h: 7,
+        target: "field-01",
+        arrival: { x: SPAWN.x, y: SPAWN.y }
+      }
+    ],
+    npcs: [
+      {
+        id: 1,
+        kind: "vendor",
+        name: "Merchant",
+        x: 32,
+        y: GROUND_TOP - BOX.h,
+        w: 4,
+        h: BOX.h
+      }
+    ]
+  };
+}
+
+// ../shared/src/zone.ts
+function clientStepAvatar(t, avatar, ctl, dtMs) {
+  const dt = Math.min(dtMs / 1000, PHYS.maxDt);
+  const e = stepEntity(t, avatar, ctl, dt).e;
+  e.attackT = Math.max(0, e.attackT - dt);
+  e.hurtT = Math.max(0, e.hurtT - dt);
+  return e;
+}
+function resolveAvatarIntent(src, intent, dt) {
+  let avatar = {
+    ...src.avatar,
+    x: intent.x,
+    y: intent.y,
+    vx: intent.vx,
+    vy: intent.vy,
+    facing: intent.facing,
+    onGround: intent.onGround
+  };
+  avatar.attackT = Math.max(0, avatar.attackT - dt);
+  avatar.hurtT = Math.max(0, avatar.hurtT - dt);
+  const log = src.log.slice(-5);
+  const attacking = intent.attack && avatar.attackT <= 0;
+  if (attacking)
+    avatar = { ...avatar, attackT: COMBAT.attackCooldown };
+  let hb = attacking ? meleeHitbox(avatar) : null;
+  let damage = COMBAT.meleeDamage;
+  const skillCooldowns = {};
+  for (const [id, cd] of Object.entries(src.skillCooldowns ?? {}))
+    skillCooldowns[id] = Math.max(0, cd - dt);
+  if (intent.skill) {
+    const skill = skillForSlot(src.class ?? "warrior", intent.skill);
+    if (skill && skillUnlocked(skill, src.progress.level) && (skillCooldowns[skill.id] ?? 0) <= 0) {
+      skillCooldowns[skill.id] = skill.cooldown;
+      hb = skillHitbox(avatar, skill);
+      damage = skill.damage;
+      log.push(`${skill.name}!`);
+    }
+  }
+  return { sa: { ...src, avatar, log, skillCooldowns }, hb, damage };
+}
+function nearestAvatar(avatars, mx) {
+  let best = -1;
+  let bestAdx = Infinity;
+  for (let i = 0;i < avatars.length; i++) {
+    const adx = Math.abs(avatars[i].avatar.x - mx);
+    if (adx < bestAdx) {
+      bestAdx = adx;
+      best = i;
+    }
+  }
+  return best;
+}
+function stepZone(state, intents, dtMs) {
+  const dt = Math.min(dtMs / 1000, PHYS.maxDt);
+  const zone = state.zone;
+  const t = zone.terrain;
+  const byId = new Map(intents.map((i) => [i.sessionId, i]));
+  const hitboxes = [];
+  const damages = [];
+  const avatars = state.avatars.map((src) => {
+    const intent = byId.get(src.sessionId);
+    if (!intent) {
+      const avatar = {
+        ...src.avatar,
+        attackT: Math.max(0, src.avatar.attackT - dt),
+        hurtT: Math.max(0, src.avatar.hurtT - dt)
+      };
+      hitboxes.push(null);
+      damages.push(0);
+      return { ...src, avatar, log: src.log.slice(-5) };
+    }
+    const { sa, hb, damage } = resolveAvatarIntent(src, intent, dt);
+    hitboxes.push(hb);
+    damages.push(damage);
+    return sa;
+  });
+  const fired = [];
+  let nextProjectileId = zone.nextProjectileId;
+  let nextMonsterId = zone.nextMonsterId;
+  const respawns = [];
+  const monsters = [];
+  for (const m0 of zone.monsters) {
+    let m = { ...m0 };
+    m.hurtT = Math.max(0, m.hurtT - dt);
+    m.attackT = Math.max(0, m.attackT - dt);
+    const target = nearestAvatar(avatars, m.x);
+    const dx = target >= 0 ? avatars[target].avatar.x - m.x : 0;
+    const adx = Math.abs(dx);
+    const engaged = target >= 0 && m.type === "shooter" && adx < SHOOTER.aggro;
+    let moveX;
+    if (target >= 0 && m.type === "chaser" && adx < MONSTER.chaserAggro)
+      moveX = adx < MONSTER.chaserDeadzone ? 0 : dx > 0 ? 1 : -1;
+    else if (engaged)
+      moveX = adx < SHOOTER.keepDist ? dx > 0 ? -1 : 1 : 0;
+    else
+      moveX = m.facing;
+    const res = stepEntity(t, m, { moveX, jump: false }, dt);
+    m = res.e;
+    if (m.onGround && !engaged) {
+      const lead = moveX >= 0 ? Math.ceil(m.x + BOX.w) - 1 : Math.floor(m.x);
+      const footY = Math.ceil(m.y + BOX.h);
+      if (res.hitWall || !isSolid(t, lead, footY))
+        m.facing = m.facing === 1 ? -1 : 1;
+    }
+    if (engaged) {
+      const dir = dx >= 0 ? 1 : -1;
+      m.facing = dir;
+      if (m.attackT <= 0) {
+        fired.push(spawnProjectile(nextProjectileId++, m, dir));
+        m = { ...m, attackT: SHOOTER.fireCooldown };
+      }
+    }
+    let killer = -1;
+    for (let i = 0;i < avatars.length; i++) {
+      const hb = hitboxes[i];
+      if (hb && m.hurtT <= 0 && aabbOverlap(hb, entityBox(m))) {
+        m = { ...m, hp: m.hp - damages[i], hurtT: 0.6 };
+        killer = i;
+        break;
+      }
+    }
+    if (m.hp > 0) {
+      for (let i = 0;i < avatars.length; i++) {
+        const a = avatars[i].avatar;
+        if (a.hurtT <= 0 && aabbOverlap(entityBox(a), entityBox(m))) {
+          avatars[i] = {
+            ...avatars[i],
+            avatar: {
+              ...a,
+              hp: a.hp - MONSTER.contactDamage,
+              hurtT: 0.6
+            }
+          };
+        }
+      }
+    }
+    if (m.hp > 0) {
+      monsters.push(m);
+    } else {
+      const credited = killer >= 0 ? killer : 0;
+      avatars[credited] = grantKill(avatars[credited]);
+      if (m.spawnIndex !== undefined)
+        respawns.push({
+          spawnIndex: m.spawnIndex,
+          remaining: RESPAWN.delaySec
+        });
+    }
+  }
+  for (const r of zone.respawns) {
+    const remaining = r.remaining - dt;
+    if (remaining > 0) {
+      respawns.push({ ...r, remaining });
+      continue;
+    }
+    const s = zone.spawns[r.spawnIndex];
+    monsters.push(spawnMonster(s.type, nextMonsterId++, s.x, s.y, r.spawnIndex));
+  }
+  const projectiles = [];
+  for (const pr0 of zone.projectiles) {
+    const pr = stepProjectile(t, pr0, dt);
+    if (!pr)
+      continue;
+    let consumed = false;
+    for (let i = 0;i < avatars.length; i++) {
+      const a = avatars[i].avatar;
+      if (a.hurtT <= 0 && aabbOverlap(projectileBox(pr), entityBox(a))) {
+        avatars[i] = {
+          ...avatars[i],
+          avatar: { ...a, hp: a.hp - pr.damage, hurtT: COMBAT.iframes }
+        };
+        consumed = true;
+        break;
+      }
+    }
+    if (!consumed)
+      projectiles.push(pr);
+  }
+  projectiles.push(...fired);
+  const deaths = [];
+  for (let i = 0;i < avatars.length; i++) {
+    const a = avatars[i].avatar;
+    if (a.hp <= 0) {
+      deaths.push(avatars[i].sessionId);
+      avatars[i] = {
+        ...avatars[i],
+        avatar: {
+          ...a,
+          hp: a.maxHp,
+          x: SPAWN.x,
+          y: SPAWN.y,
+          vx: 0,
+          vy: 0,
+          hurtT: 1
+        },
+        log: [...avatars[i].log, "You fell. Respawned in safety."]
+      };
+    }
+  }
+  const newZone = {
+    ...zone,
+    monsters,
+    projectiles,
+    nextProjectileId,
+    respawns,
+    nextMonsterId
+  };
+  return { zone: newZone, avatars, tick: state.tick + 1, deaths };
+}
+function grantKill(sa) {
+  const ap = applyXp(sa.progress, XP_PER_KILL);
+  const log = [...sa.log];
+  let avatar = sa.avatar;
+  if (ap.leveled > 0) {
+    const mhp = maxHpForLevel(ap.progress.level);
+    avatar = { ...avatar, maxHp: mhp, hp: mhp };
+    log.push(`Level up! Now level ${ap.progress.level}.`);
+  }
+  const roll = rollItem(sa.rngState, ap.progress.level);
+  const item = { ...roll.item, id: sa.nextId };
+  log.push(`Looted ${item.rarity} ${item.base}.`);
+  return {
+    ...sa,
+    avatar,
+    progress: ap.progress,
+    inventory: [...sa.inventory, item],
+    nextId: sa.nextId + 1,
+    rngState: roll.state,
+    log
+  };
+}
+// ../shared/src/sim.ts
+function createGame(seed = 1) {
+  const field = makeFieldZone("field-01");
+  const town = makeTownZone("town-01");
+  const player = spawnPlayerState(field.id, SPAWN.x, SPAWN.y, seed);
+  return {
+    player,
+    world: { zones: { [field.id]: field, [town.id]: town }, tick: 0 }
+  };
+}
+function step(game, input, dtMs) {
+  const dt = Math.min(dtMs / 1000, PHYS.maxDt);
+  const zone = game.world.zones[game.player.zoneId];
+  const t = zone.terrain;
+  if (input.interact) {
+    const here = entityBox(game.player.avatar);
+    const portal = zone.portals.find((p) => aabbOverlap(here, p));
+    if (portal) {
+      const avatar = {
+        ...game.player.avatar,
+        x: portal.arrival.x,
+        y: portal.arrival.y,
+        vx: 0,
+        vy: 0,
+        onGround: false
+      };
+      const dest = game.world.zones[portal.target];
+      const log = [...game.player.log.slice(-5), `Entered the ${dest.type}.`];
+      const player2 = {
+        ...game.player,
+        avatar,
+        zoneId: portal.target,
+        log
+      };
+      return { player: player2, world: { ...game.world, tick: game.world.tick + 1 } };
+    }
+  }
+  const predicted = stepEntity(t, game.player.avatar, { moveX: input.moveX, jump: input.jump }, dt).e;
+  const sa = {
+    sessionId: game.player.avatar.id,
+    handle: "",
+    avatar: game.player.avatar,
+    progress: game.player.progress,
+    inventory: game.player.inventory,
+    log: game.player.log,
+    nextId: game.player.nextId,
+    rngState: game.player.rngState,
+    class: game.player.class,
+    skillCooldowns: game.player.skillCooldowns
+  };
+  const intent = {
+    sessionId: sa.sessionId,
+    x: predicted.x,
+    y: predicted.y,
+    vx: predicted.vx,
+    vy: predicted.vy,
+    facing: predicted.facing,
+    onGround: predicted.onGround,
+    attack: input.attack,
+    skill: input.skill
+  };
+  const next = stepZone({ zone, avatars: [sa], tick: game.world.tick }, [intent], dtMs);
+  const out = next.avatars[0];
+  const player = {
+    avatar: out.avatar,
+    progress: out.progress,
+    inventory: out.inventory,
+    zoneId: game.player.zoneId,
+    log: out.log,
+    nextId: out.nextId,
+    rngState: out.rngState,
+    class: out.class,
+    skillCooldowns: out.skillCooldowns
+  };
+  const world = {
+    zones: { ...game.world.zones, [zone.id]: next.zone },
+    tick: next.tick
+  };
+  return { player, world };
+}
+// ../shared/src/vendor.ts
+var RARITY_VALUE = {
+  common: 5,
+  uncommon: 12,
+  rare: 30,
+  epic: 75,
+  legendary: 200
+};
+var AFFIX_VALUE = 2;
+function saleValue(item) {
+  const affixTotal = item.affixes.reduce((a, x) => a + x.value, 0);
+  return RARITY_VALUE[item.rarity] + AFFIX_VALUE * affixTotal;
+}
+function sellItem(progress, inventory, itemId) {
+  const item = inventory.find((i) => i.id === itemId);
+  if (!item)
+    return { progress, inventory };
+  return {
+    progress: { ...progress, gold: progress.gold + saleValue(item) },
+    inventory: inventory.filter((i) => i.id !== itemId)
+  };
+}
+// ../client/src/index.ts
+import { createCliRenderer } from "@opentui/core";
+
+// ../client/src/chat.ts
+var MAX_LEN = CHAT_MAX_LEN;
+
+class ChatInput {
+  open = false;
+  text = "";
+  start() {
+    this.open = true;
+    this.text = "";
+  }
+  cancel() {
+    this.open = false;
+    this.text = "";
+  }
+  key(k) {
+    if (!this.open)
+      return { action: "none" };
+    if (k.name === "return") {
+      const text = this.text.trim();
+      this.cancel();
+      return text ? { action: "send", text } : { action: "cancel" };
+    }
+    if (k.name === "escape") {
+      this.cancel();
+      return { action: "cancel" };
+    }
+    if (k.name === "backspace") {
+      this.text = this.text.slice(0, -1);
+      return { action: "edit" };
+    }
+    if (k.ctrl || k.meta)
+      return { action: "edit" };
+    const ch = k.name === "space" ? " " : k.sequence ?? "";
+    if (ch.length === 1 && ch >= " " && ch !== "\x7F" && this.text.length < MAX_LEN)
+      this.text += ch;
+    return { action: "edit" };
+  }
+}
+
+// ../client/src/hud.ts
+import {
+  BoxRenderable,
+  TextRenderable
+} from "@opentui/core";
+
+// ../client/src/theme.ts
+import { RGBA } from "@opentui/core";
+var COLORS = {
+  bg: RGBA.fromInts(16, 18, 26, 255),
+  terrainFg: RGBA.fromInts(70, 82, 104, 255),
+  terrainBg: RGBA.fromInts(34, 40, 54, 255),
+  transparent: RGBA.fromInts(0, 0, 0, 0),
+  hurt: RGBA.fromInts(255, 240, 120, 255),
+  melee: RGBA.fromInts(255, 245, 200, 255),
+  projectile: RGBA.fromInts(255, 120, 80, 255),
+  portal: RGBA.fromInts(180, 130, 255, 255),
+  vendor: RGBA.fromInts(255, 200, 90, 255),
+  hud: RGBA.fromInts(232, 232, 238, 255),
+  hudBg: RGBA.fromInts(8, 9, 13, 255),
+  hp: RGBA.fromInts(90, 220, 120, 255),
+  dim: RGBA.fromInts(150, 156, 168, 255),
+  chat: RGBA.fromInts(120, 200, 235, 255),
+  bubbleFg: RGBA.fromInts(236, 236, 242, 255),
+  bubbleBorder: RGBA.fromInts(120, 200, 235, 255),
+  bubbleBg: RGBA.fromInts(20, 24, 34, 255)
+};
+
+// ../client/src/hud.ts
+var HINT = "move \u2190/\u2192 a/d  jump \u2423/\u2191  attack j/x  skill k  interact e  chat \u23CE  quit q";
+var Z = 10;
+var CHAT_LINES = 4;
+function skillReadout(player2) {
+  const segs = [];
+  for (let slot = 1;; slot++) {
+    const skill = skillForSlot(player2.class ?? "warrior", slot);
+    if (!skill)
+      break;
+    let state;
+    if (!skillUnlocked(skill, player2.progress.level))
+      state = `L${skill.unlockLevel}`;
+    else {
+      const cd = player2.skillCooldowns?.[skill.id] ?? 0;
+      state = cd > 0 ? `${cd.toFixed(1)}s` : "ready";
+    }
+    segs.push(`k ${skill.name}: ${state}`);
+  }
+  return segs.join("   ");
+}
+
+class Hud {
+  topBar;
+  bottom;
+  stats;
+  alpha;
+  meta;
+  skills;
+  log;
+  chat;
+  chatInput;
+  constructor(ctx) {
+    this.topBar = new BoxRenderable(ctx, {
+      position: "absolute",
+      top: 0,
+      left: 0,
+      right: 0,
+      height: 1,
+      flexDirection: "row",
+      justifyContent: "space-between",
+      backgroundColor: COLORS.hudBg,
+      shouldFill: true,
+      zIndex: Z
+    });
+    this.stats = new TextRenderable(ctx, {
+      content: "",
+      fg: COLORS.hud,
+      bg: COLORS.hudBg
+    });
+    this.alpha = new TextRenderable(ctx, {
+      content: "",
+      fg: COLORS.vendor,
+      bg: COLORS.hudBg
+    });
+    this.meta = new TextRenderable(ctx, {
+      content: "",
+      fg: COLORS.dim,
+      bg: COLORS.hudBg
+    });
+    this.topBar.add(this.stats);
+    this.topBar.add(this.alpha);
+    this.topBar.add(this.meta);
+    this.bottom = new BoxRenderable(ctx, {
+      position: "absolute",
+      bottom: 0,
+      left: 1,
+      flexDirection: "column",
+      zIndex: Z
+    });
+    this.bottom.add(new TextRenderable(ctx, { content: HINT, fg: COLORS.dim, bg: COLORS.bg }));
+    this.skills = new TextRenderable(ctx, {
+      content: "",
+      fg: COLORS.melee,
+      bg: COLORS.bg
+    });
+    this.bottom.add(this.skills);
+    this.log = new TextRenderable(ctx, {
+      content: "",
+      fg: COLORS.dim,
+      bg: COLORS.bg
+    });
+    this.bottom.add(this.log);
+    this.chat = new TextRenderable(ctx, {
+      content: "",
+      fg: COLORS.chat,
+      bg: COLORS.bg
+    });
+    this.bottom.add(this.chat);
+    this.chatInput = new TextRenderable(ctx, {
+      content: "",
+      fg: COLORS.melee,
+      bg: COLORS.bg
+    });
+    this.bottom.add(this.chatInput);
+  }
+  attach(parent) {
+    parent.add(this.topBar);
+    parent.add(this.bottom);
+  }
+  showAlphaNotice() {
+    this.alpha.content = " \u26A0 ALPHA \xB7 progress resets when the server restarts ";
+  }
+  update(game, fps) {
+    const { player: player2 } = game;
+    const p = player2.avatar;
+    const zone2 = activeZone(game.world, player2.zoneId);
+    const hpPct = Math.max(0, Math.round(p.hp / p.maxHp * 100));
+    this.stats.content = ` L${player2.progress.level}  HP ${Math.max(0, Math.round(p.hp))}/${p.maxHp} (${hpPct}%)  XP ${player2.progress.xp}  Gold ${player2.progress.gold}  Items ${player2.inventory.length} `;
+    this.meta.content = `FPS ${fps}  monsters ${zone2.monsters.length} `;
+    this.skills.content = skillReadout(player2);
+    this.log.content = player2.log.slice(-3).join(`
+`);
+  }
+  updateChat(lines, open, draft) {
+    this.chat.content = lines.slice(-CHAT_LINES).join(`
+`);
+    this.chatInput.content = open ? `say> ${draft}\u2588` : "";
+  }
+}
+
+// ../client/src/input.ts
+var HELD_MS = 220;
+function actionFor(name) {
+  switch (name) {
+    case "left":
+    case "a":
+      return "left";
+    case "right":
+    case "d":
+      return "right";
+    case "up":
+    case "space":
+      return "jump";
+    case "j":
+    case "x":
+      return "attack";
+    case "e":
+      return "interact";
+    case "k":
+      return "skill1";
+    default:
+      return null;
+  }
+}
+
+class InputState {
+  held = new Set;
+  seen = new Map;
+  releaseCapable = false;
+  press(name, now) {
+    const a = actionFor(name);
+    if (!a)
+      return;
+    this.held.add(a);
+    this.seen.set(a, now);
+  }
+  release(name) {
+    this.releaseCapable = true;
+    const a = actionFor(name);
+    if (a)
+      this.held.delete(a);
+  }
+  clear() {
+    this.held.clear();
+  }
+  poll(now) {
+    if (!this.releaseCapable) {
+      for (const a of [...this.held])
+        if (now - (this.seen.get(a) ?? 0) > HELD_MS)
+          this.held.delete(a);
+    }
+    const moveX = (this.held.has("right") ? 1 : 0) - (this.held.has("left") ? 1 : 0);
+    return {
+      moveX,
+      jump: this.held.has("jump"),
+      attack: this.held.has("attack"),
+      interact: this.held.has("interact"),
+      skill: this.held.has("skill1") ? 1 : undefined
+    };
+  }
+}
+
+// ../client/src/bubble.ts
+function bubbleTtl(len) {
+  return Math.max(3, Math.min(7, 2 + 0.05 * len));
+}
+var BUBBLE_COLS = 22;
+function layoutBubble(text, maxCols = BUBBLE_COLS) {
+  const lines = [];
+  let cur = "";
+  for (const raw of text.split(/\s+/).filter(Boolean)) {
+    let word = raw;
+    while (word.length > maxCols) {
+      if (cur) {
+        lines.push(cur);
+        cur = "";
+      }
+      lines.push(word.slice(0, maxCols));
+      word = word.slice(maxCols);
+    }
+    if (!cur)
+      cur = word;
+    else if (cur.length + 1 + word.length <= maxCols)
+      cur += ` ${word}`;
+    else {
+      lines.push(cur);
+      cur = word;
+    }
+  }
+  if (cur)
+    lines.push(cur);
+  return lines.length ? lines : [""];
+}
+
+// ../client/src/interp.ts
+var INTERP_DELAY_MS = 100;
+function lerp(a, b, t) {
+  return a + (b - a) * t;
+}
+function lerpSnapshot(older, newer, alpha) {
+  const prevAvatar = new Map(older.avatars.map((a) => [a.sessionId, a]));
+  const avatars = newer.avatars.map((a) => {
+    const prev = prevAvatar.get(a.sessionId);
+    if (!prev)
+      return a;
+    return { ...a, x: lerp(prev.x, a.x, alpha), y: lerp(prev.y, a.y, alpha) };
+  });
+  const prevMonster = new Map(older.monsters.map((m) => [m.id, m]));
+  const monsters = newer.monsters.map((m) => {
+    const prev = prevMonster.get(m.id);
+    if (!prev)
+      return m;
+    return { ...m, x: lerp(prev.x, m.x, alpha), y: lerp(prev.y, m.y, alpha) };
+  });
+  return { ...newer, avatars, monsters };
+}
+var MAX_HISTORY_MS = 1000;
+
+class SnapshotBuffer {
+  frames = [];
+  get size() {
+    return this.frames.length;
+  }
+  push(snap, recvTimeMs) {
+    this.frames.push({ snap, t: recvTimeMs });
+    const cutoff = recvTimeMs - MAX_HISTORY_MS;
+    let keepFrom = 0;
+    while (keepFrom < this.frames.length - 2 && this.frames[keepFrom].t < cutoff)
+      keepFrom++;
+    if (keepFrom > 0)
+      this.frames = this.frames.slice(keepFrom);
+  }
+  sample(renderTimeMs) {
+    const frames = this.frames;
+    if (frames.length === 0)
+      return null;
+    if (renderTimeMs <= frames[0].t)
+      return frames[0].snap;
+    const last = frames[frames.length - 1];
+    if (renderTimeMs >= last.t)
+      return last.snap;
+    for (let i = 0;i < frames.length - 1; i++) {
+      const a = frames[i];
+      const b = frames[i + 1];
+      if (renderTimeMs >= a.t && renderTimeMs < b.t) {
+        const span = b.t - a.t;
+        const alpha = span > 0 ? (renderTimeMs - a.t) / span : 1;
+        return lerpSnapshot(a.snap, b.snap, alpha);
+      }
+    }
+    return last.snap;
+  }
+}
+
+// ../client/src/net.ts
+var MAX_CHAT_LOG = 100;
+
+class NetClient {
+  onReject;
+  ws;
+  buffer = new SnapshotBuffer;
+  sessionId = 0;
+  zoneId = "";
+  tickRate = 20;
+  ready = false;
+  latest = null;
+  chatLog = [];
+  bubbles = new Map;
+  rejected = null;
+  constructor(url, handle, onReject = () => {}) {
+    this.onReject = onReject;
+    this.ws = new WebSocket(url);
+    this.ws.binaryType = "arraybuffer";
+    this.ws.onopen = () => {
+      this.ws.send(encodeClientMessage({ t: "hello", handle, protocol: PROTOCOL_VERSION }));
+    };
+    this.ws.onmessage = (ev) => {
+      const msg = decodeServerMessage(new Uint8Array(ev.data));
+      this.ingest(msg, performance.now());
+    };
+    this.ws.onerror = () => {};
+  }
+  ingest(msg, recvTimeMs) {
+    if (msg.t === "welcome") {
+      this.sessionId = msg.sessionId;
+      this.zoneId = msg.zoneId;
+      this.tickRate = msg.tickRate;
+      this.ready = true;
+      return;
+    }
+    if (msg.t === "reject") {
+      this.rejected = msg.reason;
+      this.onReject(msg.reason);
+      return;
+    }
+    if (msg.t === "chat") {
+      this.chatLog.push(`${msg.handle}: ${msg.text}`);
+      if (this.chatLog.length > MAX_CHAT_LOG)
+        this.chatLog.splice(0, this.chatLog.length - MAX_CHAT_LOG);
+      this.bubbles.set(msg.sessionId, {
+        text: msg.text,
+        ttl: bubbleTtl(msg.text.length)
+      });
+      return;
+    }
+    if (msg.zoneId !== this.zoneId) {
+      this.zoneId = msg.zoneId;
+      this.buffer = new SnapshotBuffer;
+    }
+    this.latest = msg;
+    this.buffer.push(msg, recvTimeMs);
+  }
+  sample(nowMs) {
+    return this.buffer.sample(nowMs - INTERP_DELAY_MS);
+  }
+  decayBubbles(dtSec) {
+    for (const [id, b] of this.bubbles) {
+      b.ttl -= dtSec;
+      if (b.ttl <= 0)
+        this.bubbles.delete(id);
+    }
+  }
+  send(msg) {
+    if (this.ready && this.ws.readyState === WebSocket.OPEN)
+      this.ws.send(encodeClientMessage(msg));
+  }
+  close() {
+    try {
+      this.ws.close();
+    } catch {}
+  }
+  ownAvatar() {
+    return this.latest?.avatars.find((a) => a.sessionId === this.sessionId);
+  }
+}
+function avatarEntity(a) {
+  return {
+    id: a.sessionId,
+    type: "player",
+    name: a.handle,
+    x: a.x,
+    y: a.y,
+    vx: a.vx,
+    vy: a.vy,
+    speed: 0,
+    facing: a.facing,
+    onGround: a.onGround,
+    hp: a.hp,
+    maxHp: a.maxHp,
+    hurtT: a.hurtT,
+    attackT: 0
+  };
+}
+function monsterEntity(m) {
+  return {
+    id: m.id,
+    type: m.type,
+    x: m.x,
+    y: m.y,
+    vx: m.vx,
+    vy: m.vy,
+    speed: 0,
+    facing: m.facing,
+    onGround: m.onGround,
+    hp: m.hp,
+    maxHp: m.maxHp,
+    hurtT: m.hurtT,
+    attackT: 0
+  };
+}
+function snapshotToGame(field, predicted, ownSessionId, snapshot, localSkillCooldowns, bubbles = new Map) {
+  const monsters = snapshot ? snapshot.monsters.map(monsterEntity) : [];
+  const projectiles = snapshot ? snapshot.projectiles : [];
+  const others = snapshot ? snapshot.avatars.filter((a) => a.sessionId !== ownSessionId).map((a) => {
+    const e = avatarEntity(a);
+    const bubble = bubbles.get(a.sessionId)?.text;
+    if (bubble)
+      e.bubble = bubble;
+    return e;
+  }) : [];
+  const ownBubble = bubbles.get(ownSessionId)?.text;
+  const avatar = ownBubble ? { ...predicted, bubble: ownBubble } : predicted;
+  const progress = snapshot?.progress ?? { level: 1, xp: 0, gold: 0 };
+  const inventory = snapshot?.inventory ?? [];
+  const log = snapshot?.log ?? ["Connecting\u2026"];
+  const zone2 = { ...field, monsters, projectiles };
+  const player2 = {
+    avatar,
+    progress,
+    inventory,
+    zoneId: field.id,
+    log,
+    nextId: 0,
+    rngState: 0,
+    class: "warrior",
+    skillCooldowns: localSkillCooldowns
+  };
+  return {
+    player: player2,
+    world: { zones: { [field.id]: zone2 }, tick: snapshot?.tick ?? 0 },
+    others
+  };
+}
+
+// ../client/src/playfield.ts
+import {
+  Renderable
+} from "@opentui/core";
+
+// ../client/src/camera.ts
+var CAMERA = {
+  bandWidthFrac: 1 / 3,
+  bandHeight: 14,
+  snapDeltaCells: 8
+};
+var initCameraState = () => ({
+  cam: null,
+  center: null,
+  zoneId: null
+});
+function stepCamera(state, zoneId, avatarX, avatarY, view) {
+  const { sw, sh, ww, wh } = view;
+  const cx = avatarX + BOX.w / 2;
+  const cy = avatarY + BOX.h / 2;
+  const clampX = (x) => Math.max(0, Math.min(x, Math.max(0, ww - sw)));
+  const clampY = (y) => Math.max(0, Math.min(y, Math.max(0, wh - sh)));
+  const teleported = state.center !== null && (Math.abs(cx - state.center.x) > CAMERA.snapDeltaCells || Math.abs(cy - state.center.y) > CAMERA.snapDeltaCells);
+  let cam;
+  if (state.cam === null || zoneId !== state.zoneId || teleported) {
+    cam = { x: clampX(cx - sw / 2), y: clampY(cy - sh / 2) };
+  } else {
+    const bandW = sw * CAMERA.bandWidthFrac;
+    const bandH = Math.min(CAMERA.bandHeight, sh * 0.7);
+    let camX = state.cam.x;
+    let camY = state.cam.y;
+    const screenX = cx - camX;
+    const screenY = cy - camY;
+    if (screenX < (sw - bandW) / 2)
+      camX = cx - (sw - bandW) / 2;
+    else if (screenX > (sw + bandW) / 2)
+      camX = cx - (sw + bandW) / 2;
+    if (screenY < (sh - bandH) / 2)
+      camY = cy - (sh - bandH) / 2;
+    else if (screenY > (sh + bandH) / 2)
+      camY = cy - (sh + bandH) / 2;
+    cam = { x: clampX(camX), y: clampY(camY) };
+  }
+  return { cam, center: { x: cx, y: cy }, zoneId };
+}
+
+// ../client/src/sprites/sprite.ts
+var SENTINEL = "\xB7";
+var MIRROR = {
+  "(": ")",
+  ")": "(",
+  "[": "]",
+  "]": "[",
+  "{": "}",
+  "}": "{",
+  "<": ">",
+  ">": "<",
+  "/": "\\",
+  "\\": "/",
+  "`": "'",
+  "'": "`",
+  "\u258C": "\u2590",
+  "\u2590": "\u258C",
+  "\u2598": "\u259D",
+  "\u259D": "\u2598",
+  "\u2596": "\u2597",
+  "\u2597": "\u2596",
+  "\u259B": "\u259C",
+  "\u259C": "\u259B",
+  "\u2599": "\u259F",
+  "\u259F": "\u2599",
+  "\u259A": "\u259E",
+  "\u259E": "\u259A"
+};
+function splitTrimPad(art) {
+  const lines = art.split(`
+`);
+  while (lines.length > 0 && lines[0].trim() === "")
+    lines.shift();
+  while (lines.length > 0 && lines[lines.length - 1].trim() === "")
+    lines.pop();
+  const width = lines.reduce((w, l) => Math.max(w, l.length), 0);
+  return lines.map((l) => l.padEnd(width, " "));
+}
+function mirrorGlyphs(rows) {
+  return rows.map((row) => {
+    let out = "";
+    for (let i = row.length - 1;i >= 0; i--)
+      out += MIRROR[row[i]] ?? row[i];
+    return out;
+  });
+}
+function reverseRows(rows) {
+  return rows.map((row) => {
+    let out = "";
+    for (let i = row.length - 1;i >= 0; i--)
+      out += row[i];
+    return out;
+  });
+}
+
+class Sprite {
+  w;
+  h;
+  glyphRight;
+  glyphLeft;
+  colorRight;
+  colorLeft;
+  constructor(glyph, opts) {
+    const { defaultKey } = opts;
+    if (defaultKey.length !== 1)
+      throw new Error(`Sprite defaultKey must be a single char, got "${defaultKey}"`);
+    const glyphRows = splitTrimPad(glyph).map((r) => r.replaceAll(SENTINEL, " "));
+    this.h = glyphRows.length;
+    this.w = glyphRows.length > 0 ? glyphRows[0].length : 0;
+    let colorRows;
+    if (opts.colors === undefined) {
+      colorRows = glyphRows.map((r) => defaultKey.repeat(r.length));
+    } else {
+      const parsed = splitTrimPad(opts.colors);
+      const cw = parsed.length > 0 ? parsed[0].length : 0;
+      if (parsed.length !== this.h || cw !== this.w)
+        throw new Error(`Sprite colour grid (${cw}x${parsed.length}) must match glyph grid (${this.w}x${this.h})`);
+      colorRows = parsed.map((r) => Array.from(r, (c) => c === SENTINEL || c === " " ? defaultKey : c).join(""));
+    }
+    this.glyphRight = glyphRows;
+    this.glyphLeft = mirrorGlyphs(glyphRows);
+    this.colorRight = colorRows;
+    this.colorLeft = reverseRows(colorRows);
+  }
+  rows(facing = 1) {
+    return facing === 1 ? this.glyphRight : this.glyphLeft;
+  }
+  colorKeys(facing = 1) {
+    return facing === 1 ? this.colorRight : this.colorLeft;
+  }
+}
+
+// ../client/src/sprites/chaser.ts
+var GLYPH = `
+\u259A\xB7\u259F\u2599\xB7\u259E\xB7
+\u259F\u2588\u2588\u2588\u2588\u2599\xB7
+\u259E\u259B\u259B\u259B\u259B\u258C\xB7
+\u2590\u259F\u259F\u259F\u259F\u2596\xB7
+\u259E\xB7\xB7\xB7\xB7\u259A\xB7`;
+var COLORS2 = `
+\xB7\xB7\xB7\xB7\xB7\xB7\xB7
+\xB7g\xB7\xB7g\xB7\xB7
+\xB7\xB7\xB7\xB7\xB7\xB7\xB7
+\xB7\xB7\xB7\xB7\xB7\xB7\xB7
+\xB7\xB7\xB7\xB7\xB7\xB7\xB7`;
+var chaser = new Sprite(GLYPH, { defaultKey: "m", colors: COLORS2 });
+
+// ../client/src/sprites/merchant.ts
+var GLYPH2 = `
+\xB7\xB7\u259F\u2599\xB7\xB7
+\xB7\u259F\u2588\u2588\u2599\xB7
+\u259F\u259B\u2588\u2588\u259C\u2599
+\u2588\u2588\u2588\u2588\u2588\u2588
+\u259D\u2588\u2588\u2588\u2588\u2598`;
+var COLORS3 = `
+\xB7\xB7oo\xB7\xB7
+\xB7oooo\xB7
+oooooo
+cccccc
+\xB7oooo\xB7`;
+var merchant = new Sprite(GLYPH2, { defaultKey: "o", colors: COLORS3 });
+
+// ../client/src/sprites/player.ts
+var GLYPH3 = `
+\xB7\u2590\u259B\u2588\u2588\u2588\u259C\u258C\xB7
+\u259D\u259C\u2588\u2588\u2588\u2588\u2588\u259B\u2598
+\xB7\xB7\u2598\u2598\xB7\u259D\u259D\xB7\xB7`;
+var COLORS4 = `
+\xB7ppppppp\xB7
+ppppppppp
+\xB7\xB7pp\xB7pp\xB7\xB7`;
+var player2 = new Sprite(GLYPH3, { defaultKey: "p", colors: COLORS4 });
+
+// ../client/src/sprites/shooter.ts
+var GLYPH4 = `
+\xB7\u2597\u2584\u2584\u2584\u2596\xB7
+\u259F\u2588\u2588\u2588\u2588\u2588\u2599
+\u2588\u2588\u259F\u2588\u2599\u2588\u2588
+\u259C\u2588\u2588\u2588\u2588\u2588\u259B
+\xB7\u259D\u2580\u2580\u2580\u2598\xB7`;
+var COLORS5 = `
+\xB7ooooo\xB7
+oogggoo
+oggkggo
+oogggoo
+\xB7ooooo\xB7`;
+var shooter = new Sprite(GLYPH4, { defaultKey: "o", colors: COLORS5 });
+
+// ../client/src/sprites/palette.ts
+import { RGBA as RGBA2 } from "@opentui/core";
+var PALETTE = {
+  p: RGBA2.fromInts(255, 150, 40, 255),
+  m: RGBA2.fromInts(220, 90, 90, 255),
+  g: RGBA2.fromInts(170, 240, 95, 255),
+  s: RGBA2.fromInts(186, 196, 210, 255),
+  w: RGBA2.fromInts(150, 96, 52, 255),
+  y: RGBA2.fromInts(242, 210, 92, 255),
+  e: RGBA2.fromInts(236, 190, 150, 255),
+  f: RGBA2.fromInts(110, 200, 110, 255),
+  c: RGBA2.fromInts(132, 222, 230, 255),
+  o: RGBA2.fromInts(232, 230, 216, 255),
+  k: RGBA2.fromInts(64, 66, 82, 255)
+};
+
+// ../client/src/sprites/index.ts
+var REGISTRY = {
+  player: player2,
+  chaser,
+  shooter
+};
+function spriteFor(type) {
+  return REGISTRY[type];
+}
+var NPC_REGISTRY = {
+  vendor: merchant
+};
+function spriteForNpc(kind) {
+  return NPC_REGISTRY[kind];
+}
+
+// ../client/src/playfield.ts
+function blitSprite(buf, sprite, sx, sy, facing, sw, sh, hurt) {
+  const glyphs = sprite.rows(facing);
+  const keys = sprite.colorKeys(facing);
+  for (let ry = 0;ry < sprite.h; ry++) {
+    const py = sy + ry;
+    if (py < 0 || py >= sh)
+      continue;
+    const row = glyphs[ry];
+    const krow = keys[ry];
+    for (let rx = 0;rx < sprite.w; rx++) {
+      const ch = row[rx];
+      if (ch === " ")
+        continue;
+      const px = sx + rx;
+      if (px < 0 || px >= sw)
+        continue;
+      const fg = hurt ? COLORS.hurt : PALETTE[krow[rx]] ?? COLORS.hud;
+      buf.setCellWithAlphaBlending(px, py, ch, fg, COLORS.transparent);
+    }
+  }
+}
+function drawSprite(buf, e, cam, sw, sh) {
+  const sprite = spriteFor(e.type);
+  const sx = Math.round(e.x - Math.floor((sprite.w - BOX.w) / 2) - cam.x);
+  const sy = Math.round(e.y + BOX.h - sprite.h - cam.y);
+  blitSprite(buf, sprite, sx, sy, e.facing, sw, sh, e.hurtT > 0.3);
+}
+function drawNameplate(buf, e, cam, sw, sh) {
+  if (!e.name)
+    return;
+  const sprite = spriteFor(e.type);
+  const top = Math.round(e.y + BOX.h - sprite.h - cam.y);
+  const cx = e.x + BOX.w / 2 - cam.x;
+  const x = Math.round(cx - e.name.length / 2);
+  drawText(buf, x, top - 1, e.name, COLORS.dim, sw, sh);
+}
+function drawSpeechBubble(buf, e, cam, sw, sh) {
+  if (!e.bubble)
+    return;
+  const sprite = spriteFor(e.type);
+  const top = Math.round(e.y + BOX.h - sprite.h - cam.y);
+  const lines = layoutBubble(e.bubble);
+  const innerW = Math.max(...lines.map((l) => l.length));
+  const boxW = innerW + 2;
+  const boxH = lines.length + 2;
+  const cx = e.x + BOX.w / 2 - cam.x;
+  const tailY = top - 2;
+  const tailX = Math.round(cx);
+  const topY = tailY - boxH;
+  let left = Math.round(cx - boxW / 2);
+  left = Math.max(0, Math.min(left, sw - boxW));
+  for (let ry = 0;ry < boxH; ry++) {
+    const py = topY + ry;
+    if (py < 0 || py >= sh)
+      continue;
+    const lastRow = ry === boxH - 1;
+    for (let rx = 0;rx < boxW; rx++) {
+      const px = left + rx;
+      if (px < 0 || px >= sw)
+        continue;
+      const lastCol = rx === boxW - 1;
+      let ch = " ";
+      let fg = COLORS.bubbleFg;
+      if (ry === 0 || lastRow || rx === 0 || lastCol) {
+        fg = COLORS.bubbleBorder;
+        if (ry === 0)
+          ch = rx === 0 ? "\u256D" : lastCol ? "\u256E" : "\u2500";
+        else if (lastRow)
+          ch = rx === 0 ? "\u2570" : lastCol ? "\u256F" : "\u2500";
+        else
+          ch = "\u2502";
+      } else {
+        ch = lines[ry - 1]?.[rx - 1] ?? " ";
+      }
+      buf.setCell(px, py, ch, fg, COLORS.bubbleBg);
+    }
+  }
+  if (tailY >= 0 && tailY < sh && tailX >= 0 && tailX < sw)
+    buf.setCell(tailX, tailY, "\u25BC", COLORS.bubbleBorder, COLORS.bubbleBg);
+}
+function drawText(buf, x, y, text, fg, sw, sh) {
+  if (y < 0 || y >= sh)
+    return;
+  for (let i = 0;i < text.length; i++) {
+    const px = x + i;
+    if (px < 0 || px >= sw)
+      continue;
+    buf.setCellWithAlphaBlending(px, y, text[i], fg, COLORS.transparent);
+  }
+}
+function drawPlayfield(buf, game, cam) {
+  const { player: player3 } = game;
+  const zone2 = activeZone(game.world, player3.zoneId);
+  const sw = buf.width;
+  const sh = buf.height;
+  const p = player3.avatar;
+  const ww = zone2.terrain.w;
+  const wh = zone2.terrain.h;
+  const camX = Math.round(cam.x);
+  const camY = Math.round(cam.y);
+  buf.clear(COLORS.bg);
+  for (let sy = 0;sy < sh; sy++) {
+    const wy = sy + camY;
+    for (let sx = 0;sx < sw; sx++) {
+      const wx = sx + camX;
+      if (isSolid(zone2.terrain, wx, wy) && wx >= 0 && wx < ww && wy >= 0 && wy < wh)
+        buf.setCell(sx, sy, "\u2588", COLORS.terrainFg, COLORS.terrainBg);
+    }
+  }
+  const onPortal = zone2.portals.find((pr) => aabbOverlap(entityBox(p), pr));
+  for (const pr of zone2.portals) {
+    for (let yy = 0;yy < pr.h; yy++) {
+      for (let xx = 0;xx < pr.w; xx++) {
+        const px = pr.x + xx - camX;
+        const py = pr.y + yy - camY;
+        if (px >= 0 && px < sw && py >= 0 && py < sh)
+          buf.setCellWithAlphaBlending(px, py, "\u2592", COLORS.portal, COLORS.transparent);
+      }
+    }
+  }
+  if (onPortal) {
+    const dest = game.world.zones[onPortal.target]?.type ?? "zone";
+    const label = `\u21B5 e  enter the ${dest.charAt(0).toUpperCase()}${dest.slice(1)}`;
+    drawText(buf, Math.round(onPortal.x) - camX, Math.round(onPortal.y) - camY - 1, label, COLORS.portal, sw, sh);
+  }
+  const npcs = zone2.npcs ?? [];
+  const onNpc = npcs.find((n) => aabbOverlap(entityBox(p), n));
+  for (const n of npcs) {
+    const sprite = spriteForNpc(n.kind);
+    const sx = Math.round(n.x + Math.floor((n.w - sprite.w) / 2)) - camX;
+    const sy = Math.round(n.y + n.h - sprite.h) - camY;
+    blitSprite(buf, sprite, sx, sy, 1, sw, sh, false);
+    if (n === onNpc)
+      drawText(buf, sx, sy - 1, `\u21B5 e  talk to ${n.name}`, COLORS.vendor, sw, sh);
+  }
+  const others = game.others ?? [];
+  const sprites = [...zone2.monsters, ...others].sort((a, b) => a.y - b.y);
+  for (const e of sprites) {
+    drawSprite(buf, e, cam, sw, sh);
+    drawNameplate(buf, e, cam, sw, sh);
+  }
+  if (p.attackT > COMBAT.attackCooldown - 0.12) {
+    const hb = meleeHitbox(p);
+    for (let yy = 0;yy < hb.h; yy++) {
+      for (let xx = 0;xx < hb.w; xx++) {
+        const px = Math.round(hb.x + xx - cam.x);
+        const py = Math.round(hb.y + yy - cam.y);
+        if (px >= 0 && px < sw && py >= 0 && py < sh)
+          buf.setCellWithAlphaBlending(px, py, p.facing === 1 ? "/" : "\\", COLORS.melee, COLORS.transparent);
+      }
+    }
+  }
+  for (let slot = 1;; slot++) {
+    const skill = skillForSlot(player3.class ?? "warrior", slot);
+    if (!skill)
+      break;
+    const cd = player3.skillCooldowns?.[skill.id] ?? 0;
+    if (cd <= skill.cooldown - 0.15)
+      continue;
+    const hb = skillHitbox(p, skill);
+    for (let yy = 0;yy < hb.h; yy++) {
+      for (let xx = 0;xx < hb.w; xx++) {
+        const px = Math.round(hb.x + xx - cam.x);
+        const py = Math.round(hb.y + yy - cam.y);
+        if (px >= 0 && px < sw && py >= 0 && py < sh)
+          buf.setCellWithAlphaBlending(px, py, "\u2726", COLORS.melee, COLORS.transparent);
+      }
+    }
+  }
+  drawSprite(buf, p, cam, sw, sh);
+  for (const e of others)
+    drawSpeechBubble(buf, e, cam, sw, sh);
+  drawSpeechBubble(buf, p, cam, sw, sh);
+  for (const pr of zone2.projectiles) {
+    const px = Math.round(pr.x - cam.x);
+    const py = Math.round(pr.y - cam.y);
+    if (px < 0 || px >= sw || py < 0 || py >= sh)
+      continue;
+    const ch = pr.vx < 0 ? "\u25C4" : pr.vx > 0 ? "\u25BA" : "\u25CF";
+    buf.setCellWithAlphaBlending(px, py, ch, COLORS.projectile, COLORS.transparent);
+  }
+}
+
+class PlayfieldRenderable extends Renderable {
+  game = null;
+  camState = initCameraState();
+  constructor(ctx, options = {}) {
+    super(ctx, { width: "100%", height: "100%", live: true, ...options });
+  }
+  renderSelf(buffer) {
+    if (!this.game)
+      return;
+    const zone2 = activeZone(this.game.world, this.game.player.zoneId);
+    const a = this.game.player.avatar;
+    this.camState = stepCamera(this.camState, this.game.player.zoneId, a.x, a.y, {
+      sw: buffer.width,
+      sh: buffer.height,
+      ww: zone2.terrain.w,
+      wh: zone2.terrain.h
+    });
+    if (this.camState.cam)
+      drawPlayfield(buffer, this.game, this.camState.cam);
+  }
+}
+
+// ../client/src/shop.ts
+import {
+  BoxRenderable as BoxRenderable2,
+  TextRenderable as TextRenderable2
+} from "@opentui/core";
+var RARITY_PAD = 9;
+
+class Shop {
+  container;
+  gold;
+  list;
+  selected = 0;
+  constructor(ctx) {
+    this.container = new BoxRenderable2(ctx, {
+      position: "absolute",
+      top: 0,
+      left: 0,
+      right: 0,
+      bottom: 0,
+      justifyContent: "center",
+      alignItems: "center",
+      zIndex: 20,
+      visible: false
+    });
+    const panel = new BoxRenderable2(ctx, {
+      flexDirection: "column",
+      width: 46,
+      padding: 1,
+      border: true,
+      borderStyle: "single",
+      borderColor: COLORS.vendor,
+      title: " Merchant \u2014 sell loot ",
+      titleColor: COLORS.vendor,
+      backgroundColor: COLORS.hudBg
+    });
+    this.gold = new TextRenderable2(ctx, {
+      content: "",
+      fg: COLORS.vendor,
+      bg: COLORS.hudBg
+    });
+    this.list = new TextRenderable2(ctx, {
+      content: "",
+      fg: COLORS.hud,
+      bg: COLORS.hudBg
+    });
+    const footer = new TextRenderable2(ctx, {
+      content: "\u2191/\u2193 select   \u21B5 sell   e/esc close",
+      fg: COLORS.dim,
+      bg: COLORS.hudBg
+    });
+    panel.add(this.gold);
+    panel.add(this.list);
+    panel.add(footer);
+    this.container.add(panel);
+  }
+  attach(parent) {
+    parent.add(this.container);
+  }
+  get open() {
+    return this.container.visible;
+  }
+  show() {
+    this.selected = 0;
+    this.container.visible = true;
+  }
+  hide() {
+    this.container.visible = false;
+  }
+  move(delta, count) {
+    if (count <= 0) {
+      this.selected = 0;
+      return;
+    }
+    this.selected = Math.max(0, Math.min(count - 1, this.selected + delta));
+  }
+  update(player3) {
+    const inv = player3.inventory;
+    if (this.selected > inv.length - 1)
+      this.selected = Math.max(0, inv.length - 1);
+    this.gold.content = `Gold ${player3.progress.gold}`;
+    if (inv.length === 0) {
+      this.list.content = `
+(your bags are empty)
+`;
+      return;
+    }
+    const rows = inv.map((it, i) => {
+      const caret = i === this.selected ? "\u25B8" : " ";
+      const rarity = it.rarity.padEnd(RARITY_PAD);
+      return `${caret} ${rarity} ${it.base}  +${saleValue(it)}g`;
+    });
+    this.list.content = `
+${rows.join(`
+`)}
+`;
+  }
+}
+
+// ../client/src/index.ts
+var RENDER_FPS = Number(process.env.MMO_FPS) || 120;
+var PROD_SERVER = "wss://mmoserver-production-c9d8.up.railway.app";
+var OFFLINE = process.env.MMO_OFFLINE === "1" || process.env.MMO_OFFLINE === "true";
+var SERVER = process.env.MMO_SERVER || PROD_SERVER;
+var IDLE_INPUT = {
+  moveX: 0,
+  jump: false,
+  attack: false,
+  interact: false
+};
+var renderer = await createCliRenderer({
+  targetFps: RENDER_FPS,
+  exitOnCtrlC: true,
+  backgroundColor: "#10121a",
+  useKittyKeyboard: { events: true }
+});
+var input = new InputState;
+var playfield = new PlayfieldRenderable(renderer);
+renderer.root.add(playfield);
+var hud = new Hud(renderer);
+hud.attach(renderer.root);
+function quit(message) {
+  try {
+    renderer.destroy?.();
+  } catch {}
+  if (message)
+    console.error(message);
+  process.exit(message ? 1 : 0);
+}
+function fpsMeter() {
+  let fps = 0;
+  let acc = 0;
+  let frames = 0;
+  return (dt) => {
+    acc += dt;
+    frames++;
+    if (acc >= 500) {
+      fps = Math.round(frames * 1000 / acc);
+      acc = 0;
+      frames = 0;
+    }
+    return fps;
+  };
+}
+if (OFFLINE)
+  runOffline();
+else
+  runNetworked(SERVER);
+renderer.start();
+function runOffline() {
+  let game = createGame();
+  const shop = new Shop(renderer);
+  shop.attach(renderer.root);
+  function vendorUnder(g) {
+    const zone2 = activeZone(g.world, g.player.zoneId);
+    const box = entityBox(g.player.avatar);
+    return (zone2.npcs ?? []).find((n) => n.kind === "vendor" && aabbOverlap(box, n)) ?? null;
+  }
+  function sellSelected() {
+    const inv = game.player.inventory;
+    if (inv.length === 0)
+      return;
+    const item = inv[shop.selected];
+    const { progress, inventory } = sellItem(game.player.progress, inv, item.id);
+    const log = [
+      ...game.player.log.slice(-5),
+      `Sold ${item.rarity} ${item.base} (+${saleValue(item)}g).`
+    ];
+    game = { ...game, player: { ...game.player, progress, inventory, log } };
+    shop.move(0, inventory.length);
+  }
+  function handleShopKey(name) {
+    const count = game.player.inventory.length;
+    switch (name) {
+      case "up":
+        shop.move(-1, count);
+        break;
+      case "down":
+        shop.move(1, count);
+        break;
+      case "return":
+        sellSelected();
+        break;
+      case "e":
+      case "escape":
+        shop.hide();
+        break;
+    }
+    if (shop.open)
+      shop.update(game.player);
+  }
+  renderer.keyInput.on("keypress", (k) => {
+    if (k.name === "q")
+      quit();
+    if (shop.open) {
+      handleShopKey(k.name);
+      return;
+    }
+    if (k.name === "e" && vendorUnder(game)) {
+      shop.show();
+      shop.update(game.player);
+      return;
+    }
+    input.press(k.name, performance.now());
+  });
+  renderer.keyInput.on("keyrelease", (k) => input.release(k.name));
+  const meter = fpsMeter();
+  renderer.setFrameCallback(async (dt) => {
+    game = step(game, shop.open ? IDLE_INPUT : input.poll(performance.now()), dt);
+    const fps = meter(dt);
+    playfield.game = game;
+    hud.update(game, fps);
+    if (shop.open)
+      shop.update(game.player);
+  });
+}
+function localZone(id) {
+  return id === "town-01" ? makeTownZone(id) : makeFieldZone(id || "field-01");
+}
+function runNetworked(url) {
+  const handle = process.env.USER || "wanderer";
+  const net = new NetClient(url, handle, (reason) => {
+    quit(reason);
+  });
+  hud.showAlphaNotice();
+  let zoneId = "field-01";
+  let zone2 = localZone(zoneId);
+  let predicted = spawnAvatar(SPAWN.x, SPAWN.y);
+  const localCd = {};
+  const RECONCILE = 3;
+  const SEND_INTERVAL = 1000 / 30;
+  let sendAcc = 0;
+  const chat = new ChatInput;
+  renderer.keyInput.on("keypress", (k) => {
+    if (chat.open) {
+      const r = chat.key(k);
+      if (r.action === "send")
+        net.send({ t: "chat", text: r.text });
+      return;
+    }
+    if (k.name === "q")
+      quit();
+    if (k.name === "return") {
+      chat.start();
+      input.clear();
+      return;
+    }
+    input.press(k.name, performance.now());
+  });
+  renderer.keyInput.on("keyrelease", (k) => {
+    if (!chat.open)
+      input.release(k.name);
+  });
+  const meter = fpsMeter();
+  renderer.setFrameCallback(async (dt) => {
+    const inp = chat.open ? IDLE_INPUT : input.poll(performance.now());
+    if (net.zoneId && net.zoneId !== zoneId) {
+      zoneId = net.zoneId;
+      zone2 = localZone(zoneId);
+      const arrival = net.ownAvatar();
+      if (arrival)
+        predicted = {
+          ...predicted,
+          x: arrival.x,
+          y: arrival.y,
+          vx: 0,
+          vy: 0,
+          onGround: false
+        };
+    }
+    predicted = clientStepAvatar(zone2.terrain, predicted, { moveX: inp.moveX, jump: inp.jump }, dt);
+    if (inp.attack && predicted.attackT <= 0)
+      predicted.attackT = COMBAT.attackCooldown;
+    const dtSec = Math.min(dt / 1000, PHYS.maxDt);
+    for (const id in localCd)
+      localCd[id] = Math.max(0, localCd[id] - dtSec);
+    const level = net.latest?.progress.level ?? 1;
+    if (inp.skill) {
+      const skill = skillForSlot("warrior", inp.skill);
+      if (skill && skillUnlocked(skill, level) && (localCd[skill.id] ?? 0) <= 0)
+        localCd[skill.id] = skill.cooldown;
+    }
+    const own = net.ownAvatar();
+    if (own) {
+      predicted.hp = own.hp;
+      predicted.maxHp = own.maxHp;
+      predicted.hurtT = own.hurtT;
+      if (Math.abs(own.x - predicted.x) > RECONCILE || Math.abs(own.y - predicted.y) > RECONCILE) {
+        predicted.x = own.x;
+        predicted.y = own.y;
+        predicted.vx = 0;
+        predicted.vy = 0;
+      }
+    }
+    sendAcc += dt;
+    if (sendAcc >= SEND_INTERVAL) {
+      sendAcc = 0;
+      net.send({
+        t: "input",
+        x: predicted.x,
+        y: predicted.y,
+        vx: predicted.vx,
+        vy: predicted.vy,
+        facing: predicted.facing,
+        onGround: predicted.onGround,
+        attack: inp.attack,
+        interact: inp.interact ?? false,
+        skill: inp.skill
+      });
+    }
+    const fps = meter(dt);
+    const view = net.sample(performance.now());
+    net.decayBubbles(dt / 1000);
+    const game = snapshotToGame(zone2, predicted, net.sessionId, view, localCd, net.bubbles);
+    playfield.game = game;
+    hud.update(game, fps);
+    hud.updateChat(net.chatLog, chat.open, chat.text);
+  });
+}