@johnmorrisdotca/kyogijo-stadiums 0.5.0 → 0.6.1

package/dist/budo/dojo.d.ts

@@ -0,0 +1,72 @@
+import type { DojoFigures } from "../leagues/budo.ts";
+import { type MBox, type MMark, type Parts } from "./parts.ts";
+import { type MatSize, type Piece } from "./tatami.ts";
+import type { Compass, DojoEra, DojoPattern, DojoSpec, Side4 } from "./types.ts";
+/** The usual sizes of a room counted in jō, in the mats' widths across and along: 8 jō is 4 by 4 widths (3.64 m square of Chūkyōma mats), 20 jō 5 by 8. */
+export declare const DOJO_SIZES: Readonly<Record<number, readonly [number, number]>>;
+/** The mats' widths across and along of a floor of `jo` mats: the usual shape where there is one, else the whole-number shape nearest to 1 to 1.6. @throws RangeError for a count that is not a whole number of 2 or more. */
+export declare function shapeOfJo(jo: number): [number, number];
+/** The floor's size in metres from the options: its width (across, x) and its length (along, y). */
+export declare function floorOf(spec: DojoSpec, mat: MatSize): {
+    width: number;
+    length: number;
+};
+/** The compass side a name means: north is the top of the drawing. @throws Error for a name that is not a side. */
+export declare function compassOf(side: Side4 | undefined, fallback: Compass): Compass;
+/** What a dojo is: its floor, its mats, its walls and what is in them. */
+export interface DojoLayout {
+    parts: Parts;
+    floor: MBox;
+    /** The floor and the walls round it. */
+    extent: MBox;
+    width: number;
+    length: number;
+    mat: MatSize;
+    pattern: DojoPattern;
+    pieces: Piece[];
+    /** The mats counted as whole ones (a half mat is a half): the area in jō. */
+    jo: number;
+    counts: {
+        full: number;
+        half: number;
+        cut: number;
+    };
+    kamiza: Compass;
+    wall: number;
+    /** The floor and the wood surround round it: the room inside the walls. */
+    room: MBox;
+    /** The width of the wood surround, 0 for none. */
+    surround: number;
+    entrances: {
+        wall: Compass;
+        box: MBox;
+    }[];
+    windows: {
+        wall: Compass;
+        box: MBox;
+    }[];
+    shrine: MBox | undefined;
+    /** The contest areas laid on the floor. */
+    contests: MBox[];
+    /** The raised platform of the seat of honour, and the banner on its wall. */
+    dais: MBox | undefined;
+    banner: MBox | undefined;
+    /** The era of the floor, where it has them. */
+    era: DojoEra | undefined;
+    marks: MMark[];
+}
+/** The league of mats a spec asks for. */
+export declare function dojoLeague(standard: string | undefined): DojoFigures;
+/**
+ * The era a spec asks for, and the spec as it was then: the era's look, colours, pattern, contest areas and outline laid over the spec's own. `era` picks an era by name, `year` the first whose
+ * years hold it (an era with an unknown year, `null`, never holds one), and with neither the last era, the floor as it is now. A spec without eras is its own era.
+ * @throws Error for an `era` that no era is named, RangeError for a `year` no era holds.
+ */
+export declare function resolveEra(spec: DojoSpec | undefined): {
+    spec: DojoSpec;
+    era: DojoEra | undefined;
+};
+/** The dojo's spec as drawn: the era's changes laid over it. */
+export declare const dojoSpecOf: (spec: DojoSpec | undefined) => DojoSpec;
+/** The plan of the dojo a spec asks for. */
+export declare function dojoLayout(asked: DojoSpec, league: DojoFigures): DojoLayout;

package/dist/budo/dojo.js

