heron/lanternfall Public Public: anyone can read this; nobody can change it.

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

import {

  DEPTHS, HEIGHT, WIDTH, at, distance, floorAt, openCells, seesFrom,

  stepToward, visibleFrom, walkable, xy,

} from "./dungeon.ts";

test("a floor is the same floor every time it is asked for", () => {

  for (let depth = 1; depth <= DEPTHS; depth += 1)

    expect(floorAt(depth).tiles.join("")).toBe(floorAt(depth).tiles.join(""));

  expect(floorAt(1).tiles.join("")).not.toBe(floorAt(2).tiles.join(""));

});

test("every floor has rooms, an entrance, and a way on", () => {

  for (let depth = 1; depth <= DEPTHS; depth += 1) {

    const floor = floorAt(depth);

    expect(floor.rooms.length).toBeGreaterThanOrEqual(5);

    expect(openCells(floor).length).toBeGreaterThan(150);

    expect(floor.tiles[floor.entrance]).toBe("<");

    if (depth < DEPTHS) expect(floor.tiles[floor.descent as number]).toBe(">");

    else expect(floor.descent).toBeUndefined();

  }

});

test("the stair is reachable from the entrance", () => {

  // A floor you cannot cross is a floor nobody can finish. Flood fill.

  for (let depth = 1; depth < DEPTHS; depth += 1) {

    const floor = floorAt(depth);

    const seen = new Set<number>([floor.entrance]);

    const queue = [floor.entrance];

    while (queue.length > 0) {

      const cell = queue.shift() as number;

      const { x, y } = xy(cell);

      for (const [dx, dy] of [[0,-1],[0,1],[1,0],[-1,0]] as const) {

        const nx = x + dx;

        const ny = y + dy;

        if (nx < 0 || ny < 0 || nx >= WIDTH || ny >= HEIGHT) continue;

        const next = at(nx, ny);

        if (seen.has(next) || !walkable(floor.tiles[next])) continue;

        seen.add(next);

        queue.push(next);

      }

    }

    expect(seen.has(floor.descent as number)).toBe(true);

  }

});

test("a wall stops the light at the wall", () => {

  const floor = floorAt(1);

  const wall = floor.tiles.findIndex((t) => t === "#");

  const lit = visibleFrom(floor, floor.entrance);

  expect(lit).toContain(floor.entrance);

  // Nothing lit is further than the lantern reaches.

  for (const cell of lit) expect(distance(floor.entrance, cell)).toBeLessThanOrEqual(4);

  // And sight into solid rock stops: a cell behind a wall is not visible.

  const blocked = floor.tiles.findIndex(

    (t, i) => t === "." && !seesFrom(floor, floor.entrance, i) && distance(floor.entrance, i) <= 4,

  );

  if (blocked !== -1) expect(lit).not.toContain(blocked);

  expect(wall).toBeGreaterThan(-1);

});

test("a step toward something goes around the corner it cannot go through", () => {

  const floor = floorAt(1);

  const from = floor.entrance;

  const step = stepToward(floor, from, floor.descent as number);

  expect(walkable(floor.tiles[step])).toBe(true);

  expect(distance(step, from)).toBeLessThanOrEqual(1);

});