benjivers/val Public Public: anyone can read this; the crew can change it.

/**

 * The renderer, run for real against a canvas that writes down what it was

 * asked to draw. No browser, but every line of the draw path is executed —

 * which is what catches a typo in a frame nobody can see from a unit test.

 */

import { expect, test } from "bun:test";

import { drawGun, makeGun } from "../static/gun.js";

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

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

import { gridRows, TILE } from "./map.ts";

type Op = { op: string; args: unknown[] };

/** A canvas that records. Every call the renderer makes has to exist here. */

function fakeContext() {

  const ops: Op[] = [];

  const note =

    (op: string) =>

    (...args: unknown[]) => {

      ops.push({ op, args });

    };

  const ctx = {

    ops,

    fillStyle: "",

    strokeStyle: "",

    lineWidth: 1,

    font: "",

    textAlign: "left",

    globalAlpha: 1,

    clearRect: note("clearRect"),

    fillRect: note("fillRect"),

    strokeRect: note("strokeRect"),

    beginPath: note("beginPath"),

    closePath: note("closePath"),

    moveTo: note("moveTo"),

    lineTo: note("lineTo"),

    arc: note("arc"),

    ellipse: note("ellipse"),

    fill: note("fill"),

    stroke: note("stroke"),

    clip: note("clip"),

    rect: note("rect"),

    save: note("save"),

    restore: note("restore"),

    translate: note("translate"),

    rotate: note("rotate"),

    fillText: note("fillText"),

    measureText: (text: string) => ({ width: text.length * 6 }),

    createLinearGradient: () => ({ addColorStop() {} }),

  };

  return ctx;

}

// A room three tiles deep running east, with a pillar standing in it at

// column 5 — enough geometry for a body to hide behind.

const room = (col: number, row: number): boolean =>

  col < 1 || col > 12 || row < 1 || row > 3 || col === 5;

const world = { solid: room, tile: TILE };

const snapshot = (players: unknown[], zones: unknown[] = []) => ({

  phase: "live",

  clock: 40,

  result: null,

  me: { id: "me", x: 120, y: 200, angle: 0, alive: true, side: "atk", hp: 100, blind: 0, ammo: 25, reloading: false, planting: 0, spike: false, agent: "ember" },

  players,

  zones,

  orbs: [],

  shots: [],

  spike: { planted: false, carried: false, fuse: 0, defuse: 0, x: null, y: null },

});

const body = (over: Record<string, unknown> = {}) => ({

  id: "them",

  name: "Sable",

  agent: "sable",

  x: 280,

  y: 200,

  angle: 3.1,

  hp: 100,

  alive: true,

  mate: false,

  spike: false,

  blind: false,

  ...over,

});

const view = { width: 900, height: 570, look: (p: { x: number; y: number; angle: number }) => p };

const eye = { x: 120, y: 200, angle: 0 };

test("a frame draws walls in runs: the whole width covered, far fewer fills", () => {

  const ctx = fakeContext();

  drawScene(ctx as never, makeScene(), world, eye, snapshot([]), view);

  const rects = ctx.ops.filter((o) => o.op === "fillRect");

  // The bands are the full width; the rest are wall runs.

  const walls = rects

    .map((o) => ({ x: Number(o.args[0]), w: Number(o.args[2]) }))

    .filter((r) => r.w < view.width)

    .sort((a, b) => a.x - b.x);

  // This room is closed, so every column of the picture is wall: the runs

  // start at the left edge, meet end to end and reach the right one. That is

  // the same picture the old one-fill-a-column loop drew.

  expect(walls[0]!.x).toBe(0);

  let reach = 0;

  for (const rect of walls) {

    expect(rect.x).toBeLessThanOrEqual(reach);

    reach = Math.max(reach, rect.x + rect.w);

  }

  expect(reach).toBeGreaterThanOrEqual(view.width);

  // And it costs a fraction of the fills: one a column would be 900.

  expect(walls.length).toBeLessThan(view.width / 2);

});

test("a body in the open is drawn; the same body behind the pillar is not", () => {

  const open = fakeContext();

  drawScene(open as never, makeScene(), world, eye, snapshot([body()]), view);

  // The head is the only arc in this scene, so it stands for the body.

  expect(open.ops.some((o) => o.op === "arc")).toBe(true);

  const hidden = fakeContext();

  drawScene(hidden as never, makeScene(), world, eye, snapshot([body({ x: 700 })]), view);

  expect(hidden.ops.some((o) => o.op === "arc")).toBe(false);

});

test("a team mate gets a name tag and an enemy never does", () => {

  const mate = fakeContext();

  drawScene(mate as never, makeScene(), world, eye, snapshot([body({ mate: true })]), view);

  expect(mate.ops.some((o) => o.op === "fillText" && o.args[0] === "Sable")).toBe(true);

  const enemy = fakeContext();

  drawScene(enemy as never, makeScene(), world, eye, snapshot([body()]), view);

  expect(enemy.ops.some((o) => o.op === "fillText")).toBe(false);

});

test("the dead lie on the floor and wear no markers at all", () => {

  const ctx = fakeContext();

  drawScene(ctx as never, makeScene(), world, eye, snapshot([body({ mate: true, alive: false, hp: 0 })]), view);

  // Flat on the ground: an ellipse, not an upright body with a head.

  expect(ctx.ops.some((o) => o.op === "ellipse")).toBe(true);

  // No name tag, and no chevron — the chevron is the only closed path here.

  expect(ctx.ops.some((o) => o.op === "fillText")).toBe(false);

  expect(ctx.ops.some((o) => o.op === "closePath")).toBe(false);

});

