wren/val Public Public: anyone can read this; nobody can change it.

/**

 * val, in a browser. It draws what the server sends and sends what the

 * person does — nothing else. There is no position here the server did not

 * hand over, and no enemy in a snapshot the server decided you cannot see,

 * so a patched client learns nothing a plain one does not.

 *

 * This file is the wiring: the socket, the keys and the pointer, the HUD.

 * The drawing lives beside it — `scene.js` for the first-person view,

 * `topdown.js` for the map, `prompt.js` for the line of advice — and the

 * machinery under `engine/`: the renderer, the feel stack, the gun.

 */

"use strict";

import { banner, drawBanner } from "./banner.js";

import { makeBeeper } from "./beep.js";

import { makeBudget, measure } from "./engine/budget.js";

import { arrive, bodyAt, delay, feed, makeTimeline, renderTime } from "./engine/interp.js";

import { BODY_R, moveSpeed } from "../src/engine/glide.ts";

import { drawGun, gunFire, gunSnapshot, gunTick, makeGun } from "./engine/gun.js";

import { makeLocal, stepLocal } from "./engine/predict.js";

import { forget, ghosts, makePresence, shown, sighted, slide } from "./engine/presence.js";

import { choosePrompt, REACH } from "./prompt.js";

import { renderSize, WIDTHS } from "./engine/resolution.js";

import { roster, rosterKey } from "./roster.js";

import { AGENT_COLOUR, drawScene, makeScene } from "./scene.js";

import { moveVector } from "./engine/steer.js";

import { drawTopdown } from "./topdown.js";

import { drawWatching, watching, watchLines } from "./watch.js";

import { aim as aimAt, makeYaw, settle, told, turn } from "./engine/yaw.js";

const $ = (id) => document.getElementById(id);

const view = $("view");

const ctx = view.getContext("2d");

// The world is drawn here, at a few hundred columns, and blitted onto the

// visible canvas scaled. The HUD, the crosshair and the minimap are drawn on

// `view` itself, at whatever the device pixel ratio really is.

const sceneCanvas = document.createElement("canvas");

const sceneCtx = sceneCanvas.getContext("2d");

const KEY_SLOT = { KeyC: "c", KeyQ: "q", KeyE: "e", KeyX: "x" };

const COARSE = matchMedia("(pointer: coarse)").matches;

const LOOK = 0.0022; // radians per pixel of mouse travel

const HELP_SEEN = "val.help.seen";

let map = null;

let solid = () => true;

let world = null; // what predict.js slides against: the grid, from map.json

let pens = null; // the spawn tiles each side is penned to during the buy phase

let snap = null;

let socket = null;

let agents = null;

// Everybody else, kept as the last few things the server said about them and

// drawn between those — see interp.js. `drawAt` is the moment this frame is

// drawing, a snapshot interval behind the present.

const timeline = makeTimeline();

let drawAt = 0;

// Who is in sight and who just left it — see presence.js. A body the server

// has only now started sending has no history at all, and drawing it solid

// at its exact position is what makes enemies appear to teleport into a room.

const presence = makePresence();

const slid = { x: 0, y: 0, angle: 0 };

let marks = [];

let nowSec = performance.now() / 1000;

const keys = new Set();

// Where this person is looking: the browser's between snapshots, and the

// server's word taken only when it is saying something we did not. See

// yaw.js — a snapshot that stomps this is what made looking around choppy.

const head = makeYaw();

let locked = false;

let firing = false;

let mode = COARSE ? "top" : "fp"; // a raycaster with touch look is miserable

let mapOpen = false;

let pointer = null; // aim target in canvas pixels, top-down only

let stick = null; // { id, ox, oy, mx, my }

let aimTouch = null;

let helpShown = false;

let last = performance.now();

let snapAt = last; // when the last snapshot landed: how stale the answer is

// How many columns the world is drawn at, and what the frame is costing.

// See resolution.js for the ladder and budget.js for the rung it settles on:

