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

/**

 * A tile grid and the questions everything else asks of it: which tiles are

 * solid, where a circle slides to, whether a wall stands between two points,

 * where a ray stops, and how far a walk is.

 *

 * The grid is rows of letters. `#` is a wall; every other letter is floor,

 * and what a letter means beyond that is the game's business — this module

 * hands back the cells of a letter and never asks what they are for.

 *

 * `makeGrid` binds the maths to one set of rows and one tile size. The

 * collision itself is `glide.ts`, which the browser runs too; the walk

 * distances are cached per goal for the round and cleared by the caller.

 *

 * Argument order matters for speed: a walk field is built for `to` and read

 * at `from`. Keep `to` fixed and vary `from`; walking is symmetric on this

 * grid, so swapping the two never changes the answer.

 */

import { circleBlocked, slideCircle } from "./glide.ts";

export type Point = { x: number; y: number };

export type Grid = {

  lines: string[];

  cols: number;

  rows: number;

  tile: number;

  width: number;

  height: number;

  /** The letter at a tile; anything off the grid is a wall. */

  at: (col: number, row: number) => string;

  solidTile: (col: number, row: number) => boolean;

  tileOf: (x: number, y: number) => { col: number; row: number };

  centreOf: (col: number, row: number) => Point;

  solidAt: (x: number, y: number) => boolean;

  /** The letter under a point. */

  cellAt: (x: number, y: number) => string;

  /** The centres of every tile carrying this letter, row by row. */

  cellsOf: (mark: string) => Point[];

  /** Slide a circle through this grid. */

  moveCircle: (x: number, y: number, dx: number, dy: number, r: number) => Point;

  /** True when a circle at (x,y) overlaps any solid tile. */

  blockedCircle: (x: number, y: number, r: number) => boolean;

  wallBetween: (a: Point, b: Point) => boolean;

  rayHitWall: (from: Point, angle: number, range: number) => Point;

  /**

   * Tiles walked between two points, or -1. Cached by `to`: hold `to` fixed

   * and vary `from`, never the other way (symmetric, so swapping is safe).

   */

  walkDistance: (from: Point, to: Point) => number;

  /** The next point toward `to`; reads the same field, cached by `to`. */

  pathStep: (from: Point, to: Point) => Point;

  clearPaths: () => void;

  /** How many walk fields have been built so far — for tests of the cache. */

  fieldsBuilt: () => number;

};

/** Closest approach of a segment to a point, as distance and travel along it. */

export function segmentPoint(a: Point, b: Point, p: Point): { dist: number; travel: number } {

  const dx = b.x - a.x;

  const dy = b.y - a.y;

  const len2 = dx * dx + dy * dy;

  const t = len2 === 0 ? 0 : Math.max(0, Math.min(1, ((p.x - a.x) * dx + (p.y - a.y) * dy) / len2));

  const cx = a.x + dx * t;

  const cy = a.y + dy * t;

  return { dist: Math.hypot(p.x - cx, p.y - cy), travel: t * Math.sqrt(len2) };

}

export const segmentHitsCircle = (a: Point, b: Point, c: Point, r: number): boolean =>

  segmentPoint(a, b, c).dist <= r;

const STEPS = [

  [1, 0],

  [-1, 0],

  [0, 1],

  [0, -1],

] as const;