@@ -0,0 +1,300 @@
+import { DOJO_LEAGUES } from "../leagues/budo.js";
+import { boxD, rectArea } from "./kit.js";
+import { emptyParts, grow } from "./parts.js";
+import { checker, heri, lay, matCount, seams, tatamiAreas, tint } from "./tatami.js";
+/** The usual sizes of a room counted in jō, in the mats' widths across and along: 8 jō is 4 by 4 widths (3.64 m square of Chūkyōma mats), 20 jō 5 by 8. */
+export const DOJO_SIZES = Object.freeze({ 8: [4, 4], 12: [4, 6], 20: [5, 8], 50: [10, 10], 100: [10, 20], 200: [20, 20] });
+/** The mats' widths across and along of a floor of `jo` mats: the usual shape where there is one, else the whole-number shape nearest to 1 to 1.6. @throws RangeError for a count that is not a whole number of 2 or more. */
+export function shapeOfJo(jo) {
+    if (!Number.isInteger(jo) || jo < 2 || jo > 1000)
+        throw new RangeError("The area of a dojo is a whole number of jō, 2 to 1000");
+    const known = DOJO_SIZES[jo];
+    if (known !== undefined)
+        return [known[0], known[1]];
+    const units = jo * 2;
+    let best = [1, units];
+    let score = Infinity;
+    for (let a = 1; a * a <= units; a += 1) {
+        if (units % a !== 0)
+            continue;
+        const b = units / a;
+        const s = Math.abs(Math.log(b / a / 1.6));
+        if (s < score) {
+            score = s;
+            best = [a, b];
+        }
+    }
+    return best;
+}
+/** The floor's size in metres from the options: its width (across, x) and its length (along, y). */
+export function floorOf(spec, mat) {
+    const size = spec.mats ?? spec.jo ?? 20;
+    const fromJo = (jo) => {
+        const [a, b] = shapeOfJo(jo);
+        return { width: a * mat.width, length: b * mat.width };
+    };
+    if (typeof size === "number")
+        return fromJo(size);
+    if (Array.isArray(size)) {
+        const [across, along] = size;
+        for (const n of [across, along])
+            if (!Number.isInteger(n) || n < 1 || n > 60)
+                throw new RangeError("dojo.mats is [across, along]: whole numbers of mats, 1 to 60");
+        return { width: across * mat.width, length: along * mat.length };
+    }
+    const o = size;
+    if (o.jo !== undefined)
+        return fromJo(o.jo);
+    const unit = o.unit ?? "m";
+    if (unit === "jo")
+        return fromJo(o.width ?? o.length ?? 20);
+    const w = o.width;
+    const l = o.length;
+    if (typeof w !== "number" || typeof l !== "number" || !(w > 0) || !(l > 0) || !Number.isFinite(w) || !Number.isFinite(l))
+        throw new RangeError("dojo.mats is { width, length, unit } with a width and a length above 0");
+    if (unit === "mat")
+        return { width: w * mat.width, length: l * mat.length };
+    const k = unit === "ft" ? 0.3048 : 1;
+    if (unit !== "m" && unit !== "ft")
+        throw new RangeError('dojo.mats.unit is "m", "ft", "mat" or "jo"');
+    return { width: w * k, length: l * k };
+}
+/** The compass side a name means: north is the top of the drawing. @throws Error for a name that is not a side. */
+export function compassOf(side, fallback) {
+    if (side === undefined)
+        return fallback;
+    const map = { north: "north", south: "south", east: "east", west: "west", top: "north", bottom: "south", left: "west", right: "east" };
+    const found = map[String(side)];
+    if (found === undefined)
+        throw new Error(`Unknown side "${String(side)}": use north, south, east or west (or top, bottom, left or right)`);
+    return found;
+}
+const OPPOSITE = { north: "south", south: "north", east: "west", west: "east" };
+/** The league of mats a spec asks for. */
+export function dojoLeague(standard) {
+    const id = standard ?? "chukyoma";
+    const found = DOJO_LEAGUES.find((l) => l.id === id);
+    if (found === undefined)
+        throw new Error(`Unknown mat standard "${id}": use one of ${DOJO_LEAGUES.map((l) => l.id).join(", ")}`);
+    return found.dimensions;
+}
+const along = (wall, box, at, width, depth) => wall === "north" ? { x0: box.x0 + at - width / 2, y0: box.y0 - depth, x1: box.x0 + at + width / 2, y1: box.y0 } : wall === "south" ? { x0: box.x0 + at - width / 2, y0: box.y1, x1: box.x0 + at + width / 2, y1: box.y1 + depth } : wall === "west" ? { x0: box.x0 - depth, y0: box.y0 + at - width / 2, x1: box.x0, y1: box.y0 + at + width / 2 } : { x0: box.x1, y0: box.y0 + at - width / 2, x1: box.x1 + depth, y1: box.y0 + at + width / 2 };
+/** The length of a wall of the floor, and the distance along it a thing at `at` (0 to 1) stands, held so that it keeps clear of the corners. */
+function place(wall, box, at, width) {
+    const len = wall === "north" || wall === "south" ? box.x1 - box.x0 : box.y1 - box.y0;
+    const w = Math.min(width, len * 0.8);
+    const t = typeof at === "number" && Number.isFinite(at) ? Math.min(1, Math.max(0, at)) : 0.5;
+    return { at: Math.min(len - w / 2 - 0.1, Math.max(w / 2 + 0.1, t * len)), width: w };
+}
+/**
+ * The era a spec asks for, and the spec as it was then: the era's look, colours, pattern, contest areas and outline laid over the spec's own. `era` picks an era by name, `year` the first whose
+ * years hold it (an era with an unknown year, `null`, never holds one), and with neither the last era, the floor as it is now. A spec without eras is its own era.
+ * @throws Error for an `era` that no era is named, RangeError for a `year` no era holds.
+ */
+export function resolveEra(spec) {
+    const s = spec ?? {};
+    const eras = s.eras;
+    if (eras === undefined || eras.length === 0)
+        return { spec: s, era: undefined };
+    let era;
+    if (s.era !== undefined) {
+        era = eras.find((e) => e.name === s.era);
+        if (era === undefined)
+            throw new Error(`Unknown era "${String(s.era)}": use one of ${eras.map((e) => e.name).join(", ")}`);
+    }
+    else if (s.year !== undefined) {
+        if (typeof s.year !== "number" || !Number.isFinite(s.year))
+            throw new RangeError("dojo.year is a year");
+        const year = s.year;
+        era = eras.find((e) => typeof e.from === "number" && year >= e.from && (typeof e.to !== "number" || year <= e.to));
+        if (era === undefined)
+            throw new RangeError(`No era of this dojo holds the year ${year}: ${eras.map((e) => `${e.name} (${e.from ?? "?"} to ${e.to ?? "?"})`).join(", ")}`);
+    }
+    else {
+        era = eras[eras.length - 1];
+    }
+    const without = (o, keys) => Object.fromEntries(Object.entries(o).filter(([k, v]) => !keys.includes(k) && v !== undefined));
+    const colours = era.colours;
+    const merged = { ...without(s, ["eras", "era", "year"]), ...without(era, ["name", "nameJa", "from", "to", "colours"]) };
+    const own = s.colours ?? s.colors;
+    if (colours !== undefined || own !== undefined)
+        merged.colours = { ...own, ...colours };
+    delete merged.colors;
+    return { spec: merged, era };
+}
+/** The dojo's spec as drawn: the era's changes laid over it. */
+export const dojoSpecOf = (spec) => resolveEra(spec).spec;
+/** The plan of the dojo a spec asks for. */
+export function dojoLayout(asked, league) {
+    const spec = dojoSpecOf(asked);
+    const mat = league.mat;
+    const dims = floorOf(spec, mat);
+    // The floor lies wide, as every surface does: its longer side is x, and the mats run along it.
+    const width = Math.max(dims.width, dims.length);
+    const length = Math.min(dims.width, dims.length);
+    const pattern = spec.pattern ?? "traditional";
+    if (pattern !== "traditional" && pattern !== "competition" && pattern !== "checker" && pattern !== "border")
+        throw new Error(`Unknown pattern "${String(pattern)}": use traditional, competition, checker or border`);
+    const floor = { x0: 0, y0: 0, x1: width, y1: length };
+    const alongAxis = "x";
+    const kamiza = compassOf(spec.kamiza, "north");
+    const wallsOn = spec.walls !== false;
+    const wall = wallsOn ? (typeof spec.walls === "object" && spec.walls !== null && typeof spec.walls.thickness === "number" && spec.walls.thickness > 0 ? spec.walls.thickness : 0.3) : 0;
+    const parts = emptyParts();
+    const raw = lay(floor, mat, alongAxis, pattern !== "checker");
+    // Contest areas laid on the floor: squares of 8 m, centred along the longer side and 4 m apart, the mats inside them the first colour and the rest the second.
+    const contests = [];
+    const grid = spec.areas === undefined ? undefined : typeof spec.areas === "number" ? { across: spec.areas, down: 1 } : spec.areas;
+    const a = spec.areaSize === undefined ? 8 : spec.areaSize;
+    if (typeof a !== "number" || !Number.isFinite(a) || a < 8 || a > 10)
+        throw new RangeError("dojo.areaSize is 8 m to 10 m (the IJF's contest area)");
+    if (grid !== undefined && !(grid.across === 0 && grid.down === 0)) {
+        for (const k of [grid.across, grid.down])
+            if (!Number.isInteger(k) || k < 1 || k > 6)
+                throw new RangeError("dojo.areas is a whole number of 1 to 6, or { across, down } of whole numbers of 1 to 6");
+        const gap = 4;
+        const margin = 3;
+        const runX = grid.across * a + (grid.across - 1) * gap;
+        const runY = grid.down * a + (grid.down - 1) * gap;
+        const needX = runX + 2 * margin;
+        const needY = runY + 2 * margin;
+        if (width < needX - 1e-9 || length < needY - 1e-9)
+            throw new RangeError(`A floor of ${Math.round(width * 100) / 100} m by ${Math.round(length * 100) / 100} m is too small for ${grid.across * grid.down} contest area${grid.across * grid.down === 1 ? "" : "s"}: it needs ${needX} m by ${needY} m`);
+        for (let j = 0; j < grid.down; j += 1) {
+            for (let i = 0; i < grid.across; i += 1) {
+                const x0 = (width - runX) / 2 + i * (a + gap);
+                const y0 = (length - runY) / 2 + j * (a + gap);
+                contests.push({ x0, y0, x1: x0 + a, y1: y0 + a });
+            }
+        }
+    }
+    // The tones: the contest areas laid on the floor are the first, the rest of the floor the second; a border puts a band of the third round the floor (and the floor inside it is the first, or the second when contest areas lie on it).
+    let pieces;
+    // An outline puts a band one mat wide in the third colour round the inside of each contest area.
+    const zones = spec.outline === true && contests.length > 0 ? [...contests.map((b) => ({ box: grow(b, -mat.width), tone: 1 })), ...contests.map((b) => ({ box: b, tone: 3 }))] : contests.map((b) => ({ box: b, tone: 1 }));
+    let rest = contests.length > 0 ? 2 : 1;
+    if (pattern === "border") {
+        zones.push({ box: grow(floor, -mat.width), tone: contests.length > 0 ? 2 : 1 });
+        rest = 3;
+    }
+    else if (pattern === "competition" && contests.length === 0) {
+        // A floor in the colours of a contest area: a safety area of up to 3 m round the first colour.
+        const m = Math.min(3, Math.max(mat.width, Math.min(width, length) * 0.2));
+        if (Math.min(width, length) > 2 * m + mat.width) {
+            zones.push({ box: grow(floor, -m), tone: 1 });
+            rest = 2;
+        }
+    }
+    if (pattern === "checker" && contests.length === 0)
+        pieces = checker(raw, floor, mat);
+    else
+        pieces = zones.length > 0 || rest !== 1 ? tint(raw, zones, rest, mat) : raw;
+    const named = { 1: "mats", 2: "mats-alt", 3: "border" };
+    parts.areas.push(...tatamiAreas("mats", pieces, { 1: "ky-bud-t1", 2: "ky-bud-t2", 3: "ky-bud-t3" }, named));
+    parts.shapes.push(...seams("mats", pieces, 0.02));
+    if (pattern === "traditional" || pattern === "border")
+        parts.areas.push(...heri("mats", pieces, Math.min(0.05, mat.width * 0.06), mat));
+    // The walls: a band of the thickness round the floor; the doors and the windows are cut in it.
+    const entrances = [];
+    const windows = [];
+    const marks = [];
+    const surround = spec.surround === undefined ? 0 : spec.surround;
+    if (typeof surround !== "number" || !Number.isFinite(surround) || surround < 0 || surround > 5)
+        throw new RangeError("dojo.surround is the wood round the mats, 0 m to 5 m");
+    const room = grow(floor, surround);
+    const frame = grow(room, wall);
+    if (surround > 0)
+        parts.areas.unshift({ id: "surround", feature: "floor", cls: "ky-bud-floor", d: `${boxD(room)}${boxD(floor)}`, evenodd: true });
+    if (wallsOn) {
+        parts.areas.push({ id: "walls", feature: "walls", cls: "ky-bud-wall", d: `${boxD(frame)}${boxD(room)}`, evenodd: true });
+        const doors = spec.entrances ?? [{ wall: OPPOSITE[kamiza] }];
+        doors.forEach((e, i) => {
+            const w = compassOf(e.wall, OPPOSITE[kamiza]);
+            const p = place(w, room, e.at, e.width ?? 1.8);
+            const b = along(w, room, p.at, p.width, wall);
+            entrances.push({ wall: w, box: b });
+            parts.areas.push(rectArea(`door-${i + 1}`, "doors", "ky-bud-door", b));
+        });
+        const windowList = windowsOf(spec.windows, floor);
+        windowList.forEach((e, i) => {
+            const w = compassOf(e.wall, "east");
+            const p = place(w, room, e.at, e.width ?? 1.8);
+            const b = along(w, room, p.at, p.width, wall);
+            const mid = wall / 2;
+            const thin = w === "north" || w === "south" ? { x0: b.x0, y0: b.y0 + mid * 0.7, x1: b.x1, y1: b.y1 - mid * 0.7 } : { x0: b.x0 + mid * 0.7, y0: b.y0, x1: b.x1 - mid * 0.7, y1: b.y1 };
+            windows.push({ wall: w, box: thin });
+            parts.areas.push(rectArea(`window-${i + 1}`, "windows", "ky-bud-window", thin));
+        });
+    }
+    // The dais: the seat of honour's platform, against the middle of the kamiza wall, 1.5 m deep (ours: no source gives its size) and a third of the wall wide, up to 5 m.
+    let dais;
+    if (spec.dais === true) {
+        const w = Math.min(5, (kamiza === "north" || kamiza === "south" ? width : length) * 0.34);
+        const p = place(kamiza, room, 0.5, w);
+        const d = Math.min(1.5, (kamiza === "north" || kamiza === "south" ? length : width) * 0.2);
+        const edge = along(kamiza, room, p.at, w, d);
+        dais = kamiza === "north" ? { ...edge, y0: room.y0, y1: room.y0 + d } : kamiza === "south" ? { ...edge, y0: room.y1 - d, y1: room.y1 } : kamiza === "west" ? { ...edge, x0: room.x0, x1: room.x0 + d } : { ...edge, x0: room.x1 - d, x1: room.x1 };
+        parts.areas.push(rectArea("dais", "dais", "ky-bud-dais", dais));
+    }
+    // The banner: a plain dark band 0.9 m wide on the kamiza wall, in the wall's thickness, over the dais or the shrine.
+    let banner;
+    if (spec.banner === true && wallsOn) {
+        const p = place(kamiza, room, 0.5, 0.9);
+        banner = along(kamiza, room, p.at, 0.9, wall * 0.7);
+        parts.areas.push(rectArea("banner", "banner", "ky-bud-banner", banner));
+    }
+    // The shinzen (神前): the shrine at the middle of the kamiza wall, on the floor against it.
+    let shrine;
+    if (spec.shinzen === true) {
+        const w = Math.min(1.8, (kamiza === "north" || kamiza === "south" ? width : length) * 0.3);
+        const p = place(kamiza, room, 0.5, w);
+        const d = 0.35;
+        const edge = along(kamiza, room, p.at, w, d);
+        shrine = kamiza === "north" ? { ...edge, y0: room.y0, y1: room.y0 + d } : kamiza === "south" ? { ...edge, y0: room.y1 - d, y1: room.y1 } : kamiza === "west" ? { ...edge, x0: room.x0, x1: room.x0 + d } : { ...edge, x0: room.x1 - d, x1: room.x1 };
+        parts.areas.push(rectArea("shinzen", "shrine", "ky-bud-shrine", shrine));
+    }
+    const cx = width / 2;
+    const cy = length / 2;
+    const inset = (c) => (c === "north" ? { x: cx, y: Math.min(1.2, length * 0.1) } : c === "south" ? { x: cx, y: length - Math.min(1.2, length * 0.1) } : c === "west" ? { x: Math.min(1.2, width * 0.1), y: cy } : { x: width - Math.min(1.2, width * 0.1), y: cy });
+    const k = inset(kamiza);
+    const s = inset(OPPOSITE[kamiza]);
+    marks.push({ id: "kamiza", x: k.x, y: k.y, side: kamiza === "south" ? "bottom" : "top" });
+    marks.push({ id: "shimoza", x: s.x, y: s.y, side: kamiza === "north" ? "bottom" : "top" });
+    if (dais !== undefined)
+        marks.push({ id: "dais", x: (dais.x0 + dais.x1) / 2, y: (dais.y0 + dais.y1) / 2, side: kamiza === "south" ? "bottom" : "top" });
+    if (banner !== undefined)
+        marks.push({ id: "banner", x: (banner.x0 + banner.x1) / 2, y: (banner.y0 + banner.y1) / 2, side: kamiza === "south" ? "bottom" : "top" });
+    if (shrine !== undefined)
+        marks.push({ id: "shinzen", x: (shrine.x0 + shrine.x1) / 2, y: (shrine.y0 + shrine.y1) / 2, side: kamiza === "south" ? "bottom" : "top" });
+    const door = entrances[0];
+    if (door !== undefined)
+        marks.push({ id: "entrance", x: (door.box.x0 + door.box.x1) / 2, y: (door.box.y0 + door.box.y1) / 2, side: door.wall === "north" ? "top" : "bottom" });
+    const win = windows[0];
+    if (win !== undefined)
+        marks.push({ id: "window", x: (win.box.x0 + win.box.x1) / 2, y: (win.box.y0 + win.box.y1) / 2, side: win.wall === "north" ? "top" : "bottom" });
+    if (contests.length > 0)
+        marks.push({ id: "contest-area", x: (contests[0].x0 + contests[0].x1) / 2, y: contests[0].y0 + 1.2, side: "top" });
+    marks.push({ id: "tatami", x: cx, y: cy, side: "bottom" });
+    const edge = pieces.find((p) => p.kind === "full");
+    if (edge !== undefined && (pattern === "traditional" || pattern === "border"))
+        marks.push({ id: "heri", x: (edge.x0 + edge.x1) / 2, y: edge.y0 + 0.02, side: "top" });
+    if (wallsOn)
+        marks.push({ id: "wall", x: cx * 0.4, y: -wall / 2, side: "top" });
+    const counts = { full: pieces.filter((p) => p.kind === "full").length, half: pieces.filter((p) => p.kind === "half").length, cut: pieces.filter((p) => p.kind === "cut").length };
+    return { parts, floor, extent: grow(room, wall + 0.2), width, length, mat, pattern, pieces, jo: Math.round(matCount(pieces, mat) * 100) / 100, counts, kamiza, wall, entrances, windows, room, surround, shrine, contests, dais, banner, era: resolveEra(asked).era, marks };
+}
+/** The windows a spec asks for: the list, or `count` of them spread along the long walls. */
+function windowsOf(w, floor) {
+    if (w === undefined)
+        return [];
+    if (typeof w === "number") {
+        if (!Number.isInteger(w) || w < 0 || w > 24)
+            throw new RangeError("dojo.windows is a list or a whole number of 0 to 24");
+        const long = floor.x1 - floor.x0 >= floor.y1 - floor.y0 ? ["north", "south"] : ["west", "east"];
+        const out = [];
+        for (let i = 0; i < w; i += 1)
+            out.push({ wall: long[i % 2], at: (Math.floor(i / 2) + 1) / (Math.ceil(w / 2) + 1) });
+        return out;
+    }
+    return [...w];
+}