// the visible canvas is device pixels, this is not.

const budget = makeBudget(0, WIDTHS.length - 1);

let render = { width: 960, height: 600 };

let perfOn = false;

let perfAt = 0;

const walk = { x: 0, y: 0 };

// What this person is doing right now, read once a frame for the drawing and

// once every 50ms for the server. The same object either way: no allocation

// in a loop that runs sixty times a second.

const intent = { mx: 0, my: 0, angle: 0, fire: false, use: false, reload: false };

// Your own body, run forward from your own keys between snapshots, and the

// object the drawing is handed for it.

const local = makeLocal();

const drawnMe = { id: "", x: 0, y: 0, angle: 0 };

const scene = makeScene();

const gun = makeGun();

const beeper = makeBeeper();

// ------------------------------------------------------------------ socket

function connect() {

  const url = (location.protocol === "https:" ? "wss://" : "ws://") + location.host + "/ws";

  socket = new WebSocket(url);

  socket.onopen = () => ($("conn").textContent = "live");

  socket.onclose = () => {

    $("conn").textContent = "reconnecting…";

    setTimeout(connect, 1500);

  };

  socket.onmessage = (event) => {

    const data = JSON.parse(event.data);

    if (data.t !== "s") return;

    // The scoreboard is sent only when it changes; between changes this is

    // the one we have, and it is still the server's word, not a guess.

    if (data.board === undefined && snap && snap.board) data.board = snap.board;

    snap = data;

    const landed = performance.now();

    // No seat, no `me`, no players. Everything below reads a body out of the

    // snapshot, so a watching connection takes the other path entirely.

    if (watching(data)) return void paintWatch(data);

    // Timed samples for every body in it, ours included: the drawing walks

    // between them rather than chasing the newest one. The time a sample is

    // filed under is the wire's even beat, not the moment this one happened

    // to land — see interp.js. Your own snapshot's age is read off the same

    // beat, so the lead your keys are carried by does not wobble with it.

    snapAt = arrive(timeline, landed / 1000) * 1000;

    // Between rounds everybody is teleported to a spawn, so no sighting

    // before that says anything about where anybody is now.

    if (data.phase !== "live") forget(presence);

    else sighted(presence, data.players, landed / 1000);

    feed(timeline, data.me.id, data.me, snapAt / 1000);

    for (const player of data.players) feed(timeline, player.id, player, snapAt / 1000);

    // The server's angle is taken only when it is a correction, never as the

    // routine echo of the angle we sent it a moment ago.

    settle(head, data.me, landed / 1000);

    gunSnapshot(gun, data);

    paintHud(data);

    maybeHelp(data);

  };

}

const send = (message) => {

  if (socket && socket.readyState === 1) socket.send(JSON.stringify(message));

};

// ------------------------------------------------------------------- input

/**

 * Swap the view. The two share one facing — whichever you leave, you keep

 * looking the way you were looking — so nothing here touches the angle.

 */

function setMode(next) {

  mode = next;

  $("stage").dataset.mode = next;

  if (next !== "fp" && document.pointerLockElement === view) document.exitPointerLock();

}

addEventListener("keydown", (event) => {

  if (event.target instanceof HTMLInputElement) return;

  if (event.code === "Tab") {

    mapOpen = true;

    event.preventDefault();

    return;

  }

  if (event.code === "KeyH" || event.key === "?") {

    toggleHelp();

    event.preventDefault();

    return;

  }

  if (event.code === "KeyV") {

    setMode(mode === "fp" ? "top" : "fp");

    event.preventDefault();

    return;

  }

  if (event.code === "KeyB") {

    toggleBuy();

    event.preventDefault();

    return;

  }

  if (event.code === "F3" || event.code === "Backquote") {

    togglePerf();

    event.preventDefault();

    return;

  }

  if (KEY_SLOT[event.code]) {

    send({ t: "i", c: KEY_SLOT[event.code] });

    event.preventDefault();

    return;

  }

  keys.add(event.code);

  if (["KeyW", "KeyA", "KeyS", "KeyD", "Space", "KeyF", "KeyR", "ArrowLeft", "ArrowRight"].includes(event.code))

    event.preventDefault();

});

