@johnmorrisdotca/kyogijo-stadiums 0.5.0 → 0.6.0

package/dist/budo/plan.js

@@ -0,0 +1,139 @@
+import { chooseLeague } from "../leagues.js";
+import { BUDO_LEAGUES, DOJO_LEAGUES, JUDO_LEAGUES, KARATE_LEAGUES, KENDO_LEAGUES, KYUDO_LEAGUES, SUMO_LEAGUES } from "../leagues/budo.js";
+import { dojoLayout, dojoLeague, dojoSpecOf } from "./dojo.js";
+import { contestOf, gridOf, judoParts, matOf, safetyOf, snapTo } from "./judo.js";
+import { karateParts } from "./karate.js";
+import { kendoParts, kendoSide } from "./kendo.js";
+import { kyudoParts, shootersOf } from "./kyudo.js";
+import { boxD } from "./kit.js";
+import { emptyParts, grow, union } from "./parts.js";
+import { dohyoHeight, sumoParts } from "./sumo.js";
+import { lookOf } from "./looks.js";
+/** The apothem of the Nippon Budokan's arena, an octagon 55 m across the flats (the Budokan's leaflet). */
+export const BUDOKAN_ARENA = 27.5;
+const isBudoLeague = (l) => typeof l === "object" && l !== null && BUDO_LEAGUES.includes(l);
+/** The sports of the budō family. */
+export const BUDO_SPORTS = Object.freeze(["judo", "karate", "kendo", "sumo", "kyudo", "dojo"]);
+/** True for a sport of the budō family. */
+export const isBudoSport = (sport) => BUDO_SPORTS.includes(sport);
+const OWN = { judo: JUDO_LEAGUES, karate: KARATE_LEAGUES, kendo: KENDO_LEAGUES, sumo: SUMO_LEAGUES, kyudo: KYUDO_LEAGUES, dojo: DOJO_LEAGUES };
+/** The league a set of options asks for: a rulebook's, else the sport's own. */
+export function budoLeague(o) {
+    const sport = o.sport;
+    // `budo.range` names a kyūdōjō's kind, and `dojo.standard` a dojo's mats, where `league` does not.
+    const asked = o.league === undefined || o.league === "" ? (sport === "kyudo" ? o.budo?.range : sport === "dojo" ? dojoSpecOf(o.dojo).standard : undefined) : o.league;
+    if (asked !== undefined && asked !== "") {
+        const found = OWN[sport].find((l) => l.id === asked);
+        if (found === undefined)
+            throw new Error(`Unknown league "${String(asked)}" for "${sport}": use one of ${OWN[sport].map((l) => l.id).join(", ")}`);
+        return found;
+    }
+    const chosen = chooseLeague({ sport: o.sport, league: o.league }).league;
+    return isBudoLeague(chosen) ? chosen : OWN[sport][0];
+}
+/** The width a line is drawn at unless the drawing is at true widths: a little under two thousandths of the surface, so that a line stays in sight in a drawing that holds the whole of it. */
+const drawn = (box) => Math.max(0.05, Math.round((box.x1 - box.x0) * 0.0018 * 100) / 100);
+const halves = (b) => ({ left: { x0: b.x0, y0: b.y0, x1: (b.x0 + b.x1) / 2, y1: b.y1 }, right: { x0: (b.x0 + b.x1) / 2, y0: b.y0, x1: b.x1, y1: b.y1 } });
+/** The octagon of the Budokan's arena as a path, centred on (cx, cy). */
+export function octagonD(cx, cy, a) {
+    const s = a * Math.tan(Math.PI / 8);
+    const pts = [[cx - s, cy - a], [cx + s, cy - a], [cx + a, cy - s], [cx + a, cy + s], [cx + s, cy + a], [cx - s, cy + a], [cx - a, cy + s], [cx - a, cy - s]];
+    return `M${pts.map(([x, y]) => `${Math.round(x * 100) / 100} ${Math.round(y * 100) / 100}`).join("L")}Z`;
+}
+/** True when a point lies inside the Budokan's octagon about (cx, cy). */
+export const inOctagon = (cx, cy, a, x, y) => Math.abs(x - cx) <= a + 1e-9 && Math.abs(y - cy) <= a + 1e-9 && Math.abs(x - cx) + Math.abs(y - cy) <= a * Math.SQRT2 + 1e-9;
+function flag(v, def, label) {
+    if (v === undefined)
+        return def;
+    if (typeof v !== "boolean")
+        throw new TypeError(`${label} is true or false`);
+    return v;
+}
+/** The budō plan the options ask for. */
+export function budoPlan(o) {
+    const sport = o.sport;
+    const league = budoLeague(o);
+    const fig = league.dimensions;
+    const style = o.budo ?? {};
+    const look = lookOf(sport, style.look ?? (sport === "dojo" ? dojoSpecOf(o.dojo).look : undefined));
+    const seams = flag(style.seams, true, "budo.seams");
+    const dspec = sport === "dojo" ? dojoSpecOf(o.dojo) : undefined;
+    // The weave of the mats: asked for by `texture`, and a traditional dojo's by default.
+    const texture = dspec !== undefined ? dspec.texture === "weave" || (dspec.texture === undefined && (dspec.pattern === undefined || dspec.pattern === "traditional" || dspec.pattern === "border")) : sport === "judo" && style.texture === "weave";
+    const base = { sport, league: league.id, figures: fig, look, texture };
+    const finish = (p) => ({ ...base, hall: undefined, ...p, drawnLine: drawn(p.box) });
+    switch (sport) {
+        case "judo": {
+            const f = fig;
+            const mat = matOf(style.tatami, f);
+            const contest = snapTo(contestOf(style.size, f), mat.width, f.contest.min, f.contest.max);
+            const safety = snapTo(safetyOf(style.safety, f), mat.width, f.safety.min, f.safety.max);
+            const { across, down } = gridOf(style.areas);
+            const tape = league.id === "ajjf" ? ["red", "white"] : league.id === "ijf-kata" ? ["white", "white"] : ["blue", "white"];
+            const L = judoParts({ fig: f, contest, safety, across, down, mat, platform: flag(style.platform, false, "budo.platform"), officials: flag(style.officials, false, "budo.officials"), start: flag(style.start, true, "budo.start"), seams, tape });
+            const first = L.contests[0];
+            const lastC = L.contests[L.contests.length - 1];
+            const ranges = { "contest-area": { left: first, right: lastC }, half: halves(L.tatami) };
+            const fm = f.marks;
+            ranges.start = fm === null ? first : { x0: (first.x0 + first.x1) / 2 - fm.fromCentre - 1.5, y0: (first.y0 + first.y1) / 2 - 2, x1: (first.x0 + first.x1) / 2 + fm.fromCentre + 1.5, y1: (first.y0 + first.y1) / 2 + 2 };
+            return withHall(style, finish({ box: L.tatami, extent: L.extent, areas: L.parts.areas, shapes: L.parts.shapes, lineWidth: 0.05, ranges, marks: L.marks, centre: { x: (first.x0 + first.x1) / 2, y: (first.y0 + first.y1) / 2, r: contest / 2 }, judo: L }), "judo");
+        }
+        case "karate": {
+            const f = fig;
+            const { across, down } = gridOf(style.areas);
+            const officials = flag(style.officials, false, "budo.officials");
+            const L = karateParts({ fig: f, across, down, officials, judges: flag(style.judges, true, "budo.judges"), seams });
+            const first = L.areas[0];
+            const lastA = L.areas[L.areas.length - 1];
+            const ranges = { "contest-area": { left: first, right: lastA }, half: halves(L.mats), start: { x0: (first.x0 + first.x1) / 2 - 3, y0: (first.y0 + first.y1) / 2 - 2, x1: (first.x0 + first.x1) / 2 + 3, y1: (first.y0 + first.y1) / 2 + 2 } };
+            return withHall(style, finish({ box: L.mats, extent: L.extent, areas: L.parts.areas, shapes: L.parts.shapes, lineWidth: 0.05, ranges, marks: L.marks, centre: { x: (first.x0 + first.x1) / 2, y: (first.y0 + first.y1) / 2, r: f.area * 0.1 }, karate: L }), "karate");
+        }
+        case "kendo": {
+            const f = fig;
+            const side = kendoSide(style.size, f);
+            const L = kendoParts(f, side, seams);
+            const ranges = { half: halves(L.floor), start: { x0: L.centre[0] - 3, y0: L.centre[1] - 2, x1: L.centre[0] + 3, y1: L.centre[1] + 2 } };
+            return withHall(style, finish({ box: L.floor, extent: L.extent, areas: L.parts.areas, shapes: L.parts.shapes, lineWidth: f.lineWidth.min, ranges, marks: L.marks, centre: { x: L.centre[0], y: L.centre[1], r: side * 0.08 }, kendo: L }), "kendo");
+        }
+        case "sumo": {
+            const f = fig;
+            const L = sumoParts(f, { height: dohyoHeight(style.height, f), tawara: flag(style.tawara, true, "budo.tawara"), tassels: flag(style.tassels, false, "budo.tassels") });
+            const ranges = { ...L.ranges, half: halves(L.platform) };
+            return finish({ box: L.platform, extent: L.extent, areas: L.parts.areas, shapes: L.parts.shapes, lineWidth: f.shikiri.width, ranges, marks: L.marks, centre: { x: L.centre[0], y: L.centre[1], r: L.ring * 0.4 }, sumo: L });
+        }
+        case "kyudo": {
+            const f = fig;
+            const L = kyudoParts(f, { shooters: shootersOf(style.shooters, f), targets: flag(style.targets, true, "budo.targets"), roof: flag(style.roof, true, "budo.roof") });
+            const ranges = { shajo: L.shajo, yamichi: L.yamichi, azuchi: grow(L.azuchi, 0.8) };
+            return finish({ box: L.range, extent: L.extent, areas: L.parts.areas, shapes: L.parts.shapes, lineWidth: 0.05, ranges, marks: L.marks, centre: { x: (L.shajo.x0 + L.shajo.x1) / 2, y: (L.shajo.y0 + L.shajo.y1) / 2, r: 1.5 }, kyudo: L });
+        }
+        default: {
+            const L = dojoLayout(o.dojo ?? {}, dojoLeague(league.id));
+            const f = L.floor;
+            const band = Math.max(1.5, (L.kamiza === "north" || L.kamiza === "south" ? L.length : L.width) * 0.22);
+            const kamiza = L.kamiza === "north" ? { ...f, y1: f.y0 + band } : L.kamiza === "south" ? { ...f, y0: f.y1 - band } : L.kamiza === "west" ? { ...f, x1: f.x0 + band } : { ...f, x0: f.x1 - band };
+            const ranges = { kamiza, half: halves(f) };
+            return finish({ box: f, extent: L.extent, areas: L.parts.areas, shapes: L.parts.shapes, lineWidth: 0.05, ranges, marks: L.marks, centre: { x: L.width / 2, y: L.length / 2, r: Math.min(L.width, L.length) * 0.15 }, dojo: L });
+        }
+    }
+}
+/** The Budokan's arena floor under a surface, when the options ask for it (`budo.hall`): the octagon centred on the surface, which must lie wholly inside it. */
+function withHall(style, p, sport) {
+    const hall = style.hall;
+    if (hall === undefined)
+        return p;
+    if (hall !== "budokan")
+        throw new Error('budo.hall is "budokan"');
+    const cx = (p.box.x0 + p.box.x1) / 2;
+    const cy = (p.box.y0 + p.box.y1) / 2;
+    const a = BUDOKAN_ARENA;
+    const corners = [[p.extent.x0, p.extent.y0], [p.extent.x1, p.extent.y0], [p.extent.x0, p.extent.y1], [p.extent.x1, p.extent.y1]];
+    if (!corners.every(([x, y]) => inOctagon(cx, cy, a, x, y)))
+        throw new RangeError(`The ${sport} surface with everything round it does not fit in the Budokan's arena, an octagon of ${2 * a} m across the flats`);
+    const box = { x0: cx - a, y0: cy - a, x1: cx + a, y1: cy + a };
+    const floor = { id: "arena", feature: "floor", cls: "ky-bud-floor", d: octagonD(cx, cy, a) };
+    const parts = emptyParts();
+    parts.areas.push(floor);
+    return { ...p, hall: "budokan", box, extent: union([box, p.extent]), areas: [...parts.areas, ...p.areas], marks: [{ id: "arena", x: cx - a * 0.55, y: cy - a * 0.8, side: "top" }, ...p.marks], ranges: { ...p.ranges, half: halves(box) } };
+}
+export { boxD };

