@johnmorrisdotca/kyogijo-stadiums 0.4.0 → 0.6.0

package/dist/surfaces/polo.js

@@ -0,0 +1,159 @@
+import { el, num } from "../format.js";
+import { feet } from "../pool.js";
+import { box, deckMarkup, leastWidth, paintDefs, poolIds, ropeMarkup, waterMarkup } from "../pool.kit.js";
+import { WATER_POLO } from "../pool.figures.js";
+import { GUTTER } from "./pool.js";
+import { atEnds, edges, ft, quarterTurn } from "./surface.js";
+/** The space behind each goal line where the goal's net hangs, in metres (Part Six 21.6.5 and 21.7.2.1: the goal at least 0.3 m deep, the lane rope 0.3 m behind the goal line): the pool is the field of play, 25 m between the goal lines (Part Six 20.2.2.1), and this behind each of them. */
+export const POLO_BEHIND = WATER_POLO.goal.netClear;
+/**
+ * A water polo field of play lying wide, from World Aquatics' rules: 25 by 20 m between the goal lines; lane ropes along both sides whose floats are white at the goal line and the half distance line, red to
+ * the 2 m mark, yellow from 2 to 6 m and green from 6 m to the half distance line, with a red mark at 5 m (Part Six 21.7.1 and 21.7.2); the 2 m lines from the goal posts that make the goal areas
+ * (Part Six 20.4 and 21.7.2.1.2); the goals, 3 m between the posts (21.6.3.2); the re-entry area 2.0 by 1.08 m in each corner on the side away from the official table (20.7); the referees' platforms 1 m wide along both sides, coloured
+ * as the ropes are (21.9.3); the official table (21.10) and the area for flying substitutions on the side of the benches (20.6).
+ */
+export function waterPolo(o, plan, ctx = {}) {
+    const Lp = plan.length;
+    const W = plan.width;
+    const b = POLO_BEHIND;
+    const ids = ctx.ids ?? poolIds(o.id);
+    const full = o.detail === "full";
+    const m = ctx.bare === true ? 0 : (o.margin ?? feet(WATER_POLO.deck));
+    const platform = WATER_POLO.platform.width;
+    const down = plan.table === "bottom";
+    // The goal lines stand 0.30 m in from the walls; the marks are measured from them.
+    const g0 = b;
+    const g1 = Lp - b;
+    const at = (d, from) => (from === "left" ? g0 + d : g1 - d);
+    const deckTop = GUTTER + platform;
+    const deckBottom = GUTTER + platform + (down ? WATER_POLO.table.depth + 0.6 : 0);
+    let base = box(o, "gutter", "ky-boards", -GUTTER, -GUTTER, Lp + GUTTER, W + GUTTER);
+    base += waterMarkup(o, ids, plan.look, 0, 0, Lp, W);
+    // The referees' platforms along both sides, in the colours of the ropes by distance from the goal line.
+    const bands = [
+        ["red", 0, WATER_POLO.twoMetre],
+        ["yellow", WATER_POLO.twoMetre, WATER_POLO.sixMetre],
+        ["green", WATER_POLO.sixMetre, WATER_POLO.half],
+    ];
+    let walk = "";
+    for (const [y0, y1] of [[-GUTTER - platform, -GUTTER], [W + GUTTER, W + GUTTER + platform]]) {
+        for (const [colour, a, z] of bands) {
+            for (const from of ["left", "right"]) {
+                const x0 = from === "left" ? at(a, "left") : at(z, "right");
+                const x1 = from === "left" ? at(z, "left") : at(a, "right");
+                walk += el("rect", { class: ft(o, "referee-platforms", `ky-pl-rp ky-pl-rp-${colour}`), x: feet(x0), y: feet(y0), width: feet(x1 - x0), height: feet(y1 - y0) });
+            }
+        }
+    }
+    base += walk;
+    let lines = "";
+    const thin = leastWidth(o, 0.06, 0.12);
+    // The lines across the field: the goal lines and the half distance line white, the 2 m line red, the 5 m line a dashed red one (a red mark at 5 m), the 6 m line yellow.
+    const across = (cls, colour, x, dash, w = thin) => el("path", { class: ft(o, cls, `ky-pl-wl ky-pl-wl-${colour}`), d: `M${num(feet(x))} 0V${num(feet(W))}`, "stroke-width": w, "stroke-dasharray": dash, fill: "none" });
+    lines += across("goal-lines", "white", g0, undefined, thin * 1.4) + across("goal-lines", "white", g1, undefined, thin * 1.4) + across("half-distance-line", "white", Lp / 2, undefined, thin * 1.4);
+    for (const from of ["left", "right"]) {
+        lines += across("two-metre-lines", "red", at(WATER_POLO.twoMetre, from));
+        lines += across("six-metre-lines", "yellow", at(WATER_POLO.sixMetre, from));
+        lines += across("five-metre-marks", "red", at(WATER_POLO.fiveMetre, from), `${num(feet(0.5))} ${num(feet(0.5))}`);
+    }
+    // The goal areas: red lines 2 m long from the outer faces of the goal posts (Part Six 20.4.1 and 21.7.2.1.2).
+    const post = WATER_POLO.goal.post;
+    const half = WATER_POLO.goal.width / 2;
+    for (const from of ["left", "right"]) {
+        const x0 = at(0, from);
+        const x1 = at(WATER_POLO.goalAreaLine, from);
+        for (const side of [-1, 1]) {
+            const y = W / 2 + side * (half + post);
+            lines += el("path", { class: ft(o, "goal-area-lines", "ky-pl-wl ky-pl-wl-red"), d: `M${num(feet(x0))} ${num(feet(y))}H${num(feet(x1))}`, "stroke-width": thin, fill: "none" });
+        }
+    }
+    // The re-entry areas, 2.0 m along the goal line and 1.08 m into the field, in each corner on the side away from the table.
+    const away = down ? 0 : W;
+    const dirY = down ? 1 : -1;
+    for (const from of ["left", "right"]) {
+        const x0 = at(0, from);
+        const x1 = at(WATER_POLO.reEntry.depth, from);
+        const xa = Math.min(x0, x1);
+        const ya = Math.min(away, away + dirY * WATER_POLO.reEntry.length);
+        lines += el("rect", { class: ft(o, "re-entry-areas", "ky-pl-ra"), x: feet(xa), y: feet(ya), width: feet(Math.abs(x1 - x0)), height: feet(WATER_POLO.reEntry.length) });
+    }
+    // The lane ropes along the sides: white to the goal line, then red, yellow and green, with the red mark at 5 m, and white at the half distance line.
+    const runs = [];
+    const inset = 0.1;
+    for (const y of [inset, W - inset]) {
+        runs.push(["white", 0, g0, y], ["white", g1, Lp, y]);
+        for (const [colour, a, z] of bands) {
+            runs.push([colour, at(a, "left"), at(z, "left"), y]);
+            runs.push([colour, at(z, "right"), at(a, "right"), y]);
+        }
+        runs.push(["white", Lp / 2 - 0.45, Lp / 2 + 0.45, y]);
+        for (const from of ["left", "right"]) {
+            runs.push(["white", at(0, from) - 0.3, at(0, from) + 0.3, y]);
+            runs.push(["red", at(WATER_POLO.fiveMetre, from) - 0.3, at(WATER_POLO.fiveMetre, from) + 0.3, y]);
+        }
+    }
+    lines += ropeMarkup(o, runs, WATER_POLO.rope, 0.42);
+    // The goals: two posts and the crossbar between them on each goal line, white, with the net behind the line. The posts and the bar are drawn thicker than they stand, as the lines are.
+    const drawn = o.exact ? post : Math.max(post, 0.32);
+    for (const from of ["left", "right"]) {
+        const x = at(0, from);
+        const inward = from === "left" ? 1 : -1;
+        lines += el("path", { class: ft(o, "goals", "ky-pl-gn"), d: `M${num(feet(x))} ${num(feet(W / 2 - half))}h${num(feet(-inward * b))}v${num(feet(2 * half))}h${num(feet(inward * b))}`, "stroke-width": feet(0.09), fill: "none" });
+        lines += el("path", { class: ft(o, "goals", "ky-pl-gb"), d: `M${num(feet(x))} ${num(feet(W / 2 - half))}V${num(feet(W / 2 + half))}`, "stroke-width": feet(drawn) * 0.8, fill: "none" });
+        for (const side of [-1, 1]) {
+            const y = W / 2 + side * (half + post / 2);
+            lines += el("rect", { class: ft(o, "goal-posts", "ky-pl-gp"), x: feet(x - drawn / 2 - (inward * drawn) / 2 + (inward * drawn) / 2), y: feet(y - drawn / 2), width: feet(drawn), height: feet(drawn), rx: feet(drawn) * 0.12 });
+        }
+    }
+    // The official table and the flying substitution areas on the side of the benches.
+    if (down) {
+        const t = WATER_POLO.table;
+        base += el("rect", { class: ft(o, "official-table", "ky-pl-tb"), x: feet(Lp / 2 - t.length / 2), y: feet(W + GUTTER + platform + 0.5), width: feet(t.length), height: feet(t.depth), rx: feet(0.12) });
+    }
+    const sub = WATER_POLO.substitution;
+    if (full) {
+        const y0 = down ? W + GUTTER + platform : -GUTTER - platform - sub;
+        base += el("rect", { class: ft(o, "substitution-areas", "ky-pl-sa-l"), x: feet(g0), y: feet(y0), width: feet(Lp / 2 - g0), height: feet(sub) });
+        base += el("rect", { class: ft(o, "substitution-areas", "ky-pl-sa-r"), x: feet(Lp / 2), y: feet(y0), width: feet(g1 - Lp / 2), height: feet(sub) });
+    }
+    // The names of the parts, for a drawing that labels them.
+    const marks = [];
+    if (o.landmarks === true) {
+        marks.push({ id: "goal-line", x: feet(g0), y: 0, side: "top" }, { id: "two-metre-line", x: feet(at(WATER_POLO.twoMetre, "left")), y: feet(W), side: "bottom" }, { id: "five-metre-mark", x: feet(at(WATER_POLO.fiveMetre, "left")), y: 0, side: "top" }, { id: "six-metre-line", x: feet(at(WATER_POLO.sixMetre, "left")), y: feet(W), side: "bottom" }, { id: "half-distance-line", x: feet(Lp / 2), y: 0, side: "top" }, { id: "goal", x: feet(g1), y: feet(W / 2), side: "bottom" }, { id: "re-entry-area", x: feet(at(0.5, "right")), y: feet(down ? 0.5 : W - 0.5), side: down ? "top" : "bottom" }, { id: "referee-platform", x: feet(Lp * 0.3), y: feet(down ? W + GUTTER + platform / 2 : -GUTTER - platform / 2), side: down ? "bottom" : "top" });
+        if (down)
+            marks.push({ id: "official-table", x: feet(Lp / 2), y: feet(W + GUTTER + platform + 0.5 + WATER_POLO.table.depth), side: "bottom" });
+    }
+    const view0 = { x: -m, y: -feet(deckTop) - m, w: feet(Lp) + 2 * m, h: feet(W) + feet(deckTop + deckBottom) + 2 * m };
+    // The deck is under everything.
+    if (ctx.bare !== true)
+        base = deckMarkup(o, ids, plan.deck, view0.x, view0.y, view0.w, view0.h) + base;
+    const L = feet(Lp);
+    const Wf = feet(W);
+    const cy = Wf / 2;
+    const turned = o.portrait;
+    const surface = {
+        sport: "waterpolo",
+        view: view0,
+        base,
+        lines,
+        defs: ctx.bare === true ? "" : paintDefs(ids, plan.look, plan.deck, plan.seed),
+        left: { cx: -m / 2, cy, w: Wf, h: m, rot: -90 },
+        right: { cx: L + m / 2, cy, w: Wf, h: m, rot: 90 },
+        plate: turned ? { cx: L / 2, cy, w: Wf * 0.9, h: L * 0.3 } : { cx: L / 2, cy, w: L * 0.3, h: Wf * 0.5 },
+        turned,
+    };
+    surface.box = { x: 0, y: 0, w: L, h: Wf };
+    surface.lineRef = { width: thin, feet: 1 };
+    surface.ranges = {
+        half: atEnds((end) => (end === "left" ? edges(0, 0, L / 2, Wf) : edges(L / 2, 0, L, Wf))),
+        "goal-area": atEnds((end) => (end === "left" ? edges(0, 0, feet(g0 + WATER_POLO.twoMetre + 0.5), Wf) : edges(L - feet(Lp - g1 + WATER_POLO.twoMetre + 0.5), 0, L, Wf))),
+    };
+    if (o.landmarks === true)
+        surface.marks = marks;
+    if (turned) {
+        const t = quarterTurn(view0);
+        surface.view = t.view;
+        surface.turn = t.turn;
+    }
+    return surface;
+}