addEventListener("keyup", (event) => {

  if (event.code === "Tab") mapOpen = false;

  keys.delete(event.code);

});

addEventListener("blur", () => {

  keys.clear();

  mapOpen = false;

  firing = false;

});

// Aiming is pointer lock: click the canvas to capture the mouse, move to

// look, Escape gives it back. The angle sent is the same angle as ever.

view.addEventListener("click", () => {

  beeper.wake();

  if (watching(snap)) return; // nothing to aim: capturing the mouse would be a lie

  if (mode !== "fp" || locked) return;

  if (!view.requestPointerLock) return setMode("top"); // no lock, no first person

  // Asked for too soon after the last release, a browser rejects this; that

  // is a shrug, not an error, and the hint stays up until it takes.

  const asked = view.requestPointerLock();

  if (asked && asked.catch) asked.catch(() => {});

});

document.addEventListener("pointerlockchange", () => {

  locked = document.pointerLockElement === view;

  if (!locked) firing = false;

  $("stage").dataset.locked = locked ? "1" : "";

});

addEventListener("mousemove", (event) => {

  if (locked) turn(head, event.movementX * LOOK);

});

addEventListener("mousedown", (event) => {

  if (locked && event.button === 0) {

    firing = true;

    // The gun kicks now, not when the server's word comes back: the shot is

    // still the server's to fire and to land, this is the hand moving.

    if (snap && !watching(snap)) gunFire(gun, snap);

  }

});

addEventListener("mouseup", (event) => {

  if (locked && event.button === 0) firing = false;

});

// The top-down view keeps the pointer aim it always had: it is the phone

// control scheme, and the fallback when the first-person view is not wanted.

const canvasPoint = (event) => {

  const box = view.getBoundingClientRect();

  return {

    x: ((event.clientX - box.left) / box.width) * view.width,

    y: ((event.clientY - box.top) / box.height) * view.height,

  };

};

view.addEventListener("pointermove", (event) => {

  if (mode !== "top" || event.pointerType === "touch") return;

  pointer = canvasPoint(event);

});

view.addEventListener("pointerdown", (event) => {

  beeper.wake();

  if (mode !== "top") return;

  view.setPointerCapture(event.pointerId);

  const box = view.getBoundingClientRect();

  if (event.pointerType === "touch") {

    if (event.clientX - box.left < box.width / 2)

      stick = { id: event.pointerId, ox: event.clientX, oy: event.clientY, mx: 0, my: 0 };

    else {

      aimTouch = { id: event.pointerId, ...canvasPoint(event) };

      firing = true;

    }

    event.preventDefault();

    return;

  }

  pointer = canvasPoint(event);

  firing = true;

  if (snap && !watching(snap)) gunFire(gun, snap);

});

view.addEventListener("pointermove", (event) => {

  if (stick && event.pointerId === stick.id) {

    const dx = event.clientX - stick.ox;

    const dy = event.clientY - stick.oy;

    const len = Math.hypot(dx, dy) || 1;

    const reach = Math.min(len, 48) / 48;

    stick.mx = (dx / len) * reach;

    stick.my = (dy / len) * reach;

  }

  if (aimTouch && event.pointerId === aimTouch.id) Object.assign(aimTouch, canvasPoint(event));

});

const endPointer = (event) => {

  if (stick && event.pointerId === stick.id) stick = null;

  else if (aimTouch && event.pointerId === aimTouch.id) {

    aimTouch = null;

    firing = false;

  } else firing = false;

};

view.addEventListener("pointerup", endPointer);

view.addEventListener("pointercancel", endPointer);

view.addEventListener("contextmenu", (event) => event.preventDefault());

// What this person is doing, in the world's terms. In the first-person view

// the keys are read against the way you are facing; in the top-down view they