package/dist/budo/room.d.ts

@@ -0,0 +1,133 @@
+import type { SurfaceOptions } from "../types.ts";
+import type { MBox } from "./parts.ts";
+import type { Compass } from "./types.ts";
+/** Where a figure of the room comes from: a `source` (a rule or a published figure), the `plan` (it follows from the drawn layout) or `ours` (a plausible figure of ours, no source gives it). */
+export type RoomBasis = "source" | "plan" | "ours";
+/** A wall: its centre line, thickness and height. */
+export interface RoomWall {
+    id: string;
+    side: Compass | "octagon";
+    from: readonly [number, number];
+    to: readonly [number, number];
+    thickness: number;
+    height: number | undefined;
+    basis: RoomBasis;
+}
+/** A door or a window cut in a wall: the footprint in the wall, the sill (the height of its bottom) and the head (the height of its top). */
+export interface RoomOpening {
+    id: string;
+    wall: Compass;
+    box: MBox;
+    sill: number;
+    head: number;
+}
+/** A balcony: the strip of floor it covers, its height above the mats, and its rows of seats, from the rail outwards, each higher than the one before. */
+export interface RoomBalcony {
+    side: Compass;
+    box: MBox;
+    /** The height of the balcony's front edge above the mats. */
+    height: number;
+    depth: number;
+    rows: number;
+    rowDepth: number;
+    rowRise: number;
+    /** The height of the rail along the front edge. */
+    rail: number;
+}
+/** The room round a budō surface. */
+export interface DojoRoom {
+    sport: string;
+    unit: "m";
+    /** The surface's box: the mats of a competition area, the floor of a dojo, the dohyō's platform, the range of a kyūdōjō. */
+    floor: MBox;
+    /** The mats: `thickness` is the height of a mat's top above the floor under it, and `edge` how its edge is shaped (a competition mat is covered in vinyl and its edge is rounded), where a competition area's mat stands up at the safety area's outer edge. */
+    mats: {
+        thickness: number;
+        edge: "rounded" | "square";
+        basis: RoomBasis;
+    } | undefined;
+    /** The wood round the mats, between them and the walls. */
+    surround: {
+        outer: MBox;
+        inner: MBox;
+        width: number;
+        material: "wood";
+    } | undefined;
+    walls: RoomWall[];
+    /** The raised platforms: a dojo's seat of honour, the sumo dohyō. */
+    platforms: {
+        id: string;
+        box: MBox;
+        height: number;
+        basis: RoomBasis;
+    }[];
+    /** The banners: a plain dark vertical banner on a wall (no emblem is drawn), `bottom` and `top` its heights. */
+    banners: {
+        id: string;
+        wall: Compass;
+        box: MBox;
+        width: number;
+        bottom: number;
+        top: number;
+        basis: RoomBasis;
+    }[];
+    balconies: RoomBalcony[];
+    doors: RoomOpening[];
+    windows: RoomOpening[];
+    /** The shrine of a dojo (the shinzen), with its height. */
+    shrine: {
+        box: MBox;
+        height: number;
+    } | undefined;
+    /** The Budokan's octagon floor: its centre, apothem and corners, going round. */
+    hall: {
+        id: "budokan";
+        centre: readonly [number, number];
+        apothem: number;
+        corners: readonly (readonly [number, number])[];
+    } | undefined;
+    /** The figures of this room that are ours, and not a source's: the heights of walls and banners, the dais, the balcony. */
+    notes: string[];
+}
+/** The gallery of a dojo for the crowd: where its first row is from the mats, its depth and the heights of its first and last rows, in metres, from the room's balcony data. */
+export interface DojoGallery {
+    offset: number;
+    depth: number;
+    rows: number;
+    height: [number, number];
+}
+/** Our heights, in metres, where no source gives one. */
+export declare const ROOM_HEIGHTS: Readonly<{
+    wall: 3;
+    dais: 0.3;
+    bannerBottom: 1;
+    bannerTop: 3;
+    door: 2;
+    windowSill: 1;
+    windowHead: 2.4;
+    shrine: 1.2;
+    rail: 1;
+    balcony: 4;
+    mat: 0.05;
+    rowRise: 0.4;
+    rowDepth: 0.8;
+    balconyDepth: 2.4;
+    balconyRows: 4;
+}>;
+/**
+ * The room of a budō surface as data: what a 3D view raises. A dojo has its walls (3 m, ours), wood surround, dais, banner, balconies, doors, windows and shrine as its spec asks for them; the other
+ * surfaces have what they have (the mats' thickness, the dohyō's platform at its height, the Budokan's octagon). Heights that no source gives are ours and are listed in `notes`.
+ * @example
+ * ```ts
+ * import { dojoRoom } from "@johnmorrisdotca/kyogijo-stadiums/budo";
+ * const room = dojoRoom({ sport: "dojo", dojo: { jo: 20, dais: true, banner: true } });
+ * console.log(room?.walls.length, room?.platforms[0]?.height, room?.banners.length);
+ * // 4 0.3 1
+ * ```
+ */
+export declare function dojoRoom(o: Pick<SurfaceOptions, "sport" | "league" | "budo" | "dojo" | "range">): DojoRoom | undefined;
+/**
+ * The gallery a dojo's crowd sits in, from the same balcony data as `dojoRoom()`, so that the 2D stands and a 3D view agree: a thin band of 4 rows (ours) close to the walls, just beyond the wood
+ * surround. A dojo that asks for no balcony still has the default one when it has a crowd; `balcony: false` asks for none, and the sport's own stands are drawn. Not a dojo: nothing.
+ */
+export declare function dojoGallery(o: Pick<SurfaceOptions, "sport" | "league" | "budo" | "dojo" | "range">): DojoGallery | undefined;