package/dist/budo/judo.d.ts

@@ -0,0 +1,61 @@
+import type { JudoFigures } from "../leagues/budo.ts";
+import { boxD } from "./kit.ts";
+import { type MBox, type MMark, type Parts } from "./parts.ts";
+import { type MatSize, type Piece } from "./tatami.ts";
+import type { BudoStyle } from "./types.ts";
+/** The mats a `tatami` option names. */
+export declare const TATAMI: Readonly<Record<NonNullable<BudoStyle["tatami"]>, MatSize>>;
+/** What a judo plan is laid out from. */
+export interface JudoOptions {
+    fig: JudoFigures;
+    /** The contest area's side, the safety area's width and the number of areas across and down. */
+    contest: number;
+    safety: number;
+    across: number;
+    down: number;
+    mat: MatSize;
+    platform: boolean;
+    officials: boolean;
+    start: boolean;
+    seams: boolean;
+    /** The colours of the tape: the contestant to the referee's right, then to his left (blue and white in the IJF's rules, red and white in the AJJF's). */
+    tape: readonly ["blue" | "red" | "white", "white"];
+}
+/** What a judo plan is. */
+export interface JudoLayout {
+    parts: Parts;
+    /** The tatami (the contest and the safety areas together) and everything that lies beyond it. */
+    tatami: MBox;
+    extent: MBox;
+    /** The contest areas, left to right and top to bottom. */
+    contests: MBox[];
+    /** The distance between two areas that adjoin. */
+    gap: number;
+    pieces: Piece[];
+    /** The mat the area is laid with. */
+    mat: MatSize;
+    marks: MMark[];
+    /** The width of the red band of a danger zone, or 0. */
+    danger: number;
+}
+/** The mats of a `tatami` option, or the league's own when none. @throws Error for a name that is not a size of mat. */
+export declare function matOf(asked: BudoStyle["tatami"], fig: JudoFigures): MatSize;
+/**
+ * A size made a whole number of mats' widths, for mats that do not divide the rule's metres (the AJJF's 91 cm): the next whole number of mats up, so that a least the rules give is kept, or the last that
+ * is within the greatest. 8 m of 91 cm mats is 9 mats, 8.19 m; 3 m is 4 mats, 3.64 m (two ken, as the AJJF's guidebook has it).
+ */
+export declare function snapTo(size: number, width: number, least: number, greatest: number): number;
+/** The areas across and down that the options ask for. @throws RangeError for a number outside 1 to 6. */
+export declare function gridOf(areas: BudoStyle["areas"]): {
+    across: number;
+    down: number;
+};
+/** The size of a contest area the options ask for, held to what the rules allow. */
+export declare const contestOf: (asked: number | undefined, fig: JudoFigures) => number;
+/** The width of the safety area the options ask for. */
+export declare const safetyOf: (asked: number | undefined, fig: JudoFigures) => number;
+/** The plan of the competition area the options ask for. */
+export declare function judoParts(o: JudoOptions): JudoLayout;
+/** The number of mats of the competition area: a half mat counts a half. */
+export declare const mats: (layout: JudoLayout, mat: MatSize) => number;
+export { boxD };