// are the compass, the way they always were.

function readIntent() {

  let ax = 0;

  let ay = 0;

  if (keys.has("KeyW")) ay -= 1;

  if (keys.has("KeyS")) ay += 1;

  if (keys.has("KeyA")) ax -= 1;

  if (keys.has("KeyD")) ax += 1;

  if (stick) {

    ax = stick.mx;

    ay = stick.my;

  }

  intent.mx = ax;

  intent.my = ay;

  if (mode === "fp") {

    intent.angle = head.angle;

    moveVector(ax, ay, head.angle, walk);

    intent.mx = walk.x;

    intent.my = walk.y;

  } else {

    const aim = aimTouch || pointer;

    const me = worldToScreen(drawnMe.id ? drawnMe : snap.me);

    // The pointer is this view's aim, and it is ours the same way the mouse

    // is: with no pointer yet, keep the facing rather than the stale answer.

    if (aim) aimAt(head, Math.atan2(aim.y - me.y, aim.x - me.x));

    intent.angle = head.angle;

  }

  intent.fire = firing || keys.has("Space");

  intent.use = keys.has("KeyF");

  intent.reload = keys.has("KeyR");

  return intent;

}

// Twenty times a second the server hears it. Intent only — a direction, an

// angle, a held key — never a position: the guess below is for drawing.

setInterval(() => {

  if (!snap || !map || watching(snap)) return; // nothing to drive, nothing to send

  const now = readIntent();

  send({ t: "i", mx: now.mx, my: now.my, a: now.angle, f: now.fire, u: now.use, r: now.reload });

  // What we told it, so its echo is recognisable as ours when it comes back.

  told(head, now.angle, performance.now() / 1000);

}, 50);

// ------------------------------------------------------------------ drawing

function resize() {

  const box = view.getBoundingClientRect();

  const dpr = Math.min(devicePixelRatio || 1, 2);

  view.width = Math.round(box.width * dpr);

  view.height = Math.round(box.height * dpr);

  sizeRender();

}

addEventListener("resize", resize);

/** The offscreen the world is drawn into, at the level in force right now. */

function sizeRender() {

  render = renderSize(view.width, view.height, budget.level);

  if (sceneCanvas.width !== render.width) sceneCanvas.width = render.width;

  if (sceneCanvas.height !== render.height) sceneCanvas.height = render.height;

}

const scale = () => (map ? view.width / (map.rows[0].length * map.tile) : 1);

const worldToScreen = (p) => ({ x: p.x * scale(), y: p.y * scale() });

/**

 * Everybody else is drawn at `drawAt`: between the two samples that bracket

 * it, so they move at the server's own speed and arrive where it put them.

 * You are not: your own body is the one this browser can run forward

 * honestly, and drawing it late is what dragged the camera backwards.

 */

const look = (p) => {

  if (predicting() && p.id === snap.me.id) return drawnMe;

  // Your own body, when it is not being predicted — the buy phase, or dead —

  // is drawn from the newest word about it and nothing else. It must not go

  // through the two treatments below, which exist for OTHER people: drawing

  // it in the past puts the camera behind your own mouse, and the arriving

  // slide treats a respawn as somebody walking into view and slides the

  // camera in from the last place it saw you. Together they are the shake at

  // spawn.

  if (p.id === snap.me.id) return p;

  // A body still arriving is drawn part of the way in from where it came,

  // rather than at the position it had already reached when we first saw it.

  return slide(presence, p.id, bodyAt(timeline, p, drawAt), nowSec, slid);

};

/** How far into sight somebody is: 0 as they appear, 1 once they are solid. */

const shownAt = (p) => shown(presence, p.id, nowSec);

/**

 * Your own movement is only guessed at while the round is live and you are

 * alive. The buy phase pens everybody in their own spawn — a rule of the

 * match, not of the map — and a guess that does not know it would spend the

 * phase being pulled back through the door.

 */

