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

/**

 * How big the world is drawn, before it is scaled onto the screen.

 *

 * A raycaster does not need device pixels. Every column is a ray marched

 * through the grid, so the cost of the frame is the width of the canvas, and

 * a retina window asks for three thousand of them — 1512 rays and as many

 * fills at every frame, sixty times a second, for a picture made of flat

 * shaded columns that upscales almost invisibly.

 *

 * So the world is drawn into an offscreen canvas of a fixed width and

 * blitted up, and the HUD, the crosshair and the minimap stay on the visible

 * canvas at full resolution, where sharpness actually shows.

 *

 * The ladder is the knob the frame governor turns: one step coarser is one

 * step fewer rays. Nothing here touches what is sent, predicted or

 * simulated — it is a choice of how many columns to draw, out of the window

 * size and a level, and nothing else.

 */

/** Internal widths, finest first. A step is about a fifth of the rays. */

export const WIDTHS = [1280, 1080, 960, 800, 672, 544, 448];

/** The finest level a window of this many CSS pixels across starts at. */

export const startLevel = (cssWidth) => (cssWidth >= 1200 ? 0 : 2);

const clamp = (n, low, high) => (n < low ? low : n > high ? high : n);

/**

 * The size to draw the world at: never wider than the canvas actually has

 * pixels for — upscaling a 448px render onto a 360px phone would be paying

 * for columns nobody can see — and never so small it stops being a picture.

 * The aspect is the canvas's own, so the blit only ever scales.

 */

export function renderSize(deviceWidth, deviceHeight, level) {

  const want = WIDTHS[clamp(level | 0, 0, WIDTHS.length - 1)];

  const width = Math.max(240, Math.min(want, Math.round(deviceWidth) || 240));

  const height = Math.max(

    1,

    Math.round(width * (deviceHeight > 0 && deviceWidth > 0 ? deviceHeight / deviceWidth : 0.6)),

  );

  return { width, height };

}