package/dist/budo/judo.js

@@ -0,0 +1,109 @@
+import { boxD, rectArea, tapeBar, within } from "./kit.js";
+import { emptyParts, grow, union } from "./parts.js";
+import { lay, matCount, seams, tatamiAreas, tint } from "./tatami.js";
+/** The mats a `tatami` option names. */
+export const TATAMI = Object.freeze({ "2x1": { length: 2, width: 1 }, "1x1": { length: 1, width: 1 }, "182x91": { length: 1.82, width: 0.91 } });
+/** The mats of a `tatami` option, or the league's own when none. @throws Error for a name that is not a size of mat. */
+export function matOf(asked, fig) {
+    if (asked === undefined)
+        return { length: fig.tatami.length, width: fig.tatami.width };
+    const mat = TATAMI[asked];
+    if (mat === undefined)
+        throw new Error(`Unknown tatami "${String(asked)}": use one of ${Object.keys(TATAMI).join(", ")}`);
+    return mat;
+}
+/**
+ * A size made a whole number of mats' widths, for mats that do not divide the rule's metres (the AJJF's 91 cm): the next whole number of mats up, so that a least the rules give is kept, or the last that
+ * is within the greatest. 8 m of 91 cm mats is 9 mats, 8.19 m; 3 m is 4 mats, 3.64 m (two ken, as the AJJF's guidebook has it).
+ */
+export function snapTo(size, width, least, greatest) {
+    if (Math.abs(width - 1) < 1e-9 || Math.abs(Math.round(size / width) * width - size) < 1e-9)
+        return size;
+    const up = Math.ceil(size / width - 1e-9) * width;
+    return up <= greatest + 1e-9 ? up : Math.max(least, Math.floor(size / width + 1e-9) * width);
+}
+/** The areas across and down that the options ask for. @throws RangeError for a number outside 1 to 6. */
+export function gridOf(areas) {
+    const a = areas === undefined ? { across: 1, down: 1 } : typeof areas === "number" ? { across: areas, down: 1 } : areas;
+    for (const n of [a.across, a.down])
+        if (!Number.isInteger(n) || n < 1 || n > 6)
+            throw new RangeError("budo.areas is a whole number of 1 to 6, or { across, down } of whole numbers of 1 to 6");
+    return a;
+}
+/** The size of a contest area the options ask for, held to what the rules allow. */
+export const contestOf = (asked, fig) => (asked === undefined ? fig.contest.drawn : within(asked, fig.contest.min, fig.contest.max, "The contest area", "the IJF's Sport and Organisation Rules (8.7)"));
+/** The width of the safety area the options ask for. */
+export const safetyOf = (asked, fig) => (asked === undefined ? fig.safety.drawn : within(asked, fig.safety.min, fig.safety.max, "The safety area", "the IJF's Sport and Organisation Rules (8.7)"));
+/** The technical table: 3 m by 0.8 m (ours: the rules give no size), centred on its contest area and set well outside the free zone. */
+const TABLE = { length: 3, depth: 0.8, clear: 1.5 };
+/** The plan of the competition area the options ask for. */
+export function judoParts(o) {
+    const { fig, contest: c, safety: s, across, down, mat } = o;
+    const gap = Math.max(fig.common, s);
+    const width = across * c + (across - 1) * gap + 2 * s;
+    const height = down * c + (down - 1) * gap + 2 * s;
+    const tatami = { x0: 0, y0: 0, x1: width, y1: height };
+    const contests = [];
+    for (let j = 0; j < down; j += 1)
+        for (let i = 0; i < across; i += 1)
+            contests.push({ x0: s + i * (c + gap), y0: s + j * (c + gap), x1: s + i * (c + gap) + c, y1: s + j * (c + gap) + c });
+    const band = fig.danger ? mat.width : 0;
+    const parts = emptyParts();
+    // The free zone and the platform lie under the tatami: the platform one metre wider and longer than it, the free zone 50 cm beyond whichever is the larger.
+    const platform = o.platform ? grow(tatami, fig.platform) : undefined;
+    const free = grow(platform ?? tatami, fig.freeZone);
+    parts.areas.push(rectArea("free-zone", "free-zone", "ky-bud-free", free));
+    if (platform !== undefined)
+        parts.areas.push(rectArea("platform", "platform", "ky-bud-platform", platform));
+    // The mats of the whole competition area, then cut where a colour changes: the contest area inside the safety area, and inside it, for the domestic rules, the red band of the danger zone.
+    const zones = [...(band > 0 ? contests.map((b) => ({ box: grow(b, -band), tone: 1 })) : []), ...contests.map((b) => ({ box: b, tone: (band > 0 ? 3 : 1) }))];
+    const pieces = tint(lay(tatami, mat, "x", true), zones, 2, mat);
+    parts.areas.push(...tatamiAreas("tatami", pieces, { 1: "ky-bud-t1", 2: "ky-bud-t2", 3: "ky-bud-t3" }, { 1: "contest-area", 2: "safety-area", 3: "danger-zone" }));
+    if (o.seams)
+        parts.shapes.push(...seams("tatami", pieces, 0.02));
+    const marks = [];
+    // The tape that marks where the contestants start, in the middle of each contest area, across the line between them: the one to the referee's right, who faces the table at the top, is to the east.
+    if (o.start && fig.marks !== null) {
+        contests.forEach((b, k) => {
+            const cx = (b.x0 + b.x1) / 2;
+            const cy = (b.y0 + b.y1) / 2;
+            const m = fig.marks;
+            const at = (x) => ({ x0: x - m.width / 2, y0: cy - m.length / 2, x1: x + m.width / 2, y1: cy + m.length / 2 });
+            parts.shapes.push(tapeBar(`start-${k + 1}-right`, "start-right", `ky-bud-${o.tape[0]}-fill`, at(cx + m.fromCentre)));
+            parts.shapes.push(tapeBar(`start-${k + 1}-left`, "start-left", `ky-bud-${o.tape[1]}-fill`, at(cx - m.fromCentre)));
+        });
+    }
+    // The technical table of each area, outside the free zone, at the top.
+    const desks = [];
+    if (o.officials) {
+        for (const b of contests.filter((_, k) => k < across)) {
+            const cx = (b.x0 + b.x1) / 2;
+            const y1 = free.y0 - TABLE.clear;
+            desks.push({ x0: cx - TABLE.length / 2, y0: y1 - TABLE.depth, x1: cx + TABLE.length / 2, y1 });
+        }
+        desks.forEach((d, k) => parts.areas.push(rectArea(`table-${k + 1}`, "officials", "ky-bud-desk", d)));
+    }
+    const first = contests[0];
+    const fx = (first.x0 + first.x1) / 2;
+    marks.push({ id: "contest-area", x: fx, y: first.y0 + c * 0.3, side: "top" });
+    marks.push({ id: "safety-area", x: fx, y: s / 2, side: "top" });
+    if (band > 0)
+        marks.push({ id: "danger-zone", x: first.x0 + c * 0.22, y: first.y1 - band / 2, side: "bottom" });
+    if (o.start && fig.marks !== null)
+        marks.push({ id: "start-mark", x: fx + fig.marks.fromCentre, y: (first.y0 + first.y1) / 2, side: "bottom" });
+    if (across > 1)
+        marks.push({ id: "common-safe-zone", x: first.x1 + gap / 2, y: (first.y0 + first.y1) / 2, side: "bottom" });
+    marks.push({ id: "free-zone", x: width * 0.12, y: free.y0 + fig.freeZone / 2, side: "top" });
+    // The referee stands at the middle of the tatami, 2 m back from the line the contestants start on, facing the table (Article 9).
+    marks.push({ id: "referee-position", x: fx, y: (first.y0 + first.y1) / 2 + 2, side: "bottom" });
+    marks.push({ id: "tatami", x: first.x0 + 0.5 * c, y: first.y0 + c * 0.7, side: "bottom" });
+    if (platform !== undefined)
+        marks.push({ id: "platform", x: width * 0.88, y: platform.y1 - fig.platform / 2, side: "bottom" });
+    if (desks.length > 0)
+        marks.push({ id: "technical-table", x: (desks[0].x0 + desks[0].x1) / 2, y: desks[0].y0 + TABLE.depth / 2, side: "top" });
+    const extent = union([free, ...desks.map((d) => grow(d, 0.3))]);
+    return { parts, tatami, extent, contests, gap, pieces, mat, marks, danger: band };
+}
+/** The number of mats of the competition area: a half mat counts a half. */
+export const mats = (layout, mat) => Math.round(matCount(layout.pieces, mat) * 100) / 100;
+export { boxD };

package/dist/budo/karate.d.ts

@@ -0,0 +1,29 @@
+import type { KarateFigures } from "../leagues/budo.ts";
+import { type MBox, type MMark, type Parts } from "./parts.ts";
+import { type MatSize, type Piece } from "./tatami.ts";
+/** The mat of a karate area: 1 m by 1 m, a WKF-approved mat's size (ours: the rules do not give it). */
+export declare const KARATE_MAT: MatSize;
+/** What a karate plan is laid out from. */
+export interface KarateOptions {
+    fig: KarateFigures;
+    across: number;
+    down: number;
+    officials: boolean;
+    judges: boolean;
+    seams: boolean;
+}
+/** What a karate plan is. */
+export interface KarateLayout {
+    parts: Parts;
+    /** The mats, the competition areas and the safety area together. */
+    mats: MBox;
+    extent: MBox;
+    /** The competition areas (the matted squares of 8 m), left to right and top to bottom, and the inner square of each (without the outer band). */
+    areas: MBox[];
+    inner: MBox[];
+    gap: number;
+    pieces: Piece[];
+    marks: MMark[];
+}
+/** The plan of the karate area the options ask for. */
+export declare function karateParts(o: KarateOptions): KarateLayout;