const predicting = () =>

  snap !== null && !watching(snap) && world !== null && snap.me.alive && (snap.phase !== "buy" || pens !== null);

/** The server's own rule: in the buy phase, nowhere further than 120 from a spawn. */

const outsidePen = (x, y) => {

  if (snap.phase !== "buy" || pens === null) return false;

  const cells = pens[snap.me.side] ?? [];

  if (cells.length === 0) return false;

  let best = Infinity;

  for (const c of cells) best = Math.min(best, Math.hypot(c.x - x, c.y - y));

  return best > 120;

};

/**

 * A wall an ability put up is as solid as the map's, and the snapshot carries

 * every one of them. Without this the guess ran into a barrier the map did

 * not know about, and the drawn body stood inside it until the server's

 * answer pulled it out.

 */

const insideBarrier = (x, y) => {

  for (const zone of snap.zones) if (zone.k === "wall" && zone.f <= 0 && Math.hypot(zone.x - x, zone.y - y) < zone.r + BODY_R) return true;

  return false;

};

/** Anywhere the server would refuse to let you stand right now. */

const refused = (x, y) => outsidePen(x, y) || insideBarrier(x, y);

/** The server's answer, caught up to now, then this frame of your own keys. */

function predict(dt, now) {

  if (!predicting()) {

    local.ready = false;

    drawnMe.id = "";

    return;

  }

  const held = readIntent();

  const speed = moveSpeed({

    haste: snap.me.haste > 0,

    slow: snap.me.slow > 0,

    // Nobody moves once a round is decided: the server's tick returns before

    // it moves anybody, and a guess that kept walking ran a quarter second

    // into nothing and waited there for the next round to cut back.

    stopped: snap.me.planting > 0 || snap.me.defusing || snap.phase === "end" || snap.phase === "over",

    heavy: snap.me.weapon === "operator",

  });

  // The snapshot is a moment old and the keys held since have not reached

  // it; carry it that far forward and lean the drawn body onto it. Walking

  // out of the spawn pen, or into a barrier, is refused by the server

  // outright, so it is refused here too — see predict.js for how a refusal

  // holds rather than snaps.

  stepLocal(local, snap.me, held, speed, (now - snapAt) / 1000, dt, world, refused);

  drawnMe.id = snap.me.id;

  drawnMe.x = local.x;

  drawnMe.y = local.y;

  // Either view: the facing is the one this browser is holding, whether the

  // mouse moved it or the pointer aim did. The server hears it a moment later.

  drawnMe.angle = head.angle;

}

