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

/**

 * The map: one grid, and the geometry everything else asks questions of.

 *

 * Two sites (A left, B right), a mid corridor between the spawns, and a back

 * corridor along the bottom that links A main, spawn and B main — the flank.

 * Tiles are 80 units; a player is a circle of radius 16, so a one-tile

 * corridor is comfortably wide and a wall is never thin enough for a ray to

 * step over.

 *

 * Everything here is a pure function of the grid: collision, line of sight

 * and the walk distance a bot uses to path. No state.

 */

export const TILE = 80;

// '#' wall · '.' floor · 'A'/'B' plant site · 'a' attacker spawn · 'd' defender spawn

const ROWS_SRC = [

  "##############################",

  "#........###.dddd.###........#",

  "#.AAAAA..###.dddd.###..BBBBB.#",

  "#.AAAAA..##........##..BBBBB.#",

  "#.AAAAA..##.#....#.##..BBBBB.#",

  "#.AAAAA..##........##..BBBBB.#",

  "#...##......#....#......##...#",

  "#..####....#......#....####..#",

  "#..####..###......###..####..#",

  "#..####..####....####..####..#",

  "#..####..####.##.####..####..#",

  "#........####.##.####........#",

  "#..####..####....####..####..#",

  "#..####..#####..#####..####..#",

  "#..####..#####..#####..####..#",

  "#..####..###......###..####..#",

  "#........##..aaaa..##........#",

  "#............aaaa............#",

  "##############################",

];

export const COLS = ROWS_SRC[0]!.length;

export const ROWS = ROWS_SRC.length;

export const WIDTH = COLS * TILE;

export const HEIGHT = ROWS * TILE;

export const grid: string[] = ROWS_SRC;

export const gridRows = (): string[] => ROWS_SRC.slice();

export type Site = "A" | "B";

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

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

  row < 0 || row >= ROWS || col < 0 || col >= COLS ? "#" : ROWS_SRC[row]![col]!;

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

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

  col: Math.floor(x / TILE),

  row: Math.floor(y / TILE),

});

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

  x: col * TILE + TILE / 2,

  y: row * TILE + TILE / 2,

});

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

  const t = tileOf(x, y);

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

};

/** The site a point plants on, or null: the spike only arms inside a site. */

export const siteAt = (x: number, y: number): Site | null => {

  const t = tileOf(x, y);

  const c = at(t.col, t.row);

  return c === "A" || c === "B" ? c : null;

};

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;

};

export const spawnCells = (side: "atk" | "def"): Point[] => cellsOf(side === "atk" ? "a" : "d");

export const siteCells = (site: Site): Point[] => cellsOf(site);

export const siteCentre = (site: Site): Point => {

  const cells = siteCells(site);

  const sum = cells.reduce((a, p) => ({ x: a.x + p.x, y: a.y + p.y }), { x: 0, y: 0 });

  return { x: sum.x / cells.length, y: sum.y / cells.length };

};

/** Ult orbs: one on each half of mid, free for whoever walks over them. */

export const orbSpots = (): Point[] => [centreOf(4, 11), centreOf(25, 11)];

/**

 * Slide a circle through the grid: each axis is moved and resolved on its

 * own, so running along a wall slides instead of sticking.

 */

export function moveCircle(x: number, y: number, dx: number, dy: number, r: number): Point {

  let nx = x;

  let ny = y;

  if (dx !== 0) {

    const test = nx + dx;

    if (!blockedCircle(test, ny, r)) nx = test;

    else {

      const col = Math.floor(test / TILE);

      nx = dx > 0 ? col * TILE - r - 0.01 : (col + 1) * TILE + r + 0.01;

      if (blockedCircle(nx, ny, r)) nx = x;

    }

  }

  if (dy !== 0) {

    const test = ny + dy;

    if (!blockedCircle(nx, test, r)) ny = test;

    else {

      const row = Math.floor(test / TILE);

      ny = dy > 0 ? row * TILE - r - 0.01 : (row + 1) * TILE + r + 0.01;

      if (blockedCircle(nx, ny, r)) ny = y;

    }

  }

  return { x: nx, y: ny };

}

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

export function blockedCircle(x: number, y: number, r: number): boolean {

  const c0 = Math.floor((x - r) / TILE);

  const c1 = Math.floor((x + r) / TILE);

  const r0 = Math.floor((y - r) / TILE);

  const r1 = Math.floor((y + r) / TILE);

  for (let row = r0; row <= r1; row++)

    for (let col = c0; col <= c1; col++) {

      if (!solidTile(col, row)) continue;

      const nearX = Math.max(col * TILE, Math.min(x, col * TILE + TILE));

      const nearY = Math.max(row * TILE, Math.min(y, row * TILE + TILE));

      const dx = x - nearX;

      const dy = y - nearY;

      if (dx * dx + dy * dy < r * r) return true;

    }

  return false;

}

/**

 * 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.

 */

export 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. */

export 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 };

}

/** 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;

// 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>();

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

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

  const key = goalRow * COLS + goalCol;

  const cached = fields.get(key);

  if (cached) return cached;

  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 [

        [1, 0],

        [-1, 0],

        [0, 1],

        [0, -1],

      ] as const) {

        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. */

export 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 bots round corners instead

 * of grinding into them.

 */

export 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 [

    [1, 0],

    [-1, 0],

    [0, 1],

    [0, -1],

  ] as const) {

    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;

}