package/dist/surfaces/pool.d.ts

@@ -0,0 +1,27 @@
+import type { SwimPlan } from "../pool.ts";
+import { type PoolCtx, type PoolIds } from "../pool.kit.ts";
+import { type BuildOptions, type Mark, type Surface } from "./surface.ts";
+/** The swimming pool lying wide, before its deck and view: the water and the gutter, and the lines, ropes and fixtures over them, in feet from the pool's top left corner. */
+export interface SwimBody {
+    /** The gutter and the water. */
+    base: string;
+    /** The markings on the floor, the ropes and the fixtures. */
+    lines: string;
+    /** The labels of the parts to name, in feet. */
+    marks: Mark[];
+    /** Where the lane markings end: kept for the lineRef. */
+    line: number;
+}
+/** The gutter round the water, in metres: the width of the coping the pool is drawn with. */
+export declare const GUTTER = 0.4;
+/**
+ * The body of a swimming pool: every figure is the rules' (`SWIMMING`, pool.figures.ts). The lane markings on the floor are 46 m (21 m in a 25 m pool) long and end 2 m from the walls in a cross line 1 m long (Part Two 15.13.1 and 15.13.2); a
+ * cross line 0.5 m long at 15 m from each end; the touch panels 2.4 m wide at the walls with the target lines; the ropes in the rules' colours with red floats within 5 m of the walls and a mark at 15 m and 25 m;
+ * the starting blocks with their lane numbers; the backstroke flags 5 m from each end, and the false start rope 15 m from the starting end.
+ */
+export declare function swimBody(o: BuildOptions, plan: SwimPlan, ids: PoolIds): SwimBody;
+/**
+ * A swimming pool lying wide with its deck: the body, the deck round it in the colour or the tiles asked for, the data of a race at the walls and over the water, and a side section under the plan if
+ * it is asked for. The pool's water is the surface's `box`; the deck is the margin.
+ */
+export declare function swimming(o: BuildOptions, plan: SwimPlan, ctx?: PoolCtx): Surface;