export function makeGrid(lines: string[], tile: number): Grid {

  const cols = lines[0]!.length;

  const rows = lines.length;

  const at = (col: number, row: number): string =>

    row < 0 || row >= rows || col < 0 || col >= cols ? "#" : lines[row]![col]!;

  const solidTile = (col: number, row: number): boolean => at(col, row) === "#";

  const tileOf = (x: number, y: number): { col: number; row: number } => ({

    col: Math.floor(x / tile),

    row: Math.floor(y / tile),

  });

  const centreOf = (col: number, row: number): Point => ({

    x: col * tile + tile / 2,

    y: row * tile + tile / 2,

  });

  const solidAt = (x: number, y: number): boolean => {

    const t = tileOf(x, y);

    return solidTile(t.col, t.row);

  };

  const cellAt = (x: number, y: number): string => {

    const t = tileOf(x, y);

    return at(t.col, t.row);

  };

  const cellsOf = (mark: string): Point[] => {

    const out: Point[] = [];

    for (let row = 0; row < rows; row++)

      for (let col = 0; col < cols; col++) if (at(col, row) === mark) out.push(centreOf(col, row));

    return out;

  };

  const moveCircle = (x: number, y: number, dx: number, dy: number, r: number): Point =>

    slideCircle(x, y, dx, dy, r, solidTile, tile);

  const blockedCircle = (x: number, y: number, r: number): boolean => circleBlocked(x, y, r, solidTile, tile);

  /**

   * Does a wall stand between two points? Sampled every third of a tile: a

   * wall is a whole tile thick, so nothing is ever stepped over.

   */

  function wallBetween(a: Point, b: Point): boolean {

    const dx = b.x - a.x;

    const dy = b.y - a.y;

    const dist = Math.hypot(dx, dy);

    const steps = Math.ceil(dist / (tile / 3));

    for (let i = 1; i < steps; i++) {

      const t = i / steps;

      if (solidAt(a.x + dx * t, a.y + dy * t)) return true;

    }

    return false;

  }

  /** Where a shot stops: the first wall along the ray, or its full range. */

  function rayHitWall(from: Point, angle: number, range: number): Point {

    const dx = Math.cos(angle);

    const dy = Math.sin(angle);

    const step = tile / 4;

    for (let d = step; d <= range; d += step) {

      const x = from.x + dx * d;

      const y = from.y + dy * d;

      if (solidAt(x, y)) return { x: from.x + dx * (d - step), y: from.y + dy * (d - step) };

    }

    return { x: from.x + dx * range, y: from.y + dy * range };

  }

  // Walk distance from a goal tile, breadth-first over floor. Bots ask for it

  // every few ticks; the field for a goal is built once and kept for the round.

  const fields = new Map<number, Int32Array>();

  const clearPaths = (): void => void fields.clear();

  let built = 0;

  const fieldsBuilt = (): number => built;

  function field(goalCol: number, goalRow: number): Int32Array {

    const key = goalRow * cols + goalCol;

    const cached = fields.get(key);

    if (cached) return cached;

    built++;

    const dist = new Int32Array(cols * rows).fill(-1);

    if (!solidTile(goalCol, goalRow)) {

      dist[key] = 0;

      const queue: number[] = [key];

      for (let head = 0; head < queue.length; head++) {

        const here = queue[head]!;

        const col = here % cols;

        const row = (here - col) / cols;

        const d = dist[here]!;

        for (const [dc, dr] of STEPS) {

          const nc = col + dc;

          const nr = row + dr;

          if (nc < 0 || nc >= cols || nr < 0 || nr >= rows) continue;

          const nk = nr * cols + nc;

          if (dist[nk] !== -1 || solidTile(nc, nr)) continue;

          dist[nk] = d + 1;

          queue.push(nk);

        }

      }

    }

    if (fields.size > 64) fields.clear();

    fields.set(key, dist);

    return dist;

  }

  /**

   * Walk distance in tiles between two points, or -1 when unreachable. The

   * field is built for `to` and read at `from`, so a caller asking about many

   * cells should pass them as `from` against one fixed `to`: one field, not

   * one per call. Distance is symmetric, so the swap is always safe.

   */

  function walkDistance(from: Point, to: Point): number {

    const f = tileOf(from.x, from.y);

    const g = tileOf(to.x, to.y);

    return field(g.col, g.row)[f.row * cols + f.col] ?? -1;

  }

  /**

   * The next point to walk toward on the way to a goal: the centre of the

   * neighbouring tile that is one step closer, so a walker rounds corners

   * instead of grinding into them. Uses the field cached for `to`, like

   * `walkDistance`: many walkers to one goal cost one field.

   */

  function pathStep(from: Point, to: Point): Point {

    const f = tileOf(from.x, from.y);

    const g = tileOf(to.x, to.y);

    if (f.col === g.col && f.row === g.row) return to;

    const dist = field(g.col, g.row);

    const here = dist[f.row * cols + f.col] ?? -1;

    if (here <= 0) return to;

    let best: Point | null = null;

    let bestD = here;

    for (const [dc, dr] of STEPS) {

      const nc = f.col + dc;

      const nr = f.row + dr;

      if (nc < 0 || nc >= cols || nr < 0 || nr >= rows) continue;

      const d = dist[nr * cols + nc] ?? -1;

      if (d !== -1 && d < bestD) {

        bestD = d;

        best = centreOf(nc, nr);

      }

    }

    // Straight to the goal when nothing stands in the way — smoother than

    // walking tile centre to tile centre down an open corridor.

    if (best && !wallBetween(from, to) && (walkDistance(from, to) ?? 99) < 6) return to;

    return best ?? to;

  }

  return {

    lines,

    cols,

    rows,

    tile,

    width: cols * tile,

    height: rows * tile,

    at,

    solidTile,

    tileOf,

    centreOf,

    solidAt,

    cellAt,

    cellsOf,

    moveCircle,

    blockedCircle,

    wallBetween,

    rayHitWall,

    walkDistance,

    pathStep,

    clearPaths,

    fieldsBuilt,

  };

}