@johnmorrisdotca/kyogijo-stadiums 0.4.0 → 0.6.0

package/dist/budo/dojo.api.d.ts

@@ -0,0 +1,64 @@
+import type { SurfaceOptions } from "../types.ts";
+import type { MBox } from "./parts.ts";
+import type { Piece } from "./tatami.ts";
+import type { Compass, DojoPattern, DojoSpec } from "./types.ts";
+/** One mat of a dojo's floor, or a part of one, in metres from the floor's top left corner. */
+export type Tatami = Piece;
+/** A dojo made from a spec: the floor as data. */
+export interface Dojo {
+    /** The spec it was made from. */
+    spec: DojoSpec;
+    /** The mat standard: a league of the `dojo` sport (`chukyoma`, `kyoma`, `edoma`, `danchima`, `judo-2x1`) and the mat's size in metres. */
+    standard: string;
+    mat: {
+        length: number;
+        width: number;
+    };
+    /** The floor in metres: its width (x, the longer side) and its length (y). */
+    width: number;
+    length: number;
+    /** The floor's area in jō: the area over the area of a mat, a half mat counting a half. */
+    jo: number;
+    /** How many whole mats, half mats (hanjō) and cut pieces the floor holds. */
+    counts: {
+        full: number;
+        half: number;
+        cut: number;
+    };
+    pattern: DojoPattern;
+    /** Every mat, in metres, with the tone it is painted in (1, 2 or 3). */
+    mats: readonly Tatami[];
+    /** The seat of honour's wall, and the doors and windows with where each is. */
+    kamiza: Compass;
+    entrances: readonly {
+        wall: Compass;
+        box: MBox;
+    }[];
+    windows: readonly {
+        wall: Compass;
+        box: MBox;
+    }[];
+    shrine: MBox | undefined;
+    /** The thickness of the walls round the floor, 0 for none. */
+    wall: number;
+    /** The contest areas laid on the floor, in metres. */
+    contests: readonly MBox[];
+    /** The options that draw it: `drawKyogijo(dojo.options)`. */
+    options: SurfaceOptions;
+}
+/**
+ * A dojo (道場): the floor in mats, laid as real tatami units, with the walls, doors, windows, shrine and kamiza. `mats` is the floor: a number is its area in jō (8, 12, 20, 50, 100 and 200 give the usual shapes), `[across, along]`
+ * the whole mats across and along, `{ width, length, unit }` a size in metres, feet, mats or jō; `pattern` is how it is laid (`traditional`: no four corners meet; `competition`, `checker`, `border`).
+ * @example
+ * ```ts
+ * import { dojo } from "@johnmorrisdotca/kyogijo-stadiums/budo";
+ * const d = dojo({ jo: 20 });
+ * console.log(d.jo, d.width.toFixed(2), d.length.toFixed(2), d.counts.full, d.counts.half, d.pattern);
+ * // 20 7.28 4.55 18 4 traditional
+ * ```
+ */
+export declare function dojo(spec?: DojoSpec): Dojo;
+/** Draw a dojo: `drawKyogijo` with the spec as the options' `dojo`, and any other option the caller gives. */
+export declare function drawDojo(spec?: DojoSpec, more?: Partial<SurfaceOptions>): string;
+/** The mat standards a dojo can be laid with. */
+export declare const DOJO_STANDARDS: readonly string[];

package/dist/budo/dojo.api.js

@@ -0,0 +1,46 @@
+// The dojo builder's public face: `dojo(spec)` lays a floor of tatami out as real units and returns it as plain data (every mat, the floor in metres and in jō, where the kamiza, the doors and the windows are),
+// and `drawDojo(spec)` draws it. The same spec always gives the same floor.
+import { drawKyogijo } from "../draw.js";
+import { DOJO_LEAGUES } from "../leagues/budo.js";
+import { dojoLayout, dojoLeague } from "./dojo.js";
+/**
+ * A dojo (道場): the floor in mats, laid as real tatami units, with the walls, doors, windows, shrine and kamiza. `mats` is the floor: a number is its area in jō (8, 12, 20, 50, 100 and 200 give the usual shapes), `[across, along]`
+ * the whole mats across and along, `{ width, length, unit }` a size in metres, feet, mats or jō; `pattern` is how it is laid (`traditional`: no four corners meet; `competition`, `checker`, `border`).
+ * @example
+ * ```ts
+ * import { dojo } from "@johnmorrisdotca/kyogijo-stadiums/budo";
+ * const d = dojo({ jo: 20 });
+ * console.log(d.jo, d.width.toFixed(2), d.length.toFixed(2), d.counts.full, d.counts.half, d.pattern);
+ * // 20 7.28 4.55 18 4 traditional
+ * ```
+ */
+export function dojo(spec = {}) {
+    const standard = spec.standard ?? "chukyoma";
+    const league = dojoLeague(standard);
+    const L = dojoLayout(spec, league);
+    return {
+        spec,
+        standard,
+        mat: { length: L.mat.length, width: L.mat.width },
+        width: L.width,
+        length: L.length,
+        jo: L.jo,
+        counts: L.counts,
+        pattern: L.pattern,
+        mats: L.pieces,
+        kamiza: L.kamiza,
+        entrances: L.entrances,
+        windows: L.windows,
+        shrine: L.shrine,
+        wall: L.wall,
+        contests: L.contests,
+        options: { sport: "dojo", ...(standard === "chukyoma" ? {} : { league: standard }), dojo: spec },
+    };
+}
+/** Draw a dojo: `drawKyogijo` with the spec as the options' `dojo`, and any other option the caller gives. */
+export function drawDojo(spec = {}, more = {}) {
+    const d = dojo(spec);
+    return drawKyogijo({ ...d.options, ...more, sport: "dojo", dojo: spec });
+}
+/** The mat standards a dojo can be laid with. */
+export const DOJO_STANDARDS = DOJO_LEAGUES.map((l) => l.id);

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 };