package/dist/surfaces/pool.js

@@ -0,0 +1,198 @@
+import { el, num } from "../format.js";
+import { feet } from "../pool.js";
+import { box, deckMarkup, leastWidth, paintDefs, poolIds, ropeMarkup, waterMarkup } from "../pool.kit.js";
+import { raceArt } from "../pool.labels.js";
+import { sectionOf } from "../pool.section.js";
+import { SWIMMING } from "../pool.figures.js";
+import { atEnds, edges, ft, quarterTurn, textOn } from "./surface.js";
+/** The gutter round the water, in metres: the width of the coping the pool is drawn with. */
+export const GUTTER = 0.4;
+/**
+ * The body of a swimming pool: every figure is the rules' (`SWIMMING`, pool.figures.ts). The lane markings on the floor are 46 m (21 m in a 25 m pool) long and end 2 m from the walls in a cross line 1 m long (Part Two 15.13.1 and 15.13.2); a
+ * cross line 0.5 m long at 15 m from each end; the touch panels 2.4 m wide at the walls with the target lines; the ropes in the rules' colours with red floats within 5 m of the walls and a mark at 15 m and 25 m;
+ * the starting blocks with their lane numbers; the backstroke flags 5 m from each end, and the false start rope 15 m from the starting end.
+ */
+export function swimBody(o, plan, ids) {
+    const L = plan.length;
+    const W = plan.width;
+    const full = o.detail === "full";
+    // Small fixtures are drawn a little larger than they stand, as lines are, unless the true sizes are asked for.
+    const s = o.exact ? 1 : 1.5;
+    let base = box(o, "gutter", "ky-boards", -GUTTER, -GUTTER, L + GUTTER, W + GUTTER);
+    base += waterMarkup(o, ids, plan.look, 0, 0, L, W);
+    let lines = "";
+    const lw = leastWidth(o, SWIMMING.laneLine.width, 0.32);
+    const marks = [];
+    // Under pace bars the lanes are the whole race laid flat, not one length of the pool: the furniture that belongs to a length (floor lines and crosses, the marks at 15 m and 25 m, the red ends of the ropes,
+    // flags, the false start rope, blocks and panels) is left off and the ropes are plain, so that the picture reads as a chart.
+    const neutral = plan.race?.pace !== null && plan.race?.pace !== undefined;
+    // The lane markings and their cross lines on the floor: a line along the middle of each lane, 2 m short of each wall, ending in a cross line 1 m long.
+    const gap = SWIMMING.laneLine.endGap;
+    const half = SWIMMING.laneLine.cross / 2;
+    let d = "";
+    let crosses = "";
+    for (const lane of plan.lanes) {
+        d += `M${num(feet(gap))} ${num(feet(lane.y))}H${num(feet(L - gap))}`;
+        d += `M${num(feet(gap))} ${num(feet(lane.y - half))}V${num(feet(lane.y + half))}M${num(feet(L - gap))} ${num(feet(lane.y - half))}V${num(feet(lane.y + half))}`;
+        if (full)
+            for (const x of [SWIMMING.markAt15, L - SWIMMING.markAt15])
+                crosses += `M${num(feet(x))} ${num(feet(lane.y - SWIMMING.target.crossAt15 / 2))}V${num(feet(lane.y + SWIMMING.target.crossAt15 / 2))}`;
+    }
+    if (!neutral)
+        lines += el("path", { class: ft(o, "lane-lines", "ky-line"), d: d + crosses, "stroke-width": lw, fill: "none" });
+    // The touch panels on the end walls, 2.4 m wide in each lane, with the target line down the middle and its cross line.
+    if (plan.pads && !neutral) {
+        const depth = o.exact ? 0.05 : 0.3;
+        const pad = SWIMMING.pad.width;
+        let pads = "";
+        let targets = "";
+        for (const lane of plan.lanes) {
+            for (const end of [0, 1]) {
+                const x0 = end === 0 ? 0 : L - depth;
+                pads += `M${num(feet(x0))} ${num(feet(lane.y - pad / 2))}h${num(feet(depth))}v${num(feet(pad))}h${num(feet(-depth))}Z`;
+                const wall = end === 0 ? 0 : L;
+                const inward = end === 0 ? 1 : -1;
+                targets += `M${num(feet(wall))} ${num(feet(lane.y))}h${num(feet(inward * depth))}`;
+                if (full)
+                    targets += `M${num(feet(wall + inward * depth * 0.5))} ${num(feet(lane.y - SWIMMING.target.cross / 2))}v${num(feet(SWIMMING.target.cross))}`;
+            }
+        }
+        lines += el("path", { class: ft(o, "touch-pads", "ky-pl-pad"), d: pads });
+        lines += el("path", { class: ft(o, "lane-lines", "ky-line"), d: targets, "stroke-width": lw * 0.85, fill: "none" });
+    }
+    // The ropes: floats in the lane's colour, red within 5 m of each wall, and a distinct run at 15 m and 25 m from the walls.
+    const runs = [];
+    const red = SWIMMING.redEnds;
+    const run = SWIMMING.markRun / 2;
+    for (const rope of plan.ropes) {
+        if (neutral) {
+            runs.push(["white", 0, L, rope.y]);
+            continue;
+        }
+        runs.push([rope.colour, red, L - red, rope.y]);
+        runs.push(["red", 0, red, rope.y], ["red", L - red, L, rope.y]);
+        const at = [SWIMMING.markAt15, L - SWIMMING.markAt15, ...(plan.course === "long" ? [SWIMMING.markAt25] : [])];
+        for (const x of at)
+            runs.push(["white", Math.max(0, x - run), Math.min(L, x + run), rope.y]);
+    }
+    lines += ropeMarkup(o, runs, SWIMMING.floatDiameter, 0.45);
+    // The marks on the deck at 15 m (and 25 m) from the walls, and the standards of the flags: on both sides of the pool (Part Two 15.9.1).
+    if (full && !neutral) {
+        let ticks = "";
+        for (const x of [SWIMMING.markAt15, L - SWIMMING.markAt15, ...(plan.course === "long" ? [SWIMMING.markAt25] : [])]) {
+            for (const [y0, y1] of [[-GUTTER, 0], [W, W + GUTTER]])
+                ticks += `M${num(feet(x))} ${num(feet(y0))}V${num(feet(y1))}`;
+        }
+        lines += el("path", { class: ft(o, "lane-lines", "ky-line"), d: ticks, "stroke-width": feet(0.22), fill: "none" });
+    }
+    // The false start rope, 15 m from the starting end, on its standards.
+    if (plan.falseStart && !neutral) {
+        const x = SWIMMING.falseStart.at;
+        lines += el("path", { class: ft(o, "false-start-rope", "ky-pl-fs"), d: `M${num(feet(x))} ${num(feet(-0.7))}V${num(feet(W + 0.7))}`, "stroke-width": feet(0.1) * s, fill: "none", "stroke-dasharray": `${num(feet(0.5))} ${num(feet(0.3))}` });
+        if (full)
+            for (const y of [-0.7, W + 0.7])
+                lines += el("circle", { class: "ky-pl-st", cx: feet(x), cy: feet(y), r: feet(0.22) * s });
+    }
+    // The backstroke flags: a rope across the pool 5 m from each wall, flags of two colours hanging from it.
+    if (plan.flags && !neutral) {
+        for (const x of [SWIMMING.flags.at, L - SWIMMING.flags.at]) {
+            const fx = feet(x);
+            lines += el("path", { class: ft(o, "backstroke-flags", "ky-pl-fa"), d: `M${num(fx)} ${num(feet(-0.6))}V${num(feet(W + 0.6))}`, "stroke-width": feet(0.26) * s, fill: "none", "stroke-dasharray": `${num(feet(0.4))} ${num(feet(0.4))}` });
+            lines += el("path", { class: ft(o, "backstroke-flags", "ky-pl-fb2"), d: `M${num(fx)} ${num(feet(-0.6))}V${num(feet(W + 0.6))}`, "stroke-width": feet(0.26) * s, fill: "none", "stroke-dasharray": `0 ${num(feet(0.4))} ${num(feet(0.4))} 0` });
+            if (full)
+                for (const y of [-0.6, W + 0.6])
+                    lines += el("circle", { class: "ky-pl-st", cx: fx, cy: feet(y), r: feet(0.22) * s });
+        }
+    }
+    // The starting blocks, 0.5 by 0.5 m (Part Two 15.8.1 asks at least that; the June 2025 edition asked 0.6 m long at the Olympic Games and the World Championships), one in each lane at each end, numbered on the top (Part Two 15.8.1 and 15.8.6).
+    if (plan.blocks && !neutral) {
+        const bw = SWIMMING.block.width * s;
+        const bl = SWIMMING.block.length * s;
+        let blocks = "";
+        let numbers = "";
+        for (const lane of plan.lanes) {
+            for (const end of [0, 1]) {
+                const x0 = end === 0 ? -0.08 - bl : L + 0.08;
+                blocks += `M${num(feet(x0))} ${num(feet(lane.y - bw / 2))}h${num(feet(bl))}v${num(feet(bw))}h${num(feet(-bl))}Z`;
+                if (full)
+                    numbers += textOn(o.portrait, feet(x0 + bl / 2), feet(lane.y) + feet(bw) * 0.32, String(lane.number), { size: feet(bw) * 0.72, anchor: "middle", cls: "ky-pl-bn", weight: 800 });
+            }
+        }
+        lines += el("path", { class: ft(o, "starting-blocks", "ky-pl-bk"), d: blocks });
+        lines += numbers;
+    }
+    if (o.landmarks === true) {
+        const top = plan.lanes[0];
+        const mid = plan.lanes[Math.floor(plan.lanes.length / 2)];
+        const ropeY = plan.ropes[1]?.y ?? plan.ropes[0].y;
+        marks.push({ id: "lane-rope", x: feet(L * 0.62), y: feet(ropeY), side: "top" });
+        if (!neutral) {
+            marks.push({ id: "lane-line", x: feet(L * 0.35), y: feet(mid.y), side: "bottom" }, { id: "lane-end-cross", x: feet(SWIMMING.laneLine.endGap), y: feet(top.y), side: "top" }, { id: "fifteen-metre-mark", x: feet(SWIMMING.markAt15), y: 0, side: "top" });
+        }
+        if (plan.pads && !neutral)
+            marks.push({ id: "touch-pad", x: feet(0.15), y: feet(plan.lanes[plan.lanes.length - 1].y), side: "bottom" });
+        if (plan.blocks && !neutral)
+            marks.push({ id: "starting-block", x: feet(-0.6), y: feet(plan.lanes[plan.lanes.length - 1].y), side: "bottom" });
+        if (plan.flags && !neutral)
+            marks.push({ id: "backstroke-flags", x: feet(SWIMMING.flags.at), y: feet(W), side: "bottom" });
+        if (plan.falseStart && !neutral)
+            marks.push({ id: "false-start-rope", x: feet(SWIMMING.falseStart.at), y: feet(W), side: "bottom" });
+        marks.push({ id: "gutter", x: feet(L * 0.8), y: feet(W + GUTTER / 2), side: "bottom" });
+    }
+    return { base, lines, marks, line: lw };
+}
+/**
+ * A swimming pool lying wide with its deck: the body, the deck round it in the colour or the tiles asked for, the data of a race at the walls and over the water, and a side section under the plan if
+ * it is asked for. The pool's water is the surface's `box`; the deck is the margin.
+ */
+export function swimming(o, plan, ctx = {}) {
+    const L = feet(plan.length);
+    const W = feet(plan.width);
+    const ids = ctx.ids ?? poolIds(o.id);
+    const m = ctx.bare === true ? 0 : (o.margin ?? feet(SWIMMING.deck));
+    const body = swimBody(o, plan, ids);
+    const art = ctx.bare === true ? raceArt({ ...plan, race: undefined }, o) : raceArt(plan, o);
+    const section = ctx.bare === true ? sectionOf({ ...plan, section: undefined }, o, 0) : sectionOf(plan, o, W + feet(GUTTER) + m);
+    // The view: the deck all round, the plates at the walls, the title or the distances above, the section below.
+    // The depth of a section is written to the left of it.
+    const left = m + Math.max(art.reachLeft, section.height > 0 ? feet(4) : 0);
+    const right = m + art.reachRight;
+    const topExtra = Math.max(0, art.reachTop, plan.race?.event === undefined ? 0 : feet(1.6));
+    const view0 = { x: -left, y: -m - topExtra, w: L + left + right, h: W + 2 * m + topExtra + (section.height > 0 ? section.height + feet(0.6) : 0) };
+    const defs = ctx.bare === true ? "" : paintDefs(ids, plan.look, plan.deck, plan.seed) + section.defs;
+    const basis = (ctx.bare === true ? "" : deckMarkup(o, ids, plan.deck, view0.x, view0.y, view0.w, view0.h)) + body.base;
+    let lines = body.lines + art.pace + art.left + art.right + art.top;
+    if (section.markup !== "")
+        lines += section.markup;
+    const turned = o.portrait;
+    const cy = W / 2;
+    // How far the blocks reach beyond the walls, in feet.
+    const blockReach = feet(0.08 + SWIMMING.block.length * (o.exact ? 1 : 1.5));
+    const plate = turned ? { cx: L / 2, cy, w: W * 0.9, h: L * 0.34 } : { cx: L / 2, cy, w: L * 0.34, h: W * 0.62 };
+    const surface = {
+        sport: "swimming",
+        view: view0,
+        base: basis,
+        lines,
+        defs,
+        // The teams' names stand on the deck beyond the blocks.
+        left: { cx: -(blockReach + (m - blockReach) / 2), cy, w: W, h: Math.max(1, m - blockReach), rot: -90 },
+        right: { cx: L + blockReach + (m - blockReach) / 2, cy, w: W, h: Math.max(1, m - blockReach), rot: 90 },
+        plate,
+        turned,
+    };
+    surface.box = { x: 0, y: 0, w: L, h: W };
+    surface.lineRef = { width: body.line, feet: 1 };
+    surface.ranges = {
+        half: atEnds((end) => (end === "left" ? edges(0, 0, L / 2, W) : edges(L / 2, 0, L, W))),
+        "pool-end": atEnds((end) => (end === "left" ? edges(0, 0, feet(15), W) : edges(L - feet(15), 0, L, W))),
+    };
+    if (o.landmarks === true)
+        surface.marks = o.detail === "full" ? body.marks : body.marks.filter((mark) => !["lane-end-cross", "fifteen-metre-mark"].includes(mark.id));
+    if (turned) {
+        const t = quarterTurn(view0);
+        surface.view = t.view;
+        surface.turn = t.turn;
+    }
+    return surface;
+}

