@homie-rocks/studio 0.38.0 → 0.40.0

package/starters/gem-rush-3d/src/{main.ts → view.ts}

@@ -1,43 +1,4 @@
-/*
- * GEM RUSH 3D — Gem Rush (the netplay v1 reference game: the gem-rush starter and
- * @homie-rocks/studio/netplay/NETPLAY.md) drawn in three.js and dressed with free CC0 models.
- *
- * THE RULES ARE GEM RUSH'S, line for line: move, collect gems, score; 60 s rounds that cycle forever; the round
- * starts the moment the first browser arrives, with two bots, and every human who arrives takes a bot's body. One
- * browser hosts (pickups, scoring, bots, the clock) and broadcasts snapshots; everyone else moves their own animal
- * locally and draws the rest from interpolated snapshots; a promoted host continues the same round. A wave knocks
- * nearby bodies back (the host TAKES a client-owned body, drives the knockback, and GIVES it back); the hot zone
- * (keyed state) scores double; a watcher follows any player (`net.viewSeat`, `net.spotlight`); bots play at the
- * room's skill dial; the knock is tuned in the Game Lab (tunables.json, lab.json). Only the units changed: the
- * world is in metres, a 26 x 16 m clearing with a few bushes, rocks and a tree in it (solid: bodies go round them), x across and y deep (y is
- * three.js's z; the ground is y = 0 in three.js).
- *
- * THE LOOK comes from files beside game.json:
- *   style.json      the palette, fonts, light and camera (the art direction's tokens: `homie-studio style` writes it);
- *                   everything the code draws, and the repainted models, take their colours from it
- *   public/models/  the animals, the gem, trees, rocks, flowers and the fence: Kenney's CC0 packs from the Homie
- *                   starter library, phone-sized, fetched by `game new` (the repository keeps no model files).
- *                   assets/manifest.json names each library item and its SHA-256; assets/RIGHTS.md and credits.json
- *                   say what its licence allows.
- * Every model loads through @homie-rocks/studio/assets (createModels: each file is checked before three.js reads a
- * byte). A model that is refused or not there is drawn as a stand-in in the same colours (see "models" below): a
- * round never waits on, or breaks for, a model.
- *
- * HEADINGS, AND THERE ARE TWO: a body's `yaw` is `Math.atan2(dx, dy)` in the game's own x and y, so yaw 0 faces +y
- * (three.js's +z, the way the models are built) and it goes straight into `rotation.y`. That is also the yaw
- * `@homie-rocks/camera` means (0 faces +Z, positive turns toward +X, radians), so a follow or chase camera from that
- * package takes a body's `yaw` as it stands. The knock and aim angles (`ang`, `base`) are the OTHER kind,
- * `Math.atan2(dy, dx)`: 0 faces +x. Never hand one of those to a camera or to `rotation.y` without converting it:
- * `headingFrom({ zero: '+x', toward: '+z' })` from `@homie-rocks/camera/heading.js` is the adapter.
- *
- * PHONE BUDGETS: under 100 draw calls and 150k triangles a frame (the `drawCalls` and `triangles` probes read
- * renderer.info), the pixel ratio at most 1.5 on a phone and 2 on a computer, and no shadow map on a phone: a soft
- * disc under each body, gem, tree and rock (a computer draws the sun's real shadows). Repeated things (gems, trees, flowers, the fence, the discs) are one
- * InstancedMesh per model.
- *
- * The HUD (clock, scores, names, results, "Reconnecting…", the controls hint, the role badge) is a 2D canvas over
- * the world, in style.json's fonts and colours.
- */
+/** Gem Rush 3D: the room runs the rules; this view draws the meadow and its animals. */
 import {
   AmbientLight, AnimationClip, AnimationMixer, Box3, BoxGeometry, BufferAttribute, BufferGeometry, CanvasTexture, CircleGeometry, Color, ConeGeometry, CylinderGeometry,
   DodecahedronGeometry, IcosahedronGeometry, OctahedronGeometry,
@@ -49,17 +10,20 @@ import {
 import { mergeGeometries } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
 // The one model loader every studio game uses: checks each file, decodes meshopt and WebP, copies for placing.
 import { createModels, instancedCopies, placeCopy, repaint, stylize, type Copies } from '@homie-rocks/studio/assets';
-import { createNetplay, guardGestures, Roster, q, lerp, capMove, PALETTE, AI_MARK, type Peer, type RoleChange, type RoundInfo, type RoundResult, type Skill, type Slot, type Snapshot } from '@homie-rocks/studio/netplay';
+import { guardGestures, PALETTE, AI_MARK, type RoundInfo, type Slot } from '@homie-rocks/studio/netplay';
 // The port toolkit: its probe (what `homie-studio port check` and `perf` read, and sandbox + audio shims), and name
 // labels that never pile up (port/view.ts).
 import { createBubbles, createLabels, exposePort, paintBubbles, type BubbleIn, type BubbleOut, type LabelIn, type LabelOut } from '@homie-rocks/studio/port';
 // The Game Lab: tunables, phases, tracks and overlays (no-ops outside the lab).
 import { lab } from '@homie-rocks/studio/lab';
-import tuning from '../tunables.json';
+import { openRoom, type Entity } from '@homie-rocks/studio/rules/view';
+import type rules from './rules';
+const room = openRoom<typeof rules>();
+const net = room.net;
+guardGestures({ touch: 'canvas' });
 import styleFile from '../style.json';
 import gameFile from '../game.json';
 
-/* ------------------------------------------------------------------ rules */
 const W = 26;
 const H = 16;
 const R_AV = 0.44;
@@ -73,16 +37,6 @@ const OBSTACLES: readonly { x: number; y: number; r: number; kind: 'camp' | 'bus
   { x: 4.6, y: 3.8, r: 0.75, kind: 'bush' }, { x: 21.4, y: 4.6, r: 0.55, kind: 'rock' }, { x: 6.0, y: 12.6, r: 0.5, kind: 'rock' },
   { x: 20.2, y: 12.2, r: 0.75, kind: 'bush' }, { x: 9.6, y: 13.4, r: 0.45, kind: 'stone' }, { x: 23.6, y: 2.0, r: 0.5, kind: 'tree' },
 ];
-/** A position kept in the clearing and out of its features (pushed to their edge, so a body slides round them). */
-function bound(x: number, y: number): { x: number; y: number } {
-  x = Math.max(R_AV, Math.min(W - R_AV, x)); y = Math.max(R_AV, Math.min(H - R_AV, y));
-  for (const o of OBSTACLES) {
-    const dx = x - o.x; const dy = y - o.y; const d = Math.hypot(dx, dy); const min = o.r + R_AV;
-    if (d >= min) continue;
-    if (d > 1e-6) { x = o.x + (dx / d) * min; y = o.y + (dy / d) * min; } else x = o.x + min;
-  }
-  return { x, y };
-}
 const R_GEM = 0.26;
 const SPEED = 6.8;
 const BOT_SPEED = 5;
@@ -92,7 +46,7 @@ const GEM_COUNT = 14;
 const MIN_SLOTS = 3; // 1 human + 2 bots from the first frame
 const MAX_SLOTS = 8;
 /** The knock's numbers (tunables.json): the file's values, or the Game Lab's sliders while it plays a take. */
-const T = lab.tunables(tuning);
+const T = room.tune as Record<string, number>;
 const ZONE_MS = 12_000;
 /** The contract's 12 colours (PALETTE, NETPLAY.md section 3): a person wears their seat's, so the watch page's strip matches. */
 const colourOf = (slot: number, seat: number | null): string => PALETTE[(seat ?? slot) % PALETTE.length] as string;
@@ -101,282 +55,46 @@ const botName = (slot: number): string => BOT_NAMES[slot % BOT_NAMES.length] as
 /** An AI's name already ends in " · AI" (the relay sees to it); a plain bot says bot. */
 const label = (name: string, bot: boolean): string => (name.endsWith(AI_MARK) ? name : bot ? `${name} · bot` : name);
 
-/* ------------------------------------------------------------ wire shapes */
-/** Snapshot: compact arrays, quantized to the centimetre. (Reset epochs ride in the helper's `c` table.) */
-type P = [slot: number, seat: number, x: number, y: number, score: number, vx: number, vy: number];
-type G = [id: number, x: number, y: number];
-interface Snap { r: [n: number, phase: number, startedAt: number, endsAt: number]; p: P[]; g: G[] }
-/**
- * Replica input: the avatar (owner movement) AND the stick intent (host movement), so either mode reads the same
- * frame. The helper stamps the reset epoch the replica has adopted.
- */
-type Avatar = [x: number, y: number, vx: number, vy: number, mx: number, my: number];
-/** A body's bump, while it lasts: its direction (kvx, kvy), where its slide starts (kx, ky) and when (kat, after the hit-stop). */
-interface Knock { kvx: number; kvy: number; kx: number; ky: number; kat: number; knockUntil: number }
-interface Body extends Knock { slot: number; seat: number | null; name: string; bot: boolean; x: number; y: number; vx: number; vy: number; score: number; tx: number; ty: number }
-interface Gem { id: number; x: number; y: number }
-/** Slow state, on the keyed state channel (net.state('zone', ...)), not in the 20 Hz snapshot. */
-interface Zone { n: number; x: number; y: number; r: number; until: number }
-interface Ckpt { round: RoundInfo; bodies: Body[]; gems: Gem[]; roster: Slot[]; tick: number; gemSeq: number; occ?: [number, number][] }
-
-/* --------------------------------------------------------------- the net */
-/**
- * `?movement=host` plays host movement: the host moves every body from the seats' stick intents (its rules own
- * movement), and each replica PREDICTS its own body by replaying its unacknowledged intents on the host's position.
- * Default `owner`: each browser moves its own body and the host bounds it.
- */
-const MOVEMENT: 'owner' | 'host' = (() => { try { return new URLSearchParams(location.search).get('movement') === 'host' ? 'host' : 'owner'; } catch { return 'owner'; } })();
-// caps: its bots read the dial ('skill'), and its Roster takes an AI's slot for it ('agents': the join passes p.agent).
-const net = createNetplay<Snap, Avatar, Ckpt>({ game: 'gem-rush-3d', maxPlayers: MAX_SLOTS, movement: MOVEMENT, snapshotHz: 20, inputHz: 20, checkpointMs: 1000, caps: ['skill', 'agents'], checkpoint: () => checkpoint() });
-// A touch game guards its own page (NETPLAY.md section 24): a long press on the canvas never selects text or raises
-// the copy/paste callout on a phone, and a touch on it never pans or zooms the page.
-guardGestures({ touch: 'canvas' });
-/** The Roster keeps the server's AI seats (revision 6): the policy is read whenever it fills. */
-const policy = () => net.policy;
-
-/* ------------------------------------------------------------ host state */
-let roster = new Roster({ min: MIN_SLOTS, max: MAX_SLOTS, botName, policy });
-let bodies = new Map<number, Body>();
-let gems: Gem[] = [];
-let gemSeq = 0;
-let round: RoundInfo | null = null;
-let zone: Zone | null = null;
-let tick = 0;
-let hosting = false;
-let cheatResets = 0;
-let controlResets = 0;
-let predictionError = 0;
-/** Gems each slot picked up this round (a gem, whatever it scored): the dial's numbers (`pickups` probe). */
-let pickups = new Map<number, number>();
-
-/* ------------------------------------------------ this browser's avatar */
-const me = { x: W / 2, y: H / 2, vx: 0, vy: 0, kvx: 0, kvy: 0, kx: 0, ky: 0, kat: 0, knockUntil: 0, has: false };
-/** Offline (no shell) plays as a local seat 0, with keys or touch. */
-const mySeat = (): number | null => (net.offline ? 0 : net.seat);
-/** Whose view to draw: my own seat, or for a watcher the player it follows (null: the whole arena). */
-const viewSeat = (): number | null => (net.offline ? 0 : net.viewSeat);
-
-/* ------------------------------------------------------- replica view */
+const mySeat = (): number | null => room.seat;
+const viewSeat = (): number | null => net.viewSeat;
+const me = { x: 13, y: 8, has: false };
+const poses = new Map<number, Entity>();
 const drawn = new Map<number, { x: number; y: number; seat: number; score: number; slot: number }>();
 const waves: { x: number; y: number; at: number; colour: string; knock?: boolean }[] = [];
-let wavesSeen = 0;
-let knocksSeen = 0;
-let firstStateAt = 0;
-let firstSnapAt = 0;
-let frames = 0;
-
-const rnd = (a: number, b: number): number => a + Math.random() * (b - a);
-const spawnPoint = (i: number): { x: number; y: number } => {
-  const a = (i / MAX_SLOTS) * Math.PI * 2;
-  return { x: W / 2 + Math.cos(a) * 6.6, y: H / 2 + Math.sin(a) * 5 };
-};
-const newGem = (): Gem => {
-  let x = rnd(1.2, W - 1.2); let y = rnd(1.2, H - 1.2);
-  for (let i = 0; i < 12 && OBSTACLES.some((o) => Math.hypot(o.x - x, o.y - y) < o.r + 0.7); i += 1) { x = rnd(1.2, W - 1.2); y = rnd(1.2, H - 1.2); }
-  return { id: ++gemSeq, x, y };
-};
-
-function bodyFor(slot: Slot): Body {
-  const sp = spawnPoint(slot.slot);
-  return { slot: slot.slot, seat: slot.seat, name: slot.name, bot: slot.bot, x: sp.x, y: sp.y, vx: 0, vy: 0, score: 0, tx: sp.x, ty: sp.y, kvx: 0, kvy: 0, kx: sp.x, ky: sp.y, kat: 0, knockUntil: 0 };
-}
-
-function syncBodiesFromRoster(): void {
-  const seen = new Set<number>();
-  for (const s of roster.slots) {
-    seen.add(s.slot);
-    const b = bodies.get(s.slot);
-    if (!b) { bodies.set(s.slot, bodyFor(s)); continue; }
-    b.seat = s.seat; b.name = s.name; b.bot = s.bot;
-  }
-  for (const k of [...bodies.keys()]) if (!seen.has(k)) bodies.delete(k);
-}
-
-function publishRoster(): void { net.roster(roster.toJSON()); }
-
-/** The host moved body `b` itself: tell its owner (a replica adopts it; the host's own body is `me`). */
-function hostMoved(b: Body): void {
-  if (b.bot || b.seat === null) return;
-  if (b.seat === mySeat()) { me.x = b.x; me.y = b.y; me.vx = 0; me.vy = 0; me.has = true; return; }
-  net.reset(b.seat);
-}
-
-function newZone(n: number): Zone {
-  return { n, x: rnd(4.4, W - 4.4), y: rnd(4, H - 4), r: 3, until: net.now() + ZONE_MS };
-}
-function setZone(z: Zone): void { zone = z; net.state('zone', z); }
-
-function startRound(n: number, rollover = false): void {
-  const now = net.now();
-  roster.trim();
-  // The next round of a running room: the trim is what makes room (the seats a server no longer keeps for AI go
-  // here), so whoever was seated with no body is given one now, before the bodies are placed.
-  if (rollover && !net.offline) seatWaiting();
-  syncBodiesFromRoster();
-  let i = 0;
-  for (const b of [...bodies.values()].sort((a, c) => a.slot - c.slot)) {
-    const sp = spawnPoint(i++);
-    b.x = sp.x; b.y = sp.y; b.vx = 0; b.vy = 0; b.score = 0; b.tx = sp.x; b.ty = sp.y; b.kvx = 0; b.kvy = 0; b.knockUntil = 0;
-    hostMoved(b);
-  }
-  gems = Array.from({ length: GEM_COUNT }, newGem);
-  pickups = new Map();
-  sight.clear();
-  round = { n, phase: 'live', startedAt: now, endsAt: now + ROUND_MS };
-  if (lab.stage === 'dummy') stageDummy();
-  setZone(newZone((zone?.n ?? 0) + 1));
-  net.round(round);
-  publishRoster();
-  net.snapshot(buildSnap(), tick, true);
-}
-
-function endRound(): void {
-  if (!round) return;
-  const now = net.now();
-  const ranked = [...bodies.values()].sort((a, b) => b.score - a.score || Number(a.bot) - Number(b.bot) || a.slot - b.slot);
-  const agentSlot = (slot: number): boolean => Boolean(roster.slots.find((x) => x.slot === slot)?.agent);
-  const results: RoundResult[] = ranked.map((b, i) => ({ slot: b.slot, seat: b.seat, name: b.name, score: b.score, bot: b.bot, place: i + 1, ...(agentSlot(b.slot) ? { agent: true as const } : {}) }));
-  round = { n: round.n, phase: 'over', startedAt: now, endsAt: now + BREAK_MS, results };
-  net.round(round);
-}
-
-/* ---------------------------------------------------- becoming the host */
-function becomeHost(e: RoleChange<Snap, Ckpt>): void {
-  hosting = true;
-  if (e.promoted) restore(e);
-  else {
-    roster = new Roster({ min: MIN_SLOTS, max: MAX_SLOTS, botName, policy });
-    bodies = new Map();
-    const seat = mySeat();
-    if (seat !== null) roster.claim(seat, net.offline ? 'You' : net.name);
-    syncBodiesFromRoster();
-    startRound((e.round?.n ?? 0) + 1);
-  }
-  // Whoever is connected now is who plays: seats that left during the gap become bots.
-  const peers = net.offline ? [{ seat: 0, name: 'You' }] : [...net.peers.values()].filter((p) => p.seat !== null).map((p) => ({ seat: p.seat, name: p.name, agent: p.agent ?? null, occ: p.occ ?? null }));
-  // `occ` (NETPLAY.md section 25): which stay in its seat each peer's is, so a seat number that changed hands while
-  // nobody was hosting is claimed afresh instead of inheriting the last player's body in silence.
-  const { claimed } = roster.reconcile(peers);
-  syncBodiesFromRoster();
-  for (const s of claimed) { const b = bodies.get(s.slot); if (b && b.seat !== mySeat()) hostMoved(b); }
-  // My own body is wherever my local avatar is: it was client-owned a moment ago and still is.
-  const mine = mySeat() !== null ? [...bodies.values()].find((b) => b.seat === mySeat()) : undefined;
-  if (mine && me.has) { mine.x = me.x; mine.y = me.y; }
-  else if (mine) { me.x = mine.x; me.y = mine.y; me.has = true; }
-  // The hot zone is keyed state: the relay handed it over with the role.
-  zone = net.stateOf<Zone>('zone') ?? zone;
-  if (!zone && round) setZone(newZone(1));
-  publishRoster();
-}
-
-function restore(e: RoleChange<Snap, Ckpt>): void {
-  const ck = e.ckpt?.d ?? null;
-  if (ck) {
-    roster = Roster.from(ck.roster, { min: MIN_SLOTS, max: MAX_SLOTS, botName, policy }, ck.occ ?? null);
-    bodies = new Map(ck.bodies.map((b) => [b.slot, { ...b }]));
-    gems = ck.gems.map((g) => ({ ...g }));
-    gemSeq = ck.gemSeq;
-    round = ck.round;
-    tick = ck.tick;
-  } else {
-    roster = Roster.from(e.roster ?? [], { min: MIN_SLOTS, max: MAX_SLOTS, botName, policy });
-    bodies = new Map();
-    syncBodiesFromRoster();
-  }
-  // The snapshot is newer than the checkpoint (20 Hz vs 1 Hz): positions, scores and gems from it.
-  const s = e.snap;
-  if (s && (!e.ckpt || s.st >= e.ckpt.st)) {
-    for (const [slot, seat, x, y, score] of s.d.p) {
-      let b = bodies.get(slot);
-      if (!b) {
-        const rs0 = roster.slots.find((r) => r.slot === slot) ?? { slot, seat: seat >= 0 ? seat : null, name: seat >= 0 ? `Player ${seat + 1}` : botName(slot), bot: seat < 0 };
-        b = bodyFor(rs0);
-        bodies.set(slot, b);
-      }
-      b.x = x; b.y = y; b.score = score; b.tx = x; b.ty = y;
-    }
-    gems = s.d.g.map(([id, x, y]) => ({ id, x, y }));
-    gemSeq = Math.max(gemSeq, ...gems.map((g) => g.id));
-    const [n, ph, startedAt, endsAt] = s.d.r;
-    round = { n, phase: ph ? 'over' : 'live', startedAt, endsAt, ...(round?.n === n && round.results ? { results: round.results } : {}) };
-    tick = Math.max(tick, s.k);
+let wavesSeen = 0, knocksSeen = 0, frames = 0;
+let firstStateAt = 0, firstSnapAt = 0;
+let gems: { x: number; y: number; id: number }[] = [];
+let round: RoundInfo | null = null;
+let zone: { x: number; y: number; r: number } | null = null;
+const slotOf = (e: Entity): number => e.kind === 'runner' ? e.seat ?? 0 : 0;
+function updateView(): void {
+  const v = moveVector(); room.input({ ax: Math.round(v.x * 127), ay: Math.round(v.y * 127) });
+  const own = room.me; me.has = Boolean(own);
+  if (own) { me.x = own.pos.x; me.y = own.pos.y; }
+  drawn.clear(); poses.clear(); room.each('runner', e => poses.set(slotOf(e), e));
+  room.each('runner', e => drawn.set(slotOf(e), { slot: slotOf(e), seat: e.driver === 'bot' ? -1 : e.seat ?? -1, x: e.pos.x, y: e.pos.y, score: Number(e.score) }));
+  gems = []; room.each('gem', e => gems.push({ id: Number(e.serial), x: e.pos.x, y: e.pos.y }));
+  const z = room.shared.zone as { x: number; y: number } | undefined;
+  zone = z ? { x: z.x, y: z.y, r: 3 } : null;
+  if (own && !firstSnapAt) firstSnapAt = performance.now();
+  if (z && !firstStateAt) firstStateAt = performance.now();
+  const r = room.round;
+  round = r ? { ...r, startedAt: 0, endsAt: net.now() + r.secondsLeft * 1000 } : null;
+}
+function effect(name: 'wave' | 'knock', e: { id?: string; at?: { x: number; y: number } | null; dir?: { x: number; y: number }; by?: string }): void {
+  const body = e.id ? room.get(e.id) : null;
+  if (!body || body.kind !== 'runner' || !e.at) return;
+  const slot = slotOf(body), at = { x: body.pos.x, y: body.pos.y }, now = performance.now();
+  waves.push({ ...at, at: now, colour: name === 'knock' ? '#ffffff' : colourOf(slot, body.seat ?? null), knock: name === 'knock' });
+  if (name === 'wave') { net.spotlight(body.driver === 'person' ? body.seat ?? null : null); wavesSeen++; pushes.set(slot, now); }
+  else if (e.dir) {
+    const by = e.by ? room.get(e.by) : null;
+    knocksSeen++; bumped({ slot, dx: e.dir.x, dy: e.dir.y, by: by?.kind === 'runner' ? by.seat : undefined }, at);
+    if (lab.on) Object.assign(subject, { slot, at: net.now(), x0: at.x, y0: at.y, px: at.x, py: at.y, has: true });
   }
-  // A round message the relay kept is at least as authoritative as the checkpoint's copy.
-  if (e.round && (!round || e.round.n > round.n || (e.round.n === round.n && e.round.phase === 'over' && round.phase === 'live'))) round = e.round;
-  if (!round) { startRound(1); return; }
-  net.round(round);
-}
-
-function checkpoint(): Ckpt {
-  return {
-    round: round ?? { n: 0, phase: 'live', startedAt: 0, endsAt: 0 },
-    bodies: [...bodies.values()].map((b) => ({ ...b })),
-    gems: gems.map((g) => ({ ...g })),
-    roster: roster.toJSON(),
-    // Whose stay each body is, beside the roster: how the next host tells a player who came back from a new one.
-    occ: roster.occupants(),
-    tick,
-    gemSeq,
-  };
 }
-
-net.on('role', (e) => {
-  if (e.role === 'host') becomeHost(e);
-  else { hosting = false; }
-});
-/** Host: a body for somebody the relay seated. False when every body is somebody's (they wait: see seatWaiting). */
-function giveBody(p: Peer): boolean {
-  if (p.seat === null) return false;
-  // An AI takes a seat kept for AI, a person never does (revision 6: the Roster needs p.agent for that).
-  const c = roster.claim(p.seat, p.name, p.agent ? { role: p.agent.role, hands: p.agent.hands } : null, p.occ ?? null);
-  if (!c) return false;
-  syncBodiesFromRoster();
-  const b = bodies.get(c.slot.slot);
-  // The arriving human takes over the bot's body where it stands, score and all (reset = "adopt this position").
-  if (b) { b.vx = 0; b.vy = 0; b.kvx = 0; b.kvy = 0; b.knockUntil = 0; hostMoved(b); }
-  return true;
-}
-/**
- * SEAT WHOEVER IS WAITING (NETPLAY.md section 28). The relay seats a person; this host gives them a body. A claim that
- * found every body taken (a server's AI seats were still kept, say) used to be tried once: that player watched for the
- * rest of the visit, online, with nothing said. It is tried again whenever a body frees up and at every round start.
- */
-function seatWaiting(): boolean {
-  let any = false;
-  for (const p of net.peers.values()) if (p.seat !== null && !roster.bySeat(p.seat) && giveBody(p)) any = true;
-  return any;
-}
-net.on('join', (p) => {
-  if (!hosting || !giveBody(p)) return;
-  publishRoster();
-  net.snapshot(buildSnap(), tick, true);
-});
-net.on('leave', (p) => {
-  if (!hosting || p.seat === null) return;
-  roster.release(p.seat); // their body stays, driven by a bot
-  syncBodiesFromRoster();
-  // A body just went to a bot: somebody seated with none takes it now.
-  const seated = seatWaiting();
-  publishRoster();
-  if (seated) net.snapshot(buildSnap(), tick, true);
-});
-// The server's policy changed: its AI seats come (or go between rounds) at once.
-net.on('policy', () => { if (!hosting) return; roster.fill(); syncBodiesFromRoster(); publishRoster(); });
-net.on('event', (e) => {
-  if (e.k === 'wave') addWave(e.d as { slot: number });
-  if (e.k === 'knock') addWave(e.d as { slot: number }, true);
-});
-net.on('round', (r) => { round = hosting ? round : r; });
-net.on('state', (e) => { if (e.k === 'zone' && !hosting) zone = (e.d as Zone | null) ?? null; if (!firstStateAt) firstStateAt = performance.now(); });
-net.on('snapshot', () => { if (!firstSnapAt) firstSnapAt = performance.now(); });
-/** My body's control changed: on a reset, stand where the host put me (a new round, a takeover, a knockback's end). */
-net.on('control', (e) => {
-  if (!e.reset) return;
-  controlResets += 1;
-  const p = (e.snap as Snapshot<Snap>).d.p.find((x) => x[1] === net.seat);
-  if (p) { me.x = p[2]; me.y = p[3]; me.vx = 0; me.vy = 0; me.has = true; }
-});
-
+room.on('wave', e => effect('wave', e));
+room.on('knock', e => effect('knock', e));
 /* ----------------------------------------------------------------- input */
 // The camera looks across the meadow from its near edge, square to it: screen right is +x and screen down is +y, so
 // keys and the stick move a body exactly as in Gem Rush.
@@ -416,284 +134,14 @@ function moveVector(): { x: number; y: number } {
     if (len > 6) { const m = Math.min(1, len / 56); x += (dx / len) * m; y += (dy / len) * m; }
   }
   const len = Math.hypot(x, y);
-  return len > 1 ? { x: x / len, y: y / len } : { x, y };
+  if (len > 1) { x /= len; y /= len; }
+  const c = Math.cos(view3.yaw), s = Math.sin(view3.yaw);
+  return { x: x * c + y * s, y: -x * s + y * c };
 }
 
 function wave(): void {
-  const seat = mySeat();
-  if (seat === null) return;
-  if (hosting) {
-    const b = [...bodies.values()].find((x) => x.seat === seat);
-    if (b) hostWave(b);
-  } else net.press('wave');
+  const v = moveVector(); room.input({ ax: Math.round(v.x * 127), ay: Math.round(v.y * 127), wave: true });
 }
-/** Host: a wave rings out, and knocks back every body within reach (bots, the host itself, and replicas). */
-function hostWave(from: Body): void {
-  addWave({ slot: from.slot }); net.send('wave', { slot: from.slot });
-  for (const b of bodies.values()) {
-    if (b === from || Math.hypot(b.x - from.x, b.y - from.y) > T.knockRange) continue;
-    knock(b, from.x, from.y, from.slot);
-  }
-}
-/**
- * Host: knock a body back. The hit LANDS first: for T.hitStopMs the body holds where it was hit (it flashes, squashes
- * and shakes on every screen), then it SLIDES T.knockDistance along the hit, fast at first and easing into the stop
- * (T.knockEase), so it arrives at rest, the same distance at any frame rate, and its owner steers again with no pop.
- * A replica's body is TAKEN for the whole bump (its owner's avatar frames are ignored; the host drives it; the owner
- * draws its body from snapshots), then the helper GIVES it back with a reset, so the owner stands where it ended.
- */
-function knock(b: Body, fx: number, fy: number, by: number): void {
-  let dx = b.x - fx; let dy = b.y - fy;
-  const len = Math.hypot(dx, dy);
-  if (len < 0.02) { const a = Math.random() * Math.PI * 2; dx = Math.cos(a); dy = Math.sin(a); } else { dx /= len; dy /= len; }
-  const at = net.now() + T.hitStopMs;
-  const o: Knock & { x: number; y: number } = !b.bot && b.seat !== null && b.seat === mySeat() ? me : b;
-  o.kvx = dx; o.kvy = dy; o.kx = o.x; o.ky = o.y; o.kat = at; o.knockUntil = at + T.knockMs;
-  if (o === b && !b.bot && b.seat !== null) net.take(b.seat, T.hitStopMs + T.knockMs);
-  labKnock(b);
-  const d = { slot: b.slot, dx: q(dx, 2), dy: q(dy, 2), by };
-  addWave(d, true); net.send('knock', d);
-}
-
-/** Where a bumped body is now: held through the hit-stop, then eased out along the hit. Sets its velocity too. */
-function slide(o: Knock & { x: number; y: number; vx: number; vy: number }, now: number, dt: number): void {
-  const u = Number.isFinite(o.kat) ? Math.max(0, Math.min(1, (now - o.kat) / Math.max(1, T.knockMs))) : 1;
-  const e = 1 - (1 - u) ** Math.max(1, T.knockEase);
-  const { x, y } = bound(o.kx + o.kvx * T.knockDistance * e, o.ky + o.kvy * T.knockDistance * e);
-  if (u >= 1) { o.vx = 0; o.vy = 0; } else if (dt > 0) { o.vx = (x - o.x) / dt; o.vy = (y - o.y) / dt; }
-  o.x = x; o.y = y;
-}
-/** The frame a bump is over: the body lands exactly where its slide ends, at rest (at 12 fps the last step is long). */
-function landed(o: Knock & { x: number; y: number; vx: number; vy: number }): void {
-  if (!o.kat) return;
-  slide(o, o.kat + T.knockMs, 0);
-  o.kat = 0;
-}
-function addWave(d: { slot: number; dx?: number; dy?: number; by?: number }, isKnock = false): void {
-  const pos = hosting ? bodies.get(d.slot) : [...drawn.values()].find((x) => x.slot === d.slot);
-  // The action, for a watcher on Auto: whoever waved (a person, never a bot).
-  const waver = pos && 'bot' in pos ? (pos.bot ? null : pos.seat) : pos && pos.seat >= 0 ? pos.seat : null;
-  if (!isKnock) net.spotlight(waver);
-  const mineSlot = hosting ? [...bodies.values()].find((x) => x.seat !== null && x.seat === mySeat())?.slot : [...drawn.values()].find((x) => x.seat === net.seat)?.slot;
-  const at = mineSlot === d.slot && me.has ? me : pos;
-  if (!at) return;
-  waves.push({ x: at.x, y: at.y, at: performance.now(), colour: isKnock ? '#ffffff' : PALETTE[d.slot % PALETTE.length] as string, knock: isKnock });
-  if (isKnock) knocksSeen += 1; else wavesSeen += 1;
-  if (isKnock) bumped(d, at); else pushes.set(d.slot, performance.now());
-}
-
-/* ---------------------------------------------------------------- simulate */
-/** The one movement rule, shared by the owner, the host (host movement) and a replica's prediction. */
-function integrate(o: { x: number; y: number; vx: number; vy: number }, mx: number, my: number, dt: number): void {
-  mx = Number(mx) || 0; my = Number(my) || 0;
-  const len = Math.hypot(mx, my);
-  if (len > 1) { mx /= len; my /= len; } // an intent is at most full stick: no speed hack through intents
-  const k = Math.min(1, dt * 14);
-  o.vx += (mx * SPEED - o.vx) * k;
-  o.vy += (my * SPEED - o.vy) * k;
-  const p = bound(o.x + o.vx * dt, o.y + o.vy * dt);
-  o.x = p.x; o.y = p.y;
-}
-
-function stepMe(dt: number): void {
-  const seat = mySeat();
-  if (seat === null) { me.has = false; return; }
-  // Host-driven (host movement, or knocked back on a replica): stepReplica predicts me instead.
-  if (!net.owned) return;
-  if (me.knockUntil > net.now()) { slide(me, net.now(), dt); return; }
-  landed(me);
-  const v = moveVector();
-  integrate(me, v.x, v.y, dt);
-}
-
-/**
- * Replica, host-driven body. My stick moves me locally every frame (instant response), with the same rule the host
- * runs. When a new snapshot lands: start from where the host has me, replay every intent it had not acknowledged,
- * and pull toward that by 30% (or jump, if it is far). The host stays the truth; I never wait for it.
- */
-let predictedK = -1;
-function predictMe(dt: number): void {
-  const v = moveVector();
-  integrate(me, v.x, v.y, dt);
-  const snap = net.latest();
-  if (!snap || snap.k === predictedK) return;
-  predictedK = snap.k;
-  const p = snap.d.p.find((x) => x[1] === net.seat);
-  if (!p) return;
-  const pred = { x: p[2], y: p[3], vx: p[5] ?? 0, vy: p[6] ?? 0 };
-  for (const f of net.pending()) {
-    let left = Math.min(0.25, f.dt / 1000);
-    while (left > 0) { const h = Math.min(left, 1 / 60); integrate(pred, f.a[4], f.a[5], h); left -= h; }
-  }
-  const err = Math.hypot(pred.x - me.x, pred.y - me.y);
-  predictionError = err;
-  if (!me.has || err > 3) { me.x = pred.x; me.y = pred.y; me.vx = pred.vx; me.vy = pred.vy; }
-  else { me.x += (pred.x - me.x) * 0.3; me.y += (pred.y - me.y) * 0.3; }
-  me.has = true;
-}
-
-function stepKnocked(b: Body, dt: number): void { slide(b, net.now(), dt); }
-
-/**
- * THE BOTS, AT THE ROOM'S DIAL (NETPLAY.md section 17). A bot re-reads the world only every `reactionMs` (what it
- * last noticed is where it heads, and a miss costs it that long again), aims up to 4 m off at aimNoise 1, leaves
- * the hot zone to the people at positioning 0 and fights for it at 1, and waves at a rival in reach about
- * `aggression x 0.8` times a second. Rookie is beatable by anyone, Maxed by few.
- */
-const sight = new Map<number, { at: number; tx: number; ty: number; arrived?: boolean }>();
-
-function stepBots(dt: number): void {
-  const taken = new Set<number>();
-  const now = net.now();
-  for (const b of bodies.values()) {
-    if (!b.bot) continue;
-    if (b.knockUntil > now) { stepKnocked(b, dt); continue; }
-    landed(b);
-    if (lab.stage === 'dummy') { standStill(b, dt); continue; }
-    const s: Skill = net.skillOf(b.slot); // Fair when nobody set a dial
-    let eye = sight.get(b.slot);
-    if (!eye || now - eye.at >= s.reactionMs) { // REACTION TIME
-      const g = pickGem(b, taken, s); // POSITIONING
-      const miss = 4 * s.aimNoise; // AIM NOISE: up to 4 m off at 1
-      eye = { at: now, tx: g ? g.x + (Math.random() - 0.5) * miss : b.tx, ty: g ? g.y + (Math.random() - 0.5) * miss : b.ty };
-      sight.set(b.slot, eye);
-      if (g) taken.add(g.id);
-    }
-    b.tx = eye.tx; b.ty = eye.ty;
-    const rival = nearestBody(b, T.knockRange); // AGGRESSION: waves at a rival in reach
-    if (rival && round?.phase === 'live' && Math.random() < s.aggression * 0.8 * dt) hostWave(b);
-    const dx = b.tx - b.x; const dy = b.ty - b.y; const dist = Math.hypot(dx, dy);
-    const len = dist || 1;
-    // Arrived where it aimed: it stands there, and notices what it missed only a reaction later.
-    if (dist < 0.12 && !eye.arrived) { eye.arrived = true; eye.at = now; }
-    const speed = dist < 0.12 ? 0 : BOT_SPEED;
-    const k = Math.min(1, dt * 5);
-    b.vx += ((dx / len) * speed - b.vx) * k;
-    b.vy += ((dy / len) * speed - b.vy) * k;
-    const p = bound(b.x + b.vx * dt, b.y + b.vy * dt);
-    b.x = p.x; b.y = p.y;
-  }
-}
-
-/** Positioning: 0 leaves the hot zone to the people, 1 fights for it. */
-function pickGem(b: Body, taken: Set<number>, s: Skill): Gem | null {
-  let best: Gem | null = null; let bd = Infinity;
-  for (const g of gems) {
-    if (taken.has(g.id)) continue;
-    const hot = zone !== null && Math.hypot(g.x - zone.x, g.y - zone.y) < zone.r;
-    const d = Math.hypot(g.x - b.x, g.y - b.y) * (hot ? 1.5 - s.positioning : 1);
-    if (d < bd) { bd = d; best = g; }
-  }
-  return best;
-}
-
-/** The nearest other body within `range` (a bot's rival), or null. */
-function nearestBody(b: Body, range: number): Body | null {
-  let best: Body | null = null; let bd = range;
-  for (const o of bodies.values()) {
-    if (o === b) continue;
-    const d = Math.hypot(o.x - b.x, o.y - b.y);
-    if (d < bd) { bd = d; best = o; }
-  }
-  return best;
-}
-
-function stepHost(dt: number): void {
-  tick += 1;
-  const seat = mySeat();
-  const now0 = net.now();
-  for (const b of bodies.values()) {
-    if (b.bot) continue;
-    if (b.seat === seat) {
-      me.has = true;
-      b.x = me.x; b.y = me.y; b.vx = me.vx; b.vy = me.vy;
-      continue;
-    }
-    if (b.seat === null) continue;
-    const ctl = net.control(b.seat);
-    if (ctl.taken || b.knockUntil > now0) { stepKnocked(b, dt); if (net.takePresses(b.seat)['wave']) hostWave(b); continue; } // the host drives the knockback
-    if (MOVEMENT === 'host') {
-      // Host movement: the seat sends intents; the rules move the body.
-      const f = net.inputOf(b.seat);
-      integrate(b, f ? Number(f.a?.[4]) : 0, f ? Number(f.a?.[5]) : 0, dt);
-      if (net.takePresses(b.seat)['wave']) hostWave(b);
-      continue;
-    }
-    const a = net.avatar(b.seat); // null while taken, or until the owner has adopted the last reset
-    if (a && Array.isArray(a)) {
-      // Client-owned movement, bounded: to the arena, and to 1.3x top speed per frame. A legitimate avatar catches
-      // up within a frame; a teleport crawls, and a claim more than half a second of running away is reset.
-      const claim = bound(Number(a[0]) || 0, Number(a[1]) || 0);
-      const m = capMove(b, claim, SPEED * 1.3 * dt + 0.12);
-      if (m.over > SPEED * 0.5) { net.reset(b.seat); cheatResets += 1; }
-      else { b.x = m.x; b.y = m.y; b.vx = Number(a[2]) || 0; b.vy = Number(a[3]) || 0; }
-    }
-    if (net.takePresses(b.seat)['wave']) hostWave(b);
-  }
-  stepBots(dt);
-  const now = net.now();
-  if (round && round.phase === 'live') {
-    if (!zone || now >= zone.until) setZone(newZone((zone?.n ?? 0) + 1));
-    for (const b of bodies.values()) {
-      for (let i = 0; i < gems.length; i += 1) {
-        const g = gems[i] as Gem;
-        if (Math.hypot(g.x - b.x, g.y - b.y) < R_AV + R_GEM) {
-          b.score += zone && Math.hypot(g.x - zone.x, g.y - zone.y) < zone.r ? 2 : 1;
-          pickups.set(b.slot, (pickups.get(b.slot) ?? 0) + 1);
-          gems[i] = newGem();
-        }
-      }
-    }
-    if (now >= round.endsAt) endRound();
-  } else if (round && round.phase === 'over' && now >= round.endsAt) startRound(round.n + 1, true);
-  if (net.snapshotDue()) net.snapshot(buildSnap(), tick);
-}
-
-function buildSnap(): Snap {
-  const r = round ?? { n: 0, phase: 'live', startedAt: 0, endsAt: 0 };
-  return {
-    r: [r.n, r.phase === 'over' ? 1 : 0, r.startedAt, r.endsAt],
-    p: [...bodies.values()].map((b) => [b.slot, b.seat ?? -1, q(b.x, 2), q(b.y, 2), b.score, q(b.vx, 1), q(b.vy, 1)] as P),
-    g: gems.map((g) => [g.id, q(g.x, 2), q(g.y, 2)] as G),
-  };
-}
-
-function stepReplica(dt: number): void {
-  const seat = net.seat;
-  if (seat !== null) {
-    // Host-driven (host movement, or taken for a knockback): predict from the host's position and my intents.
-    if (!net.owned) predictMe(dt);
-    // Only once I have a body (the first control event adopts it): before that my position is nobody's.
-    if (me.has) {
-      const v = moveVector();
-      // Stick direction as held "buttons": a new direction is a press edge, so it is sent within 16 ms.
-      const held = [v.x > 0.2 ? 'R' : v.x < -0.2 ? 'L' : '', v.y > 0.2 ? 'D' : v.y < -0.2 ? 'U' : ''].filter(Boolean);
-      net.input([q(me.x, 2), q(me.y, 2), q(me.vx, 1), q(me.vy, 1), q(v.x, 2), q(v.y, 2)], held);
-    }
-  }
-  const smp = net.sample();
-  drawn.clear();
-  if (!smp) return;
-  const bySlot = new Map<number, P>(smp.a.d.p.map((p) => [p[0], p]));
-  for (const pb of smp.b.d.p) {
-    const pa = bySlot.get(pb[0]) ?? pb;
-    drawn.set(pb[0], { slot: pb[0], seat: pb[1], x: lerp(pa[2], pb[2], smp.alpha), y: lerp(pa[3], pb[3], smp.alpha), score: pb[4] });
-  }
-  const [n, ph, startedAt, endsAt] = smp.b.d.r;
-  if (!round || round.n !== n || (round.phase === 'over') !== (ph === 1)) {
-    const kept = net.roundInfo && net.roundInfo.n === n ? net.roundInfo : null;
-    round = kept ?? { n, phase: ph ? 'over' : 'live', startedAt, endsAt };
-  }
-}
-
-/* -------------------------------------------------------------- how a bump looks */
-/*
- * Every screen draws a bump from the knock event (the host's own, or the one it sends): the hit lands (the animal
- * flashes white and holds, squashed against the hit, shaking), flies (stretched along the hit, less as it slows),
- * stops (squashed, then a wobble that dies away: overlap), throws sparks, and kicks the camera of whoever was in it.
- * The waver's own body puffs up a little when it waves. Sparks and the camera's kick roll lab.random(): their own
- * dice, so the world's (Math.random) stay the same as a build without them, which the Game Lab needs to compare two.
- */
 const bumps = new Map<number, { at: number; dx: number; dy: number }>();
 const pushes = new Map<number, number>();
 const sparks: { x: number; y: number; h: number; vx: number; vy: number; vh: number; at: number; life: number; gold?: boolean }[] = [];
@@ -710,7 +158,7 @@ function bumped(d: { slot: number; dx?: number; dy?: number; by?: number }, at:
   }
   if (sparks.length > 160) sparks.splice(0, sparks.length - 160);
   // The camera kicks for whoever was in it: the body bumped, or the one who waved.
-  const mine = hosting ? [...bodies.values()].find((x) => x.seat !== null && x.seat === mySeat())?.slot : [...drawn.values()].find((x) => x.seat === net.seat)?.slot;
+  const mine = [...drawn.values()].find((x) => x.seat === net.seat)?.slot;
   if (mine !== undefined && (d.slot === mine || d.by === mine)) kickAt = now;
 }
 /** A gem taken: a little gold burst where it was (drawn on every screen from the gem list; the rules never see it). */
@@ -753,36 +201,8 @@ function bodyFx(slot: number, t: number): { ox: number; oy: number; sx: number;
  * labKnock and labReport never run.
  */
 type Pose = { x: number; y: number; sx?: number; sy?: number; a?: number };
-/**
- * The take's stage "dummy" (lab.stage, only ever set by the lab): you stand left of the middle with a bot a short step
- * to your right, and every bot stands still unless it is bumped, like a training dummy. The knock alone, every time.
- */
-function stageDummy(): void {
-  const seat = mySeat();
-  const list = [...bodies.values()].sort((a, c) => a.slot - c.slot);
-  const mine = list.find((b) => !b.bot && b.seat === seat);
-  const bots = list.filter((b) => b.bot);
-  if (mine) { mine.x = W / 2 - 3.2; mine.y = H / 2; hostMoved(mine); }
-  bots.forEach((b, i) => { b.x = i === 0 ? W / 2 - 3.2 + 1.84 : W - 3.6; b.y = i === 0 ? H / 2 : 3 + (i - 1) * 14; b.tx = b.x; b.ty = b.y; });
-}
-/** A dummy at rest: it eases to a stop wherever the last bump left it. */
-function standStill(b: Body, dt: number): void {
-  const k = Math.min(1, dt * 5);
-  b.vx -= b.vx * k; b.vy -= b.vy * k;
-  const p = bound(b.x + b.vx * dt, b.y + b.vy * dt); b.x = p.x; b.y = p.y;
-}
 const subject = { slot: -1, at: 0, x0: 0, y0: 0, px: 0, py: 0, has: false };
-function labKnock(b: Body): void {
-  if (!lab.on) return;
-  subject.slot = b.slot; subject.at = net.now(); subject.x0 = b.x; subject.y0 = b.y; subject.px = b.x; subject.py = b.y; subject.has = true;
-}
-/** Where the subject is now (the host's own body is `me`), or null. */
-function subjectAt(): Pose | null {
-  if (!subject.has) return null;
-  const b = bodies.get(subject.slot);
-  if (!b) return null;
-  return !b.bot && b.seat !== null && b.seat === mySeat() ? me : b;
-}
+function subjectAt(): Pose | null { return subject.has ? drawn.get(subject.slot) ?? null : null; }
 function labReport(dt: number): void {
   const at = subjectAt();
   if (!at || dt <= 0) { lab.phase(null); return; }
@@ -801,7 +221,6 @@ function labReport(dt: number): void {
 }
 /** The lab's views: the game's own camera, close on the knock, the whole arena. */
 const labView = lab.camera<{ zoom?: number; whole?: boolean } | null>({ game: null, close: { zoom: 2.4 }, arena: { whole: true } });
-
 /* ================================================================== THE LOOK */
 
 /* ------------------------------------------------------------------ style.json */
@@ -1509,8 +928,9 @@ function poseAnimal(a: Animal, at: { x: number; y: number }, t: number, dt: numb
   a.speed += (Math.min(sp, 12) - a.speed) * Math.min(1, dt * 10);
   a.px = at.x; a.py = at.y;
   // It faces where it goes, but not while flying from a bump (it is knocked backwards, not turned round).
-  if (sp > 0.6 && !bumps.has(a.slot) && Number.isFinite(step)) {
-    const want = Math.atan2(dx, dy);
+  const pose = poses.get(a.slot);
+  if (pose) {
+    const want = Math.atan2(pose.heading.x, pose.heading.y);
     let d = want - a.yaw; d = Math.atan2(Math.sin(d), Math.cos(d));
     a.yaw += d * Math.min(1, dt * 14);
   }
@@ -1705,7 +1125,6 @@ let lastDraw = 0;
 /** Where a seat's body is drawn now (host: the real body; replica: interpolated), or null. */
 function seatPos(seat: number): { x: number; y: number } | null {
   if (seat === mySeat() && me.has && !net.watching) return me;
-  if (hosting) { const b = [...bodies.values()].find((x) => !x.bot && x.seat === seat); return b ? { x: b.x, y: b.y } : null; }
   const d = [...drawn.values()].find((x) => x.seat === seat);
   return d ? { x: d.x, y: d.y } : null;
 }
@@ -1752,7 +1171,7 @@ function draw(t: number, dt: number): void {
   }
 
   // gems: spinning, bobbing, glowing; a taken one bursts into gold where it was
-  const gemList: { x: number; y: number; id: number }[] = hosting ? gems : (net.latest()?.d.g ?? []).map(([id, x, y]) => ({ id, x, y }));
+  const gemList: { x: number; y: number; id: number }[] = gems;
   const rn = round?.n ?? -1;
   const seenNow = new Set<number>();
   let nb = 0;
@@ -1789,13 +1208,11 @@ function draw(t: number, dt: number): void {
   for (let i = nw; i < wavePool.length; i += 1) (wavePool[i] as Mesh).visible = false;
 
   // the animals
-  const names = new Map<number, Slot>((net.slots ?? roster.slots).map((s) => [s.slot, s]));
+  const names = new Map<number, Slot>((net.slots ?? []).map((s) => [s.slot, s]));
   // `mine`: the body whose view this is: my own, or the player a watcher follows (named, never "You").
   const list: { slot: number; seat: number | null; x: number; y: number; bot: boolean; name: string; mine: boolean }[] = [];
   const isView = (seat: number | null, bot: boolean): boolean => !bot && seat !== null && seat === view;
-  if (hosting) {
-    for (const b of bodies.values()) list.push({ slot: b.slot, seat: b.seat, x: b.x, y: b.y, bot: b.bot, name: b.name, mine: isView(b.seat, b.bot) });
-  } else {
+  {
     for (const d of drawn.values()) {
       const own = !net.watching && d.seat >= 0 && d.seat === net.seat;
       const s = names.get(d.slot);
@@ -1984,8 +1401,7 @@ function hud(cw: number, ch: number, phone: boolean, list: { slot: number; seat:
   // scores: the play page's room button (and a server's pill beside it) sit at the top right (game.json screen.share's
   // default): the scores start under that band, so the buttons never cover a score.
   const scores = new Map<number, number>();
-  if (hosting) for (const b of bodies.values()) scores.set(b.slot, b.score);
-  else for (const d of drawn.values()) scores.set(d.slot, d.score);
+  for (const d of drawn.values()) scores.set(d.slot, d.score);
   // A phone's board is compact (the top three, names without " · bot": a bot's dot is hollow), so a game's own HUD at
   // the top left (a basket, a timer) has room beside it.
   const rows = [...list].sort((a, b) => (scores.get(b.slot) ?? 0) - (scores.get(a.slot) ?? 0)).slice(0, phone ? 3 : 6);
@@ -2073,9 +1489,7 @@ function frame(t: number): void {
   const dt = lab.time.dt(t, 0.05);
   // The look's own clock (the animals' clips): real seconds, at most a tenth, whatever the rules' step.
   const ddt = lastT < 0 ? 0 : Math.min(0.1, Math.max(0, (t - lastT) / 1000)); lastT = t;
-  stepMe(dt);
-  if (hosting) stepHost(dt);
-  else stepReplica(dt);
+  updateView();
   if (lab.on) labReport(dt);
   draw(t, lab.on ? dt : ddt);
   frames += 1;
@@ -2087,24 +1501,16 @@ net.expose({
   bubbles: () => shownBubbles.map((b) => ({ seat: b.key, text: b.lines.join(' '), alpha: b.alpha, left: Math.round(b.left), top: Math.round(b.top), right: Math.round(b.right), bottom: Math.round(b.bottom) })),
   self: () => (me.has ? { x: me.x, y: me.y } : null),
   peer: (seat: number) => {
-    if (hosting) { const b = [...bodies.values()].find((x) => x.seat === seat); return b ? { x: b.x, y: b.y } : null; }
     const d = [...drawn.values()].find((x) => x.seat === seat);
     return d ? { x: d.x, y: d.y } : null;
   },
   frames: () => frames,
-  scores: () => (hosting ? [...bodies.values()].map((b) => ({ slot: b.slot, seat: b.seat, bot: b.bot, score: b.score })) : [...drawn.values()].map((d) => ({ slot: d.slot, seat: d.seat >= 0 ? d.seat : null, bot: d.seat < 0, score: d.score }))),
-  /** Host: gems each slot picked up this round, the round's age, and the dial each bot plays at (the dial's numbers). */
-  pickups: () => (hosting ? { round: round ? { n: round.n, phase: round.phase, ageMs: net.now() - round.startedAt } : null, slots: [...bodies.values()].map((b) => ({ slot: b.slot, bot: b.bot, gems: pickups.get(b.slot) ?? 0, level: b.bot ? net.skillOf(b.slot).level : null })) } : null),
-  /** Host: when each bot last looked (its reaction clock). */
-  sight: () => (hosting ? [...sight.entries()].map(([slot, e]) => ({ slot, at: e.at })) : null),
+  scores: () => [...drawn.values()].map(d => ({ slot: d.slot, seat: d.seat >= 0 ? d.seat : null, bot: d.seat < 0, score: d.score })),
+  pickups: () => { const slots: unknown[] = []; room.each('runner', e => slots.push({ slot: e.seat, bot: e.driver === 'bot', gems: e.pickups })); return { round, slots }; },
   waves: () => wavesSeen,
   knocks: () => knocksSeen,
   zone: () => zone,
-  owned: () => net.owned,
-  cheatResets: () => cheatResets,
-  movement: () => MOVEMENT,
-  controlResets: () => controlResets,
-  predictionError: () => predictionError,
+  movement: () => 'server',
   /** Where the camera looks (rules metres), how far away it is, its turn, and whose view it is. */
   camera: () => ({ x: view3.x, y: view3.y, dist: view3.dist, yaw: view3.yaw, view: viewSeat() }),
   /** The names as drawn (boxes, never the text): the e2e probe counts overlaps and checks your own. */
@@ -2116,31 +1522,17 @@ net.expose({
   triangles: () => renderer.info.render.triangles,
   /** The models: how many loaded, their triangles, texture memory and bytes, and any refused (with why). */
   models: () => ({ ...models.stats(), standIns: [...standIns], animals: [...animals.values()].map((a) => ({ slot: a.slot, animal: ANIMALS[a.kind], standIn: a.model?.name === 'stand-in' })) }),
-  /** Harness hook (host only): knock the body of `seat` back, toward the middle of the arena. */
-  debugKnock: (seat: number) => {
-    if (!hosting) return false;
-    const b = [...bodies.values()].find((x) => x.seat === seat);
-    if (!b) return false;
-    knock(b, b.x < W / 2 ? b.x - 0.05 : b.x + 0.05, b.y, -1); // push toward the middle, away from the nearer wall (bumped by nobody)
-    return true;
-  },
+
 });
 
 exposePort(net, {
   view: 'top',
   self: () => (me.has && mySeat() !== null ? { x: me.x, y: me.y } : null),
   size: R_AV,
-  score: () => { const seat = mySeat(); const b = hosting ? [...bodies.values()].find((x) => x.seat === seat) : [...drawn.values()].find((x) => x.seat === seat); return b ? b.score : null; },
+  score: () => { const seat = mySeat(); const b = [...drawn.values()].find((x) => x.seat === seat); return b ? b.score : null; },
   // The renderer's own counters, by the names `homie-studio perf` and the playtest read on the port probe (measured
   // scene cost while playing; port/probe.ts PortExtra). Nobody dies in this game, so there is no `alive` to say.
   extra: { drawCalls: () => renderer.info.render.calls, triangles: () => renderer.info.render.triangles },
 });
 
-void net.ready.then(() => {
-  const seat = mySeat();
-  if (seat !== null && hosting) {
-    const b = [...bodies.values()].find((x) => x.seat === seat);
-    if (b) { me.x = b.x; me.y = b.y; me.has = true; }
-  }
-});
 requestAnimationFrame(frame);