test("an enemy wears a chevron and a team mate does not", () => {

  const enemy = fakeContext();

  drawScene(enemy as never, makeScene(), world, eye, snapshot([body()]), view);

  expect(enemy.ops.some((o) => o.op === "closePath")).toBe(true);

  const mate = fakeContext();

  drawScene(mate as never, makeScene(), world, eye, snapshot([body({ mate: true })]), view);

  expect(mate.ops.some((o) => o.op === "closePath")).toBe(false);

  expect(mate.ops.some((o) => o.op === "fillText")).toBe(true);

});

test("a body has a hard dark edge, whichever side it is on", () => {

  const ctx = fakeContext();

  drawScene(ctx as never, makeScene(), world, eye, snapshot([body()]), view);

  expect(ctx.ops.some((o) => o.op === "strokeRect")).toBe(true);

});

test("a smoke between the eye and a body hides it", () => {

  const smoke = [{ k: "smoke", x: 200, y: 200, r: 90, f: 0, l: 8 }];

  const ctx = fakeContext();

  drawScene(ctx as never, makeScene(), world, eye, snapshot([body()], smoke), view);

  expect(ctx.ops.some((o) => o.op === "arc")).toBe(false);

  // A smoke that is not on the line does not hide anything.

  const aside = [{ k: "smoke", x: 200, y: 900, r: 90, f: 0, l: 8 }];

  const clear = fakeContext();

  drawScene(clear as never, makeScene(), world, eye, snapshot([body()], aside), view);

  expect(clear.ops.some((o) => o.op === "arc")).toBe(true);

});

test("every kind of zone, the spike and a tracer draw without falling over", () => {

  const zones = ["smoke", "molly", "wall", "trip", "dart", "flash", "heal"].map((k, i) => ({

    k,

    x: 300 + i * 20,

    y: 200,

    r: 90,

    f: k === "flash" ? 0.3 : 0,

    l: 5,

  }));

  const snap = snapshot([body(), body({ id: "mate", mate: true, alive: false, hp: 0 })], zones);

  snap.orbs = [{ x: 360, y: 200 }] as never;

  snap.shots = [{ x1: 130, y1: 200, x2: 380, y2: 200, hit: true, age: 0 }] as never;

  snap.spike = { planted: true, carried: false, fuse: 12, defuse: 0, x: 330, y: 200 } as never;

  const ctx = fakeContext();

  drawScene(ctx as never, makeScene(), world, eye, snap, view);

  expect(ctx.ops.length).toBeGreaterThan(100);

  expect(ctx.globalAlpha).toBe(1);

});

test("the top-down view draws the real map, small or large", () => {

  const map = { rows: gridRows(), tile: TILE };

  const snap = snapshot([body({ mate: true })]);

  const big = fakeContext();

  drawTopdown(big as never, map, snap, (p: never) => p, { x: 0, y: 0, w: 900, h: 570 });

  const small = fakeContext();

  drawTopdown(small as never, map, snap, (p: never) => p, { x: 8, y: 8, w: 260, h: 165 }, { labels: false });

  expect(big.ops.some((o) => o.op === "fillText")).toBe(true);

  expect(small.ops.some((o) => o.op === "fillText")).toBe(false);

  expect(small.ops.some((o) => o.op === "translate")).toBe(true);

});

test("on the map a dead team mate is crossed out and a dead enemy is not there", () => {

  const map = { rows: gridRows(), tile: TILE };

  const box = { x: 0, y: 0, w: 900, h: 570 };

  const look = (p: never) => p;

  const mate = fakeContext();

  drawTopdown(mate as never, map, snapshot([body({ mate: true, alive: false })]), look, box);

  // Two strokes through the dot, and no dot: a cross is not a live player.

  expect(mate.ops.filter((o) => o.op === "moveTo").length).toBe(2);

  expect(mate.ops.some((o) => o.op === "arc")).toBe(false);

  const enemy = fakeContext();

  drawTopdown(enemy as never, map, snapshot([body({ alive: false })]), look, box);

  const empty = fakeContext();

  drawTopdown(empty as never, map, snapshot([]), look, box);

  expect(enemy.ops.length).toBe(empty.ops.length);

});

test("a living team mate carries their initial on the big map", () => {

  const map = { rows: gridRows(), tile: TILE };

  const big = fakeContext();

  drawTopdown(big as never, map, snapshot([body({ mate: true, name: "Wren" })]), (p: never) => p, {

    x: 0,

    y: 0,

    w: 900,

    h: 570,

  });

  expect(big.ops.some((o) => o.op === "fillText" && o.args[0] === "W")).toBe(true);

});

test("the gun and the crosshair draw, and the hit marker only when there is one", () => {

  const gun = makeGun();

  const ctx = fakeContext();

  drawGun(ctx as never, gun, 900, 570, snapshot([]));

  const quiet = ctx.ops.length;

  gun.mark = 1;

  gun.kick = 1;

  const loud = fakeContext();

  drawGun(loud as never, gun, 900, 570, snapshot([]));

  expect(loud.ops.length).toBeGreaterThan(quiet);

});