package/dist/budo/room.js

@@ -0,0 +1,111 @@
+import { dojoSpecOf } from "./dojo.js";
+import { BUDOKAN_ARENA, budoPlan } from "./plan.js";
+/** Our heights, in metres, where no source gives one. */
+export const ROOM_HEIGHTS = Object.freeze({ wall: 3, dais: 0.3, bannerBottom: 1, bannerTop: 3, door: 2, windowSill: 1, windowHead: 2.4, shrine: 1.2, rail: 1, balcony: 4, mat: 0.05, rowRise: 0.4, rowDepth: 0.8, balconyDepth: 2.4, balconyRows: 4 });
+const SIDES = ["north", "east", "south", "west"];
+const COMPASS = { north: "north", south: "south", east: "east", west: "west", top: "north", bottom: "south", left: "west", right: "east" };
+/**
+ * The room of a budō surface as data: what a 3D view raises. A dojo has its walls (3 m, ours), wood surround, dais, banner, balconies, doors, windows and shrine as its spec asks for them; the other
+ * surfaces have what they have (the mats' thickness, the dohyō's platform at its height, the Budokan's octagon). Heights that no source gives are ours and are listed in `notes`.
+ * @example
+ * ```ts
+ * import { dojoRoom } from "@johnmorrisdotca/kyogijo-stadiums/budo";
+ * const room = dojoRoom({ sport: "dojo", dojo: { jo: 20, dais: true, banner: true } });
+ * console.log(room?.walls.length, room?.platforms[0]?.height, room?.banners.length);
+ * // 4 0.3 1
+ * ```
+ */
+export function dojoRoom(o) {
+    if (o.sport !== "judo" && o.sport !== "karate" && o.sport !== "kendo" && o.sport !== "sumo" && o.sport !== "kyudo" && o.sport !== "dojo")
+        return undefined;
+    const plan = budoPlan({ ...o, detail: "full" });
+    const ox = plan.box.x0;
+    const oy = plan.box.y0;
+    const mv = (b) => ({ x0: b.x0 - ox, y0: b.y0 - oy, x1: b.x1 - ox, y1: b.y1 - oy });
+    const floor = mv(plan.box);
+    const notes = [];
+    const room = { sport: o.sport, unit: "m", floor, mats: undefined, surround: undefined, walls: [], platforms: [], banners: [], balconies: [], doors: [], windows: [], shrine: undefined, hall: undefined, notes };
+    if (plan.judo !== undefined) {
+        const fig = plan.figures;
+        room.mats = { thickness: fig.tatami.thickness, edge: "rounded", basis: "source" };
+    }
+    if (plan.dojo !== undefined) {
+        const L = plan.dojo;
+        const spec = dojoSpecOf(o.dojo);
+        room.mats = { thickness: ROOM_HEIGHTS.mat, edge: "square", basis: "ours" };
+        if (L.surround > 0)
+            room.surround = { outer: mv(L.room), inner: mv(L.floor), width: L.surround, material: "wood" };
+        if (L.wall > 0) {
+            const r = mv(L.room);
+            const w = L.wall;
+            const ring = [
+                ["north", [r.x0 - w / 2, r.y0 - w / 2], [r.x1 + w / 2, r.y0 - w / 2]],
+                ["east", [r.x1 + w / 2, r.y0 - w / 2], [r.x1 + w / 2, r.y1 + w / 2]],
+                ["south", [r.x1 + w / 2, r.y1 + w / 2], [r.x0 - w / 2, r.y1 + w / 2]],
+                ["west", [r.x0 - w / 2, r.y1 + w / 2], [r.x0 - w / 2, r.y0 - w / 2]],
+            ];
+            for (const [side, from, to] of ring)
+                room.walls.push({ id: `wall-${side}`, side, from, to, thickness: w, height: ROOM_HEIGHTS.wall, basis: "ours" });
+            notes.push(`The walls are ${ROOM_HEIGHTS.wall} m high (ours).`);
+        }
+        if (L.dais !== undefined) {
+            room.platforms.push({ id: "dais", box: mv(L.dais), height: ROOM_HEIGHTS.dais, basis: "ours" });
+            notes.push(`The dais is ${ROOM_HEIGHTS.dais} m high and 1.5 m deep at most (ours).`);
+        }
+        if (L.banner !== undefined) {
+            room.banners.push({ id: "banner", wall: L.kamiza, box: mv(L.banner), width: L.banner.x1 - L.banner.x0 > L.banner.y1 - L.banner.y0 ? L.banner.x1 - L.banner.x0 : L.banner.y1 - L.banner.y0, bottom: ROOM_HEIGHTS.bannerBottom, top: ROOM_HEIGHTS.bannerTop, basis: "ours" });
+            notes.push("The banner is a plain dark vertical band, from 1 m to 3 m up the wall (ours).");
+        }
+        if (L.shrine !== undefined)
+            room.shrine = { box: mv(L.shrine), height: ROOM_HEIGHTS.shrine };
+        L.entrances.forEach((e, i) => room.doors.push({ id: `door-${i + 1}`, wall: e.wall, box: mv(e.box), sill: 0, head: ROOM_HEIGHTS.door }));
+        L.windows.forEach((e, i) => room.windows.push({ id: `window-${i + 1}`, wall: e.wall, box: mv(e.box), sill: ROOM_HEIGHTS.windowSill, head: ROOM_HEIGHTS.windowHead }));
+        const b = spec.balcony;
+        if (b !== undefined && b !== false) {
+            const own = typeof b === "object" && b !== null ? b : {};
+            const sides = own.sides === undefined ? SIDES : own.sides.map((s) => COMPASS[String(s)]).filter((s) => s !== undefined);
+            const depth = own.depth ?? ROOM_HEIGHTS.balconyDepth;
+            const r = mv(L.room);
+            const outer = { x0: r.x0 - L.wall, y0: r.y0 - L.wall, x1: r.x1 + L.wall, y1: r.y1 + L.wall };
+            for (const side of sides) {
+                const box = side === "north" ? { x0: outer.x0 - depth, y0: outer.y0 - depth, x1: outer.x1 + depth, y1: outer.y0 } : side === "south" ? { x0: outer.x0 - depth, y0: outer.y1, x1: outer.x1 + depth, y1: outer.y1 + depth } : side === "west" ? { x0: outer.x0 - depth, y0: outer.y0, x1: outer.x0, y1: outer.y1 } : { x0: outer.x1, y0: outer.y0, x1: outer.x1 + depth, y1: outer.y1 };
+                const rows = own.rows ?? ROOM_HEIGHTS.balconyRows;
+                room.balconies.push({ side, box, height: own.height ?? ROOM_HEIGHTS.balcony, depth, rows, rowDepth: depth / rows, rowRise: ROOM_HEIGHTS.rowRise, rail: ROOM_HEIGHTS.rail });
+            }
+            notes.push("The balcony's height, depth and rows are ours; where a source gives its seats (the Kodokan's gallery, about 900) the atlas hall says so.");
+        }
+    }
+    if (plan.sumo !== undefined)
+        room.platforms.push({ id: "dohyo", box: floor, height: plan.sumo.height, basis: "source" });
+    if (plan.hall === "budokan") {
+        const cx = (plan.box.x0 + plan.box.x1) / 2 - ox;
+        const cy = (plan.box.y0 + plan.box.y1) / 2 - oy;
+        const a = BUDOKAN_ARENA;
+        const k = a * (Math.SQRT2 - 1);
+        const pts = [[cx - k, cy - a], [cx + k, cy - a], [cx + a, cy - k], [cx + a, cy + k], [cx + k, cy + a], [cx - k, cy + a], [cx - a, cy + k], [cx - a, cy - k]];
+        room.hall = { id: "budokan", centre: [cx, cy], apothem: a, corners: pts };
+        pts.forEach((p, i) => room.walls.push({ id: `arena-${i + 1}`, side: "octagon", from: p, to: pts[(i + 1) % pts.length], thickness: 0, height: undefined, basis: "plan" }));
+        notes.push("The octagon is 55 m across the flats (the Budokan's leaflet); no height of its wall is given.");
+    }
+    if (room.mats !== undefined && plan.judo !== undefined)
+        notes.push("A competition mat's top stands 5 cm above the floor (the IJF's tatami): at the outer edge of the safety area its thickness shows.");
+    return room;
+}
+/**
+ * The gallery a dojo's crowd sits in, from the same balcony data as `dojoRoom()`, so that the 2D stands and a 3D view agree: a thin band of 4 rows (ours) close to the walls, just beyond the wood
+ * surround. A dojo that asks for no balcony still has the default one when it has a crowd; `balcony: false` asks for none, and the sport's own stands are drawn. Not a dojo: nothing.
+ */
+export function dojoGallery(o) {
+    if (o.sport !== "dojo")
+        return undefined;
+    const spec = dojoSpecOf(o.dojo);
+    if (spec.balcony === false)
+        return undefined;
+    const room = dojoRoom({ ...o, dojo: { ...spec, eras: undefined, era: undefined, year: undefined, balcony: spec.balcony ?? true } });
+    const b = room?.balconies[0];
+    if (room === undefined || b === undefined)
+        return undefined;
+    const f = room.floor;
+    const offset = Math.min(...room.balconies.map((x) => (x.side === "north" ? f.y0 - x.box.y1 : x.side === "south" ? x.box.y0 - f.y1 : x.side === "west" ? f.x0 - x.box.x1 : x.box.x0 - f.x1)));
+    return { offset, depth: b.depth, rows: b.rows, height: [b.height, b.height + b.rows * b.rowRise] };
+}

