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

/**

 * The dungeon itself: generated, never stored. Five floors, each a pure

 * function of the seed and the depth — so every delver walks the same rooms,

 * every corridor is where the last one left it, and the database only has to

 * remember what has *happened* in the dungeon, not what it looks like.

 *

 * Nothing in this file touches the database or the clock.

 */

export const WIDTH = 48;

export const HEIGHT = 24;

export const DEPTHS = 5;

/** How far a lantern throws, in tiles. */

export const LANTERN = 4;

export type Tile = "#" | "." | ">" | "<";

export interface Room {

  x: number;

  y: number;

  w: number;

  h: number;

}

export interface Floor {

  depth: number;

  tiles: Tile[];

  rooms: Room[];

  /** Where a delver arrives when coming down (or starting out). */

  entrance: number;

  /** The stair down; on the deepest floor there is none. */

  descent: number | undefined;

}

export const at = (x: number, y: number): number => y * WIDTH + x;

export const xy = (cell: number): { x: number; y: number } => ({

  x: cell % WIDTH,

  y: Math.floor(cell / WIDTH),

});

/** Deterministic noise: the same seed, depth and salt always give the same roll. */

function roll(seed: number, depth: number, salt: number): number {

  let h = (seed * 2654435761) ^ (depth * 40503) ^ (salt * 2246822519);

  h = Math.imul(h ^ (h >>> 15), 2246822519);

  h = Math.imul(h ^ (h >>> 13), 3266489917);

  return ((h ^ (h >>> 16)) >>> 0) / 4294967296;

}

const between = (r: number, lo: number, hi: number): number =>

  lo + Math.floor(r * (hi - lo + 1));

function carveRoom(tiles: Tile[], room: Room): void {

  for (let y = room.y; y < room.y + room.h; y += 1)

    for (let x = room.x; x < room.x + room.w; x += 1) tiles[at(x, y)] = ".";

}

function carveCorridor(tiles: Tile[], a: Room, b: Room, bendFirst: boolean): void {

  const ax = Math.floor(a.x + a.w / 2);

  const ay = Math.floor(a.y + a.h / 2);

  const bx = Math.floor(b.x + b.w / 2);

  const by = Math.floor(b.y + b.h / 2);

  const hor = (y: number, from: number, to: number): void => {

    for (let x = Math.min(from, to); x <= Math.max(from, to); x += 1)

      tiles[at(x, y)] = ".";

  };

  const ver = (x: number, from: number, to: number): void => {

    for (let y = Math.min(from, to); y <= Math.max(from, to); y += 1)

      tiles[at(x, y)] = ".";

  };

  if (bendFirst) {

    hor(ay, ax, bx);

    ver(bx, ay, by);

  } else {

    ver(ax, ay, by);

    hor(by, ax, bx);

  }

}

const overlaps = (a: Room, b: Room): boolean =>

  a.x < b.x + b.w + 1 &&

  a.x + a.w + 1 > b.x &&

  a.y < b.y + b.h + 1 &&

  a.y + a.h + 1 > b.y;

/** One floor, built the same way every time it is asked for. */

export function floorAt(depth: number, seed = 1848): Floor {

  const tiles: Tile[] = new Array(WIDTH * HEIGHT).fill("#");

  const rooms: Room[] = [];

  // Deeper floors are more broken up: fewer, smaller, further apart.

  const attempts = 60;

  const maxRooms = Math.max(5, 11 - depth);

  for (let i = 0; i < attempts && rooms.length < maxRooms; i += 1) {

    const w = between(roll(seed, depth, i * 7 + 1), 5, Math.max(6, 11 - depth));

    const h = between(roll(seed, depth, i * 7 + 2), 3, Math.max(4, 7 - Math.floor(depth / 2)));

    const room: Room = {

      x: between(roll(seed, depth, i * 7 + 3), 1, WIDTH - w - 2),

      y: between(roll(seed, depth, i * 7 + 4), 1, HEIGHT - h - 2),

      w,

      h,

    };

    if (rooms.some((other) => overlaps(room, other))) continue;

    rooms.push(room);

  }

  for (const room of rooms) carveRoom(tiles, room);

  for (let i = 1; i < rooms.length; i += 1)

    carveCorridor(tiles, rooms[i - 1] as Room, rooms[i] as Room, roll(seed, depth, i * 13) < 0.5);

  const first = rooms[0] as Room;

  const last = rooms[rooms.length - 1] as Room;

  const entrance = at(Math.floor(first.x + first.w / 2), Math.floor(first.y + first.h / 2));

  tiles[entrance] = "<";

  let descent: number | undefined;

  if (depth < DEPTHS) {

    descent = at(Math.floor(last.x + last.w / 2), Math.floor(last.y + last.h / 2));

    tiles[descent] = ">";

  }

  return { depth, tiles, rooms, entrance, descent };

}

export const walkable = (tile: Tile | undefined): boolean =>

  tile === "." || tile === ">" || tile === "<";

/** Floor tiles in reading order — what anything placed in the dungeon picks from. */

export function openCells(floor: Floor): number[] {

  const open: number[] = [];

  for (const [cell, tile] of floor.tiles.entries())

    if (tile === ".") open.push(cell);

  return open;

}

/**

 * Line of sight, Bresenham. A wall stops the light at the wall, so you see

 * the wall itself and nothing behind it — which is what makes a doorway read

 * as a doorway.

 */

export function seesFrom(floor: Floor, from: number, to: number): boolean {

  const a = xy(from);

  const b = xy(to);

  let { x, y } = a;

  const dx = Math.abs(b.x - x);

  const dy = Math.abs(b.y - y);

  const sx = x < b.x ? 1 : -1;

  const sy = y < b.y ? 1 : -1;

  let err = dx - dy;

  for (;;) {

    if (x === b.x && y === b.y) return true;

    const e2 = 2 * err;

    if (e2 > -dy) {

      err -= dy;

      x += sx;

    }

    if (e2 < dx) {

      err += dx;

      y += sy;

    }

    if (x === b.x && y === b.y) return true;

    if (!walkable(floor.tiles[at(x, y)])) return false;

  }

}

export const distance = (a: number, b: number): number => {

  const p = xy(a);

  const q = xy(b);

  return Math.max(Math.abs(p.x - q.x), Math.abs(p.y - q.y));

};

/** Every cell a delver standing here can currently see. */

export function visibleFrom(floor: Floor, from: number, radius = LANTERN): number[] {

  const seen: number[] = [];

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

  for (let dy = -radius; dy <= radius; dy += 1)

    for (let dx = -radius; dx <= radius; dx += 1) {

      const nx = x + dx;

      const ny = y + dy;

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

      const cell = at(nx, ny);

      if (distance(from, cell) > radius) continue;

      if (seesFrom(floor, from, cell)) seen.push(cell);

    }

  return seen;

}

/** One step from `from` toward `to`, around walls where it can manage it. */

export function stepToward(floor: Floor, from: number, to: number): number {

  const a = xy(from);

  const b = xy(to);

  const sx = Math.sign(b.x - a.x);

  const sy = Math.sign(b.y - a.y);

  const tries = [

    at(a.x + sx, a.y + sy),

    sx !== 0 ? at(a.x + sx, a.y) : at(a.x, a.y + sy),

    sy !== 0 ? at(a.x, a.y + sy) : at(a.x + sx, a.y),

  ];

  for (const cell of tries)

    if (cell !== from && walkable(floor.tiles[cell])) return cell;

  return from;

}