function frame(now) {

  requestAnimationFrame(frame);

  const began = performance.now();

  const dt = Math.min(0.1, (now - last) / 1000);

  last = now;

  nowSec = began / 1000;

  marks = ghosts(presence, nowSec);

  drawAt = renderTime(timeline, now / 1000);

  // A watching connection draws the watching view and stops there: it has no

  // map to stand on and no body to put on it, and must invent neither.

  if (watching(snap)) return void drawWatch();

  if (!map) return;

  gunTick(gun, dt);

  ctx.clearRect(0, 0, view.width, view.height);

  if (!snap) {

    drawTopdown(ctx, map, null, look, { x: 0, y: 0, w: view.width, h: view.height });

    return;

  }

  // Turning with the arrow keys belongs to the frame, at a rate a second,

  // rather than to whatever the input timer happens to do.

  if (mode === "fp" && keys.has("ArrowLeft")) turn(head, -0.9 * dt);

  if (mode === "fp" && keys.has("ArrowRight")) turn(head, 0.9 * dt);

  predict(dt, now);

  beeper.update(snap.spike.planted, snap.spike.fuse, now / 1000);

  const eye = look(snap.me);

  const facing = mode === "fp" ? head.angle : eye.angle;

  if (mode === "fp" && !mapOpen) {

    // The world at a few hundred columns, then scaled onto the canvas. The

    // walls are flat shaded, so the upscale costs the picture almost

    // nothing; the crosshair and the map below are drawn sharp on top.

    drawScene(sceneCtx, scene, { solid, tile: map.tile }, { x: eye.x, y: eye.y, angle: facing }, snap, {

      width: render.width,

      height: render.height,

      look,

      shown: shownAt,

      marks,

    });

    ctx.drawImage(sceneCanvas, 0, 0, view.width, view.height);

    drawGun(ctx, gun, view.width, view.height, snap);

    drawMinimap();

  } else {

    const box = { x: 0, y: 0, w: view.width, h: view.height };

    ctx.drawImage(tileLayer(view.width, view.height, true), 0, 0);

    drawTopdown(ctx, map, snap, look, box, { marks, tiles: false });

  }

  if (snap.me.planting > 0) bar(snap.me.planting / 4, "#e0a040", "planting");

  else if (snap.spike.planted && snap.spike.defuse > 0 && snap.me.side === "def")

    bar(snap.spike.defuse / 7, "#4fd6a0", "defusing");

  // The moment a round turns, the view says so: who took it, why, and when

  // the next one starts. Between rounds the banner is the word, so the dead

  // overlay only speaks while a round is actually being played without you.

  const words = banner(snap);

  if (words) drawBanner(ctx, words, view.width, view.height);

  $("flash").style.opacity = Math.min(0.95, snap.me.blind * 0.8);

  $("dead").style.display = snap.me.alive || snap.phase !== "live" ? "none" : "grid";

  $("aimhint").style.display = mode === "fp" && !locked && !COARSE ? "grid" : "none";

  // What this frame cost to draw, not how long the browser waited for the

  // next one: a machine with headroom is capped at its refresh rate, and the

  // renderer would never earn a rung back if that were the measure.

  const ended = performance.now();

  if (measure(budget, ended - began, ended / 1000)) sizeRender();

  paintPerf(ended);

}

/** F3 or ` — the numbers, so "it feels choppy" has something to argue with. */

function togglePerf() {

  perfOn = !perfOn;

  const box = $("perf");

  if (!box) return;

  box.style.display = perfOn ? "block" : "none";

  // Straight away, whatever the clock says: a readout you turn on and that

  // stays blank for half a second reads as a readout that does not work.

  if (perfOn) paintPerf(performance.now(), true);

}

/**

 * The readout, rewritten twice a second: the frame rate and the mean frame

 * the governor decided on, the rate snapshots are actually arriving at, the

 * interpolation delay in force, how wide the world is being drawn, and how

 * many times a minute the drawing took the server's word outright — your

 * own body anchored, somebody else started again, the view re-pointed. Each

 * of those is a jump, and a jump is what a stutter is made of.

 */

let perfSince = 0;

function paintPerf(nowMs, force) {

  const box = $("perf");

  if (!perfOn || !box || (!force && nowMs - perfAt < 500)) return;

  perfAt = nowMs;

  if (perfSince === 0) perfSince = nowMs;

  const hz = timeline.interval > 0 ? 1 / timeline.interval : 0;

  const jumps = local.anchored + timeline.restarts + head.corrected;

  const minutes = Math.max(1 / 60, (nowMs - perfSince) / 60000);

  box.textContent =

    `${budget.fps.toFixed(1)} fps · ${budget.mean.toFixed(1)} ms/frame · ` +

    `${hz.toFixed(1)} Hz in · ${(delay(timeline) * 1000).toFixed(0)} ms behind · ` +

    `${render.width}×${render.height} of ${view.width}×${view.height} · ` +

    `${jumps} jumps (${(jumps / minutes).toFixed(1)}/min)`;

}

/**

 * The map's own tiles, drawn once a size and kept. There are 570 of them and

 * they are the same 570 every frame — on the minimap that was more fills

 * than the whole first-person view costs. Called with no snapshot,

 * `drawTopdown` draws exactly this layer and nothing else.

 */

const layers = new Map();

