tilt/shared/rink.js

/**
 * Rink geometry.
 *
 * NHL dimensions in metres, kept as plain numbers with no three.js import so
 * the sim, the tests and (later) a server can all agree on where the boards
 * are without pulling in a renderer.
 *
 * The surface is a rounded rectangle: a `halfX` by `halfZ` box with the four
 * corners replaced by quarter circles of radius `cornerR`. Every containment
 * query in the game reduces to "how far outside that shape are you", so it
 * lives here once as `rinkPenetration`.
 */

/** 200ft x 85ft, 28ft corner radius, 42in boards. */
export const RINK = Object.freeze({
  halfX: 30.48, // length/2 — the long axis runs along X
  halfZ: 12.95, // width/2
  cornerR: 8.53,
  boardHeight: 1.07,
  /** Glass above the boards is visual only in this spike. */
  glassHeight: 1.8,
});

/** Blue lines / centre line, as distances from centre ice along X. */
export const MARKINGS = Object.freeze({
  blueLine: 7.77,
  goalLine: 25.6,
  faceoffCircleR: 4.57,
  centreCircleR: 4.57,
  faceoffDotX: 6.7,
  faceoffDotZ: 6.7,
  zoneDotX: 20.2,
});

/**
 * Centre of the corner arc nearest (x, z), and the sign of the quadrant.
 * Points outside the straight sections belong to exactly one corner.
 */
function cornerCentre(x, z, out) {
  const sx = x >= 0 ? 1 : -1;
  const sz = z >= 0 ? 1 : -1;
  out.x = sx * (RINK.halfX - RINK.cornerR);
  out.z = sz * (RINK.halfZ - RINK.cornerR);
  return out;
}

const _c = { x: 0, z: 0 };

/**
 * Signed distance from the rink's inner surface, plus the inward normal.
 *
 * Positive `dist` means the point is outside the playing surface by that much;
 * `nx`/`nz` point back toward the ice. Returns the same object every call, so
 * copy anything you need to keep.
 */
const _pen = { dist: 0, nx: 0, nz: 0 };
export function rinkPenetration(x, z, radius = 0) {
  const ax = Math.abs(x);
  const az = Math.abs(z);
  const straightX = RINK.halfX - RINK.cornerR;
  const straightZ = RINK.halfZ - RINK.cornerR;

  if (ax <= straightX || az <= straightZ) {
    // Straight section: whichever wall is closer wins. A point can only be
    // outside one of them here, since the corners are handled below.
    const overX = ax + radius - RINK.halfX;
    const overZ = az + radius - RINK.halfZ;
    if (overX >= overZ) {
      _pen.dist = overX;
      _pen.nx = x >= 0 ? -1 : 1;
      _pen.nz = 0;
    } else {
      _pen.dist = overZ;
      _pen.nx = 0;
      _pen.nz = z >= 0 ? -1 : 1;
    }
    return _pen;
  }

  cornerCentre(x, z, _c);
  const dx = x - _c.x;
  const dz = z - _c.z;
  const d = Math.hypot(dx, dz) || 1e-6;
  _pen.dist = d + radius - RINK.cornerR;
  _pen.nx = -dx / d;
  _pen.nz = -dz / d;
  return _pen;
}

/** True when a circle of `radius` at (x, z) is fully on the ice. */
export function insideRink(x, z, radius = 0) {
  return rinkPenetration(x, z, radius).dist <= 0;
}

/**
 * Push a body back inside the boards and kill the velocity going into them.
 *
 * Box3D owns board contact for anything with a proxy capsule; this is the
 * headless fallback (tests, and any future server tick without a physics
 * world) and a cheap safety net against a body escaping the world.
 *
 * `restitution` 0 is a dead thud, 1 a perfect bounce. Boards eat most of it.
 */
export function clampToRink(state, radius = 0.36, restitution = 0.18) {
  const pen = rinkPenetration(state.x, state.z, radius);
  if (pen.dist <= 0) return false;
  state.x += pen.nx * pen.dist;
  state.z += pen.nz * pen.dist;
  const into = state.vx * pen.nx + state.vz * pen.nz;
  if (into < 0) {
    // Remove the inward-normal component, then add back a fraction reversed.
    state.vx -= into * pen.nx * (1 + restitution);
    state.vz -= into * pen.nz * (1 + restitution);
  }
  return true;
}

/**
 * The board line as a closed polyline, counter-clockwise from the +X end.
 *
 * The physics boards and the rendered boards are both built from this, so the
 * wall a skater bounces off is the wall they can see. `cornerSteps` is the
 * number of segments each of the four corner arcs is cut into.
 */
export function rinkOutline(cornerSteps = 8) {
  const sx = RINK.halfX - RINK.cornerR;
  const sz = RINK.halfZ - RINK.cornerR;
  const pts = [];
  // Four corners, each an arc swept from its own quadrant, with the straight
  // sections falling out as the gaps between consecutive arcs.
  const corners = [
    { cx: sx, cz: sz, a0: 0 }, //  +X +Z
    { cx: -sx, cz: sz, a0: Math.PI / 2 }, // -X +Z
    { cx: -sx, cz: -sz, a0: Math.PI }, // -X -Z
    { cx: sx, cz: -sz, a0: -Math.PI / 2 }, // +X -Z
  ];
  for (const c of corners) {
    for (let i = 0; i <= cornerSteps; i++) {
      const a = c.a0 + (i / cornerSteps) * (Math.PI / 2);
      pts.push({ x: c.cx + Math.cos(a) * RINK.cornerR, z: c.cz + Math.sin(a) * RINK.cornerR });
    }
  }
  return pts;
}

/**
 * A random point on the ice, inset from the boards.
 * `rand` is any () => [0,1) so callers can keep it seeded.
 */
export function randomIcePoint(rand, inset = 3) {
  for (let i = 0; i < 24; i++) {
    const x = (rand() * 2 - 1) * (RINK.halfX - inset);
    const z = (rand() * 2 - 1) * (RINK.halfZ - inset);
    if (insideRink(x, z, inset)) return { x, z };
  }
  // Rejection sampling in a rounded rect basically never fails, but never
  // hand back an off-ice waypoint if it does.
  return { x: 0, z: 0 };
}