package/dist/budo/sumo.d.ts

@@ -0,0 +1,31 @@
+import type { SumoFigures } from "../leagues/budo.ts";
+import { type MBox, type MMark, type Parts } from "./parts.ts";
+/** What a sumo plan is. */
+export interface SumoLayout {
+    parts: Parts;
+    /** The clay square: the playing surface. */
+    platform: MBox;
+    extent: MBox;
+    centre: [number, number];
+    /** The circle: the radius of its inside, the wrestlers' ring, and of the outer edge of the tawara. */
+    ring: number;
+    outer: number;
+    /** The centres of the 20 tawara, as angles in degrees (0 east, growing clockwise as the eye sees it), the tokudawara at 0, 90, 180 and 270. */
+    bales: {
+        angle: number;
+        tokuda: boolean;
+    }[];
+    /** The length of a tawara along the circle. */
+    baleLength: number;
+    height: number;
+    marks: MMark[];
+    ranges: Record<string, MBox>;
+}
+/** The height of the clay square the options ask for, held to 34 cm to 60 cm. */
+export declare const dohyoHeight: (asked: number | undefined, fig: SumoFigures) => number;
+/** The plan of the dohyō the options ask for. */
+export declare function sumoParts(fig: SumoFigures, o: {
+    height: number;
+    tawara: boolean;
+    tassels: boolean;
+}): SumoLayout;