function tileLayer(w, h, labels) {

  const key = `${w}x${h}${labels ? "L" : ""}`;

  const had = layers.get(key);

  if (had) return had;

  const layer = document.createElement("canvas");

  layer.width = w;

  layer.height = h;

  drawTopdown(layer.getContext("2d"), map, null, look, { x: 0, y: 0, w, h }, { labels });

  if (layers.size > 3) layers.clear(); // a window being dragged, not a leak

  layers.set(key, layer);

  return layer;

}

/** The same top-down drawing, small, in the corner, with you as an arrow. */

function drawMinimap() {

  const w = Math.min(view.width * 0.3, 260 * (view.width / 900));

  const h = (w * map.rows.length) / map.rows[0].length;

  const pad = 8;

  ctx.save();

  ctx.globalAlpha = 0.85;

  ctx.fillStyle = "#0b0d11";

  ctx.fillRect(pad - 2, pad - 2, w + 4, h + 4);

  ctx.drawImage(tileLayer(Math.max(1, Math.round(w)), Math.max(1, Math.round(h)), false), pad, pad, w, h);

  drawTopdown(ctx, map, snap, look, { x: pad, y: pad, w, h }, { labels: false, marks, tiles: false });

  ctx.restore();

  ctx.strokeStyle = "rgba(255,255,255,0.18)";

  ctx.lineWidth = 1;

  ctx.strokeRect(pad - 2, pad - 2, w + 4, h + 4);

}

function bar(fraction, colour, label) {

  const w = view.width * 0.4;

  const x = view.width / 2 - w / 2;

  const y = view.height * 0.86;

  ctx.fillStyle = "#0009";

  ctx.fillRect(x, y, w, 16);

  ctx.fillStyle = colour;

  ctx.fillRect(x, y, w * Math.min(1, fraction), 16);

  ctx.fillStyle = "#fff";

  ctx.font = "12px system-ui, sans-serif";

  ctx.textAlign = "center";

  ctx.fillText(label, view.width / 2, y + 12);

  ctx.textAlign = "left";

}

// --------------------------------------------------------------------- hud

// The buy opens itself every buy phase; closing it is remembered until the

// next one, so nobody has to fight the panel to watch the round start.

function toggleBuy() {

  const open = $("buy").classList.toggle("on");

  $("buy").dataset.closed = open ? "" : "1";

}

$("buytoggle").addEventListener("click", toggleBuy);

$("viewtoggle").addEventListener("click", () => setMode(mode === "fp" ? "top" : "fp"));

$("helptoggle").addEventListener("click", () => toggleHelp());

$("helpclose").addEventListener("click", () => toggleHelp(false));

for (const button of document.querySelectorAll("[data-buy]"))

  button.addEventListener("click", () => send({ t: "buy", what: button.dataset.buy }));

for (const button of document.querySelectorAll("[data-agent]"))

  button.addEventListener("click", () => send({ t: "agent", id: button.dataset.agent }));

function toggleHelp(force) {

  const open = force === undefined ? $("help").style.display !== "grid" : force;

  $("help").style.display = open ? "grid" : "none";

  if (!open) {

    helpShown = true;

    try {

      localStorage.setItem(HELP_SEEN, "1");

    } catch {

      // A browser that refuses storage still gets the card, every visit.

    }

  }

}

/** The first-run card, once per browser, and never over a round in progress. */

function maybeHelp(s) {

  if (helpShown) return;

  try {

    if (localStorage.getItem(HELP_SEEN) === "1") {

      helpShown = true;

      return;

    }

  } catch {

    /* no storage: show it and move on */

  }

  if (s.phase === "live" && s.me.alive) return;

  helpShown = true;

  $("help").style.display = "grid";

}

const KITS = {};

