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

/**

 * The wall batching, as arithmetic: columns in, runs out. What matters is

 * that the runs say the same thing the columns did — every column covered

 * exactly once, in order — while there are far fewer of them.

 */

import { expect, test } from "bun:test";

import { covered, GEOM, hazeStep, makeColumns, SKY, wallRuns } from "../../static/engine/slices.js";

type Col = { level: number; side?: number; top?: number; high?: number; haze?: number };

/** Columns from a list, so a case reads as the picture it describes. */

function columns(list: Col[]) {

  const cols = makeColumns(list.length);

  list.forEach((c, i) => {

    cols.level[i] = c.level;

    cols.side[i] = c.side ?? 0;

    cols.top[i] = c.top ?? 100;

    cols.high[i] = c.high ?? 200;

    cols.haze[i] = c.haze ?? 0;

  });

  return cols;

}

const flat = (n: number, over: Col = { level: 7 }) => columns(Array.from({ length: n }, () => over));

test("a run of equal levels is one rectangle, however long it is", () => {

  const out: never[] = [];

  const used = wallRuns(flat(1280), out);

  expect(used).toBe(1);

  expect(out[0]).toMatchObject({ from: 0, to: 1279, level: 7 });

});

test("the picture's column count is unchanged: every column covered once", () => {

  const cols = columns([

    { level: 3 },

    { level: 3 },

    { level: 4 },

    { level: 4 },

    { level: 4 },

    { level: 9, side: 1 },

  ]);

  const out: { from: number; to: number }[] = [];

  const used = wallRuns(cols, out);

  expect(used).toBe(3);

  expect(covered(out, used)).toBe(6);

  // In order, end to end, no gaps and no overlap.

  expect(out.slice(0, used).map((r) => [r.from, r.to])).toEqual([

    [0, 1],

    [2, 4],

    [5, 5],

  ]);

});

test("each column its own level is one rectangle each: no picture is lost", () => {

  const cols = columns(Array.from({ length: 40 }, (_, i) => ({ level: i })));

  const out: never[] = [];

  const used = wallRuns(cols, out);

  expect(used).toBe(40);

  expect(covered(out, used)).toBe(40);

});

test("the same level on a different face is a different run", () => {

  const cols = columns([{ level: 5, side: 0 }, { level: 5, side: 1 }, { level: 5, side: 1 }]);

  const out: { side: number }[] = [];

  const used = wallRuns(cols, out);

  expect(used).toBe(2);

  expect(out[1]!.side).toBe(1);

});

test("sky ends a run and is covered by nothing", () => {

  const cols = columns([{ level: 2 }, { level: SKY }, { level: 2 }, { level: 2 }]);

  const out: { from: number; to: number }[] = [];

  const used = wallRuns(cols, out);

  expect(used).toBe(2);

  expect(covered(out, used)).toBe(3);

  expect(out[1]).toMatchObject({ from: 2, to: 3 });

});

test("slices that differ in height by more than half a pixel do not merge", () => {

  const near = columns([

    { level: 6, top: 100, high: 200 },

    { level: 6, top: 100 + GEOM / 2, high: 200 },

  ]);

  const far = columns([

    { level: 6, top: 100, high: 200 },

    { level: 6, top: 100, high: 200 + GEOM * 4 },

  ]);

  expect(wallRuns(near, [])).toBe(1);

  expect(wallRuns(far, [])).toBe(2);

});

test("haze joins the run's identity, quantised, so fog is batched too", () => {

  expect(hazeStep(0)).toBe(0);

  expect(hazeStep(1)).toBe(16);

  expect(hazeStep(2)).toBe(16); // clamped: nothing is fogged past opaque

  const cols = columns([

    { level: 6, haze: 0.5 },

    { level: 6, haze: 0.51 }, // the same step: one rectangle

    { level: 6, haze: 0.9 },

  ]);

  const out: { haze: number }[] = [];

  const used = wallRuns(cols, out);

  expect(used).toBe(2);

  expect(out[0]!.haze).toBeCloseTo(0.5, 5);

});

test("the run buffer is reused: a smaller frame allocates nothing new", () => {

  const out: unknown[] = [];

  wallRuns(columns(Array.from({ length: 30 }, (_, i) => ({ level: i }))), out);

  const grown = out.length;

  expect(grown).toBe(30);

  const used = wallRuns(flat(30), out);

  expect(used).toBe(1);

  expect(out.length).toBe(grown);

});