package/dist/surfaces/skating.d.ts

@@ -0,0 +1,6 @@
+import type { SkatingPlan } from "../skating/plan.ts";
+import { type BuildOptions, type Surface } from "./surface.ts";
+/** Feet in a metre. */
+export declare const K: number;
+/** The surface of the plan lying wide. `margin` is the ground round what is drawn, in feet. */
+export declare function skatingSurface(o: BuildOptions, plan: SkatingPlan, margin: number): Surface;

package/dist/surfaces/skating.js

@@ -0,0 +1,62 @@
+// The skating rink's surface lying wide, from its plan (skating/plan.ts): the ice, the floor of the infield, the warm-up lane, the padding, the boards, the furniture, then every painted line and the
+// blocks. The plan is in metres; the drawing is in feet, as every surface lies, so the whole is drawn inside a group that scales metres to feet and moves the rink's box to the origin.
+import { el } from "../format.js";
+import { areaD, marks, strokes } from "./field.js";
+import { atEnds, edges, ft, quarterTurn } from "./surface.js";
+/** Feet in a metre. */
+export const K = 1 / 0.3048;
+const feetBox = (b, ox, oy) => edges((b.x0 - ox) * K, (b.y0 - oy) * K, (b.x1 - ox) * K, (b.y1 - oy) * K);
+/** A plan's named range in feet, as a surface lists them. */
+function rangeOf(r, ox, oy) {
+    return "left" in r ? atEnds((end) => feetBox(end === "left" ? r.left : r.right, ox, oy)) : feetBox(r, ox, oy);
+}
+/** The surface of the plan lying wide. `margin` is the ground round what is drawn, in feet. */
+export function skatingSurface(o, plan, margin) {
+    const ox = plan.box.x0;
+    const oy = plan.box.y0;
+    const full = o.detail === "full";
+    const view0 = { x: (plan.extent.x0 - ox) * K - margin, y: (plan.extent.y0 - oy) * K - margin, w: (plan.extent.x1 - plan.extent.x0) * K + 2 * margin, h: (plan.extent.y1 - plan.extent.y0) * K + 2 * margin };
+    const place = `scale(${K.toFixed(6)}) translate(${(-ox).toFixed(4)} ${(-oy).toFixed(4)})`;
+    const group = (inner, cls) => el("g", { class: cls, transform: place }, inner);
+    const turned = o.portrait;
+    // Under everything: the apron, then the ice, the floor, the warm-up lane, the padding and the furniture, in the plan's order.
+    let base = el("rect", { class: ft(o, "apron", "ky-apron"), x: view0.x, y: view0.y, width: view0.w, height: view0.h });
+    let ground = "";
+    for (const a of plan.areas)
+        ground += el("path", { class: ft(o, a.feature, a.cls), d: areaD(a), "fill-rule": a.evenodd === true ? "evenodd" : undefined });
+    base += group(ground, "ky-ska-ground");
+    const thick = o.exact ? plan.lineWidth : plan.drawnLine;
+    const lines = group(strokes(plan, o) + marks(plan, o), "ky-ska-lines");
+    const W = (plan.box.x1 - plan.box.x0) * K;
+    const H = (plan.box.y1 - plan.box.y0) * K;
+    const surface = {
+        sport: "skating",
+        view: view0,
+        base,
+        lines,
+        defs: "",
+        // A team's name, in a score, is written on the ice either side of the middle.
+        left: { cx: W * 0.27, cy: H / 2, w: W * 0.2, h: H * 0.11, rot: 0 },
+        right: { cx: W * 0.73, cy: H / 2, w: W * 0.2, h: H * 0.11, rot: 0 },
+        plate: { cx: W / 2, cy: H / 2, w: Math.min(W * 0.34, 140), h: Math.min(W * 0.34, 140) * 0.52 },
+        turned,
+        bannersOver: true,
+        onColour: false,
+    };
+    surface.box = { x: 0, y: 0, w: W, h: H };
+    surface.lineRef = { width: thick, feet: K };
+    const ranges = {};
+    for (const [name, r] of Object.entries(plan.ranges))
+        ranges[name] = rangeOf(r, ox, oy);
+    surface.ranges = ranges;
+    if (o.landmarks === true) {
+        const m = plan.marks.map((p) => ({ id: p.id, x: (p.x - ox) * K, y: (p.y - oy) * K, side: p.side }));
+        surface.marks = full ? m : m.filter((p) => !p.id.startsWith("~"));
+    }
+    if (turned) {
+        const t = quarterTurn(view0);
+        surface.view = t.view;
+        surface.turn = t.turn;
+    }
+    return surface;
+}