function paintHud(s) {

  $("clock").textContent = Math.ceil(s.phase === "live" && s.spike.planted ? s.spike.fuse : s.clock);

  document.querySelector("#scoreline .red").textContent = "red " + s.score.red;

  document.querySelector("#scoreline .blue").textContent = s.score.blue + " blue";

  const turned = s.phase === "end" && s.last ? `round over — ${s.last.winner} took it` : null;

  $("phase").textContent =

    `round ${s.round} · ${s.phase === "buy" ? "buy phase" : s.phase === "live" ? (s.spike.planted ? "spike down" : "live") : (turned ?? (s.phase === "end" ? "round over" : "match over"))} · ${s.attackers} attacking · you are ${s.me.side === "atk" ? "attacking" : "defending"}${s.result ? " · " + s.result : ""}`;

  $("hp").textContent = `${s.me.hp} hp${s.me.armour ? " +" + s.me.armour : ""}`;

  $("gun").textContent = `${s.me.weapon}${s.me.reloading ? " reloading" : " " + s.me.ammo}`;

  $("creds").textContent = `${s.me.credits} cr`;

  $("ultmeter").textContent = `ult ${s.me.ult}/${s.me.ultNeeds}`;

  $("buy").classList.toggle("on", s.phase === "buy" && $("buy").dataset.closed !== "1");

  if (s.phase !== "buy") $("buy").dataset.closed = "";

  const text = choosePrompt(s, {

    onSite: onSite(s.me),

    nearSpike: s.spike.x !== null && Math.hypot(s.spike.x - s.me.x, s.spike.y - s.me.y) < REACH,

  });

  if ($("prompt").textContent !== text) $("prompt").textContent = text;

  paintKit(s);

  paintBuy(s);

  paintRoster(s);

  paintFeed(s);

  paintLog(s);

  for (const side of ["atk", "def"]) {

    const body = $(side + "board");

    const rows = (s.board ?? []).filter((p) => p.side === side).sort((a, b) => b.kills - a.kills);

    const key = rows.map((p) => `${p.name}${p.kills}${p.deaths}${p.alive}${p.credits}`).join();

    if (body.dataset.key === key) continue;

    body.dataset.key = key;

    body.replaceChildren();

    for (const player of rows) {

      const tr = document.createElement("tr");

      const cells = [

        player.name + (player.bot ? " (bot)" : "") + (player.alive ? "" : " ✕"),

        player.agent + (player.credits !== null ? ` · ${player.credits}cr` : ""),

        String(player.kills),

        String(player.deaths),

      ];

      for (const value of cells) {

        const td = document.createElement("td");

        td.textContent = value;

        tr.append(td);

      }

      if (player.id === s.me.id) tr.style.fontWeight = "700";

      body.append(tr);

    }

  }

}

/** The last few things that happened, in words. Rebuilt only when they change. */

function paintLog(s) {

  const log = $("log");

  const lines = (s.events ?? []).slice(0, 3);

  if (log.dataset.text === lines.join("\n")) return;

  log.dataset.text = lines.join("\n");

  log.replaceChildren();

  for (const line of lines) {

    const div = document.createElement("div");

    div.textContent = line;

    log.append(div);

  }

}

/**

 * The HUD for a connection with no seat. Everything a seat's HUD says about

 * you — health, gun, credits, kit, your five — has no answer here, so it says

 * so rather than leaving the page's first paint standing there going stale.

 */

function paintWatch(s) {

  const lines = watchLines(s);

  $("clock").textContent = Math.ceil(Math.max(0, Number(s.clock) || 0));

  document.querySelector("#scoreline .red").textContent = "red " + (s.score?.red ?? 0);

  document.querySelector("#scoreline .blue").textContent = (s.score?.blue ?? 0) + " blue";

  $("phase").textContent = lines.phase;

  $("hp").textContent = "watching";

  $("gun").textContent = "no seat";

  $("creds").textContent = "—";

  $("ultmeter").textContent = "—";

  $("buy").classList.toggle("on", false);

  if ($("prompt").textContent !== lines.why) $("prompt").textContent = lines.why;

  paintFeed(s);

  paintLog(s);

  blank($("kit"));

  blank($("roster"));

  blank($("atkboard"));

  blank($("defboard"));

  if (KITS.shape !== "watching") KITS.shape = "watching";

}