package/dist/budo/sumo.js

@@ -0,0 +1,71 @@
+import { annulusD, discArea, rectArea, tapeBar, within } from "./kit.js";
+import { emptyParts, grow } from "./parts.js";
+import { num } from "../format.js";
+/** The height of the clay square the options ask for, held to 34 cm to 60 cm. */
+export const dohyoHeight = (asked, fig) => (asked === undefined ? fig.height.drawn : within(asked, fig.height.min, fig.height.max, "The dohyō's height", "the Sumo Rules (Dohyō Regulations, Article 1)"));
+const rd = (v) => Math.round(v * 1000) / 1000;
+/** The plan of the dohyō the options ask for. */
+export function sumoParts(fig, o) {
+    const side = fig.platform;
+    const c = side / 2;
+    const platform = { x0: 0, y0: 0, x1: side, y1: side };
+    const inner = fig.circle / 2;
+    const wb = fig.bale.width;
+    const rb = inner + wb / 2;
+    const outer = inner + wb;
+    const parts = emptyParts();
+    parts.areas.push(rectArea("platform", "clay", "ky-bud-clay", platform));
+    // The ring's inside is the same clay. The band of sand lies just outside the tawara.
+    if (o.tawara)
+        parts.areas.push({ id: "jano-me", feature: "jano-me", cls: "ky-bud-sand", d: annulusD(c, c, outer, outer + fig.jano), evenodd: true });
+    // The 20 tawara are 4 tokudawara and 4 between each of them: one every 18 degrees, laid along the circle; a tokudawara stands a little way out.
+    const n = fig.tawara.count;
+    const step = 360 / n;
+    const bales = [];
+    const baleLength = ((2 * Math.PI * rb) / n) * 0.96;
+    const perQuarter = fig.tawara.between + 1;
+    const polys = [];
+    for (let i = 0; i < n; i += 1) {
+        const tokuda = i % perQuarter === 0;
+        const angle = i * step;
+        bales.push({ angle, tokuda });
+        const t = (angle * Math.PI) / 180;
+        const R = rb + (tokuda ? fig.bale.out : 0);
+        const px = c + R * Math.cos(t);
+        const py = c + R * Math.sin(t);
+        const tx = -Math.sin(t);
+        const ty = Math.cos(t);
+        const nx = Math.cos(t);
+        const ny = Math.sin(t);
+        const hl = baleLength / 2;
+        const hw = wb / 2;
+        const corners = [[-hl, -hw], [hl, -hw], [hl, hw], [-hl, hw]].map(([a, b]) => [rd(px + a * tx + b * nx), rd(py + a * ty + b * ny)]);
+        polys.push(`M${corners.map(([x, y]) => `${num(x)} ${num(y)}`).join("L")}Z`);
+    }
+    if (o.tawara) {
+        parts.areas.push({ id: "tawara", feature: "tawara", cls: "ky-bud-tawara", d: polys.join("") });
+        // The shikiri-sen, two white lines across the line between the wrestlers, 70 cm apart, 90 cm long and 6 cm wide.
+        const s = fig.shikiri;
+        for (const [k, dx] of [["east", 1], ["west", -1]]) {
+            const x = c + dx * (s.apart / 2 + s.width / 2);
+            parts.shapes.push(tapeBar(`shikiri-${k}`, "shikiri-sen", "ky-bud-white-fill", { x0: x - s.width / 2, y0: c - s.length / 2, x1: x + s.width / 2, y1: c + s.length / 2 }));
+        }
+    }
+    // The four tassels, in the colours of the quarters: green east, red south, white west, black north.
+    if (o.tassels) {
+        const at = 0.22;
+        parts.areas.push(discArea("tassel-east", "tassels", "ky-bud-tassel-e", side - at, c, 0.12), discArea("tassel-south", "tassels", "ky-bud-tassel-s", c, side - at, 0.12), discArea("tassel-west", "tassels", "ky-bud-tassel-w", at, c, 0.12), discArea("tassel-north", "tassels", "ky-bud-tassel-n", c, at, 0.12));
+    }
+    const reach = outer + fig.bale.out;
+    const ranges = { ring: { x0: c - reach - 0.3, y0: c - reach - 0.3, x1: c + reach + 0.3, y1: c + reach + 0.3 }, start: { x0: c - 1.2, y0: c - 0.9, x1: c + 1.2, y1: c + 0.9 } };
+    const marks = [
+        { id: "dohyo", x: side * 0.1, y: side * 0.12, side: "top" },
+        { id: "ring", x: c - 0.9, y: c - inner * 0.62, side: "top" },
+        { id: "tawara", x: c + rb * Math.cos((1.5 * step * Math.PI) / 180), y: c - rb * Math.sin((1.5 * step * Math.PI) / 180) * -1, side: "bottom" },
+        { id: "tokudawara", x: c + rb + fig.bale.out, y: c, side: "bottom" },
+        { id: "shikiri-sen", x: c - fig.shikiri.apart / 2 - fig.shikiri.width / 2, y: c + fig.shikiri.length / 2, side: "bottom" },
+    ];
+    if (o.tawara)
+        marks.push({ id: "jano-me", x: c - (outer + fig.jano / 2) * Math.SQRT1_2, y: c - (outer + fig.jano / 2) * Math.SQRT1_2, side: "top" });
+    return { parts, platform, extent: grow(platform, 0.5), centre: [c, c], ring: inner, outer, bales, baleLength, height: o.height, marks, ranges };
+}