package/dist/surfaces/soccer.js

@@ -140,7 +140,7 @@ export function soccer(b, o) {
     // The ends in the team's colour, in a score: the penalty area (or what a small pitch has in its place).
     const zoneDepth = Math.max(spec.penaltyDepth, L * 0.12);
     const zoneWidth = Math.max(spec.area === "arcs" ? spec.areaLine + 2 * spec.penaltyDepth : spec.area === "semicircle" ? 2 * spec.penaltyDepth : lay.penaltyHalfWidth * 2, W * 0.4);
-    if (o.score) {
+    if (o.score && o.pageant !== true) {
         // A rectangle at each end: the penalty area on a full pitch, a box that holds the name on the others (their areas are curved).
         for (const side of [0, 1])
             inside += el("rect", { class: `ky-zone ky-zone-${side === 0 ? "left" : "right"}`, x: side === 0 ? 0 : L - zoneDepth, y: cy - zoneWidth / 2, width: zoneDepth, height: zoneWidth });
@@ -231,6 +231,7 @@ export function soccer(b, o) {
     };
     surface.lineRef = { width: lw, feet: K };
     surface.box = { x: 0, y: 0, w: Lf, h: Wf };
+    surface.centreRadius = spec.centreRadius * K;
     // The penalty area reaches as far as its lines do: the area, the arc beyond it and a small pitch's curved area; and a little more.
     const arcBeyond = spec.arcRadius > 0 && lay.spot > 0 && lay.penaltyDepth > lay.spot ? Math.max(0, spec.arcRadius - (lay.penaltyDepth - lay.spot)) : 0;
     const curved = spec.area === "arcs" || spec.area === "semicircle" ? spec.penaltyDepth : 0;

package/dist/surfaces/surface.d.ts

@@ -1,4 +1,5 @@
 import type { Ballpark } from "../ballpark.ts";
+import type { Hardwood } from "../hardwood.ts";
 import type { Box, Detail, GoalInfo, GoalStyle, Sport, StripePattern } from "../types.ts";
 /** Where a team's name and logo go, and how its words lie. */
 export interface Zone {
@@ -20,11 +21,61 @@ export interface PlateSpot {
     w: number;
     h: number;
 }
+/** A place on a surface for a pageant's picture, in the surface's frame in feet; a `disc` is the diameter of the round room the picture must lie in (a curling house). */
+export interface PageantSpot extends PlateSpot {
+    disc?: number;
+}
+/** What a surface says of where a pageant's pictures go, when it is not the plain halves and the middle. */
+export interface PageantPlan {
+    /** Where the first (left) team's picture goes, and the second's (right), when not in the halves: a diamond's outfield and infield, a sheet's two houses. */
+    left?: PageantSpot;
+    right?: PageantSpot;
+    /** The emblem's place: its centre and the radius of the circle it lies in; the middle of the surface, with the centre circle's radius, when missing. */
+    centre?: {
+        cx: number;
+        cy: number;
+        r: number;
+    };
+    /** Half the length, along the surface, that the pictures keep clear in the middle (a cricket pitch's). */
+    clear?: number;
+    /** The first picture is the away team's and the second the home team's, whichever side each is on (a diamond's outfield is the visitors', its infield the home team's). */
+    byRole?: boolean;
+}
 /** The parts of a surface a drawing can be cropped to, by name: one box, or one at each end (`left` and `right` as the surface lies wide), in feet in the wide frame. */
 export type SurfaceRanges = Readonly<Record<string, Box | {
     left: Box;
     right: Box;
 }>>;
+/** The places of a surface's own parts that a game's situation (`situation`) is drawn against, in the wide frame, in feet. */
+export type SituationAnchors = {
+    kind: "hockey";
+    length: number;
+    width: number;
+    blueLine: number;
+    goalLine: number;
+    cornerRadius: number;
+    net: {
+        width: number;
+        depth: number;
+    };
+}
+/** The centre of each base, as the drawing has it (first, second, third), and half the diagonal of a base as drawn; where the backstop stands behind home plate. */
+ | {
+    kind: "baseball";
+    bases: readonly (readonly [number, number])[];
+    half: number;
+    backstop: number;
+}
+/** The field of play from goal line to goal line, with its end zones. */
+/** `arrows` and `numerals`: what a tag must not cover, each as its centre and half its size along the field and across it (`[x, y, hx, hy]`): the arrows beside the yard numbers that point to a goal line, when the field draws them, and the numbers. */
+ | {
+    kind: "football";
+    length: number;
+    endZone: number;
+    width: number;
+    arrows: readonly (readonly [number, number, number, number])[];
+    numerals: readonly (readonly [number, number, number, number])[];
+};
 /** A surface, ready for the teams and the score to be laid on it. */
 export interface Surface {
     sport: Sport;
@@ -84,11 +135,30 @@ export interface Surface {
     plateFits?: boolean;
     /** For a surface set inside another (a special game): the transform that carries the surface's own frame to the drawing's, which data in the surface's frame (`layers`) is put through. */
     frame?: string;
+    /** A surface drawn in parts, one of which is shown again larger beside it (a folded curling sheet): for each copy, the transform that carries the surface's frame to it and the id of the clip that cuts it. The data layers are drawn in each. */
+    panels?: {
+        transform: string;
+        clip: string;
+    }[];
+    /** Markup drawn over the data layers: the labels of a surface's panels. */
+    over?: string;
+    /** True for a surface whose frame has parts the annotations (axes, direction, landmarks) have no margin to stand in. */
+    folded?: boolean;
+    /** The radius of the centre circle in feet, where the surface has one: the emblem of a pageant lies in it. */
+    centreRadius?: number;
+    /** Where a pageant's pictures go, when the halves and the middle are not the place. */
+    pageant?: PageantPlan;
+    /** For a surface whose own frame is turned to an angle that is not a quarter (a close-up of an athletics start): the turn, in degrees, that a layer's texts and logos are given to read upright. */
+    upright?: number;
     /** How wide the surface's ordinary line is drawn, in the units of the `lines` markup, and how many feet one of those units is: what `lineWidth` scales. */
     lineRef?: {
         width: number;
         feet: number;
     };
+    /** For a surface with a crowd: the margin it was drawn with, which holds the stands. */
+    crowdMargin?: number;
+    /** Where the parts a situation is drawn against are: a rink's lines and nets, a diamond's bases, a gridiron's goal lines. */
+    anchors?: SituationAnchors;
 }
 /** A part of a surface to label: its anchor on the surface in feet and the margin its label stands in (the top or the bottom as the surface lies wide). */
 export interface Mark {
@@ -114,9 +184,15 @@ export interface BuildOptions {
         baselineText?: [string, string];
         centreLogo?: string;
         paintThreePoint?: boolean;
+        /** The realistic floor, when asked for (`court.hardwood`), its options read. */
+        hardwood?: Hardwood;
+        /** Words along the sidelines, `[top, bottom]`, on a hardwood floor. */
+        sidelineText?: [string, string];
     };
     /** True in a score drawing, so that panels are made room for. */
     score: boolean;
+    /** True when the drawing is a pageant: the teams' pictures lie over the halves, so the ends are not painted in the teams' colours. */
+    pageant?: boolean;
     /** The names of the features that have a colour of their own, so that their elements carry the class that colour is given to. */
     features?: ReadonlySet<string>;
     /** How the grass is mown, when the options say (a football field and a ballpark have their own default). */

package/dist/surfaces/venue.d.ts

@@ -0,0 +1,15 @@
+import { type VenueLayout } from "../pool.ts";
+import type { Language, PoolStyle } from "../types.ts";
+import { type BuildOptions, type Surface } from "./surface.ts";
+/** The name each pool of a hall is called on the plan, in a language. */
+export declare function venueName(item: VenueLayout["items"][number], language: Language): string;
+/**
+ * Several pools in one hall, to scale: each pool is drawn by its own sport's builder (the competition pool of 8 lanes, a diving well, a warm-up pool, a water polo pool or an artistic swimming area) and set at its place,
+ * with the deck round the hall drawn once and the paint of the water and the deck defined once for all of them. The pools stand at least 8 m apart, 10 m by default, as the rules keep a swimming pool and a diving well
+ * (Part Two 15.15.1). The water of the whole hall is the surface's `box`.
+ */
+export declare function natatorium(o: BuildOptions, style: PoolStyle, look: {
+    look: "flat" | "water" | "tiled";
+    deck: "plain" | "tiled";
+    seed: number;
+}, language: Language): Surface;