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

/**

 * How a body moves through a grid of solid tiles: the collision, the slide

 * along a wall, and how fast it goes.

 *

 * One module because two programs have to agree about it. The server owns

 * where everybody is; the browser predicts where *you* are between the

 * snapshots it is sent, and a prediction that resolves a wall differently

 * from the server is a camera that fights the server every tick. Written

 * twice this drifts; written once, the guess lands on the answer.

 *

 * Nothing here knows about the map, the match or a player: the caller says

 * which tiles are solid and how big one is. It is the server's `map.ts` and

 * the browser's `map.json` asking the same question of the same maths.

 */

export type Solid = (col: number, row: number) => boolean;

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

/** The radius of a body on this map, and how fast one runs. */

export const BODY_R = 16;

export const RUN = 250;

/** How near a wall a refused step creeps: halvings of what was refused. */

const CREEP_STEPS = 6;

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

export function circleBlocked(x: number, y: number, r: number, solid: Solid, tile: 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 (!solid(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;

}

/** The largest fraction of a refused step that is still free, by halving. */

function creep(delta: number, free: (v: number) => boolean): number {

  let lo = 0;

  let hi = delta;

  for (let i = 0; i < CREEP_STEPS; i++) {

    const mid = (lo + hi) / 2;

    if (free(mid)) lo = mid;

    else hi = mid;

  }

  return lo;

}

/**

 * Move a circle by (dx,dy), sliding along whatever it runs into.

 *

 * The motion is projected onto the wall it meets — the blocked component is

 * dropped, never snapped to the tile edge. A snap makes a body against a

 * wall alternate between a snapped coordinate and a free one, which is a

 * position that disagrees with the input every other tick; a projection is

 * a fixed point, so a body pressed into a corner stays exactly where it is.

 *

 * Which component survives is decided by the motion (the longer one wins a

 * corner it is clipping), not by an axis resolved first, so walking into a

 * corner ends in one place whichever way the diagonal is written.

 */

export function slideCircle(

  x: number,

  y: number,

  dx: number,

  dy: number,

  r: number,

  solid: Solid,

  tile: number,

): Point {

  if (dx === 0 && dy === 0) return { x, y };

  const free = (px: number, py: number): boolean => !circleBlocked(px, py, r, solid, tile);

  if (free(x + dx, y + dy)) return { x: x + dx, y: y + dy };

  const okX = dx !== 0 && free(x + dx, y);

  const okY = dy !== 0 && free(x, y + dy);

  const longerIsX = Math.abs(dx) >= Math.abs(dy);

  let ax = okX ? dx : 0;

  let ay = okY ? dy : 0;

  // Both axes open but the diagonal shut is a corner being clipped: the

  // longer component goes through whole and the shorter one creeps.

  if (okX && okY) {

    if (longerIsX) ay = 0;

    else ax = 0;

  }

  let nx = x + ax;

  let ny = y + ay;

  // Whatever was refused still creeps as near the wall as it fits, rather

  // than stopping a whole step short of it — a step is a third of a body.

  const creepX = (): void => {

    if (ax === 0 && dx !== 0) nx = x + creep(dx, (v) => free(x + v, ny));

  };

  const creepY = (): void => {

    if (ay === 0 && dy !== 0) ny = y + creep(dy, (v) => free(nx, y + v));

  };

  if (longerIsX) {

    creepX();

    creepY();

  } else {

    creepY();

    creepX();

  }

  return { x: nx, y: ny };

}

/**

 * How fast a body moves, given what is on it. The browser reads the same

 * four facts out of its snapshot that the match reads off a player, so a

 * prediction runs at the speed the server is about to use.

 */

export function moveSpeed(state: { haste?: boolean; slow?: boolean; stopped?: boolean; heavy?: boolean }): number {

  if (state.stopped) return 0;

  let speed = RUN;

  if (state.haste) speed *= 1.35;

  if (state.slow) speed *= 0.55;

  if (state.heavy) speed *= 0.86;

  return speed;

}