package/dist/budo/tatami.d.ts

@@ -0,0 +1,55 @@
+import type { Area, Shape } from "../fields.types.ts";
+import type { MBox } from "./parts.ts";
+/** A mat's size. */
+export interface MatSize {
+    length: number;
+    width: number;
+}
+/** What a piece of floor is: a whole mat, half of one (a square), or a mat cut to fit. */
+export type PieceKind = "full" | "half" | "cut";
+/** One piece of the floor, a mat or part of one. */
+export interface Piece extends MBox {
+    kind: PieceKind;
+    /** The axis of its long side: `x` or `y`. */
+    along: "x" | "y";
+    /** Which colour it is painted: 1 the first, 2 the second, 3 the third (a danger zone or a border). */
+    tone: 1 | 2 | 3;
+}
+/** The kind of a piece of a floor laid with mats of a size. */
+export declare function kindOf(w: number, h: number, mat: MatSize, along: "x" | "y"): PieceKind;
+/**
+ * Lay a rectangle with mats whose long sides run along `along`, in columns the width of a mat. With `stagger` every second column is set off by half a mat, so that no four
+ * corners meet (the traditional lay); without it the mats make a grid. The floor's ends and sides are cut to fit where its size is not a whole number of mats; a column that is
+ * set off begins and ends with half a mat.
+ */
+export declare function lay(rect: MBox, mat: MatSize, along: "x" | "y", stagger: boolean): Piece[];
+/** The part of a piece inside a box, and the parts of it outside, each a piece of its own (a mat cut where a colour changes). */
+export declare function cutBy(piece: Piece, box: MBox, mat: MatSize): {
+    inside: Piece | undefined;
+    outside: Piece[];
+};
+/**
+ * Give every piece the tone of the zone it lies in: the first of `zones` that holds it, else `rest`. A mat that a boundary runs through is cut there, each part
+ * taking its own zone's tone.
+ */
+export declare function tint(pieces: readonly Piece[], zones: readonly {
+    box: MBox;
+    tone: 1 | 2 | 3;
+}[], rest: 1 | 2 | 3, mat: MatSize): Piece[];
+/** The mats of a checker floor: the tone alternates from one mat to the next, as the squares of a chessboard do. */
+export declare function checker(pieces: readonly Piece[], rect: MBox, mat: MatSize): Piece[];
+/**
+ * How many points are a corner of four pieces or more: where four mats meet. A floor laid in the traditional way has none. Pieces that only touch along a side are not counted (a T is a point
+ * where one piece's side runs past the corners of two others, not a corner of three).
+ */
+export declare function fourCorners(pieces: readonly Piece[]): number;
+/** The floor's area in square metres. */
+export declare const areaOf: (pieces: readonly Piece[]) => number;
+/** The number of mats a floor holds, counted as the mats' own area: a half mat is a half, a cut piece the share of a mat it covers. */
+export declare const matCount: (pieces: readonly Piece[], mat: MatSize) => number;
+/** The painted areas of a floor of mats: one path for each tone, in the class the look gives it. */
+export declare function tatamiAreas(id: string, pieces: readonly Piece[], classes: Readonly<Record<1 | 2 | 3, Area["cls"]>>, feature: Readonly<Record<1 | 2 | 3, string>>): Area[];
+/** The seams: the outline of every piece, as one line. */
+export declare function seams(id: string, pieces: readonly Piece[], width: number): Shape[];
+/** The heri (畳縁), the cloth along the two long sides of a traditional mat, as filled strips inside the mat. Cut pieces and the thin ends of a floor have none. */
+export declare function heri(id: string, pieces: readonly Piece[], width: number, mat: MatSize): Area[];