@johnmorrisdotca/kyogijo-stadiums 0.4.0 → 0.5.0

package/dist/uprights.fields.js

@@ -0,0 +1,172 @@
+import { FEET_PER_METRE, fenceAt, footballLength } from "./geometry.js";
+import { fenceOutline } from "./surfaces/baseball.js";
+import { flagPole, goalCage, postPair } from "./uprights.goal.js";
+import { mesh, n, pole, threads, wall } from "./turn.kit.js";
+const M = FEET_PER_METRE;
+/**
+ * The crossbar of a football post is 10 ft over the ground (NFL 2026 Rule 1-3-1: "the top face of which is 10 feet above the ground"; CFL 2026 Rule 1-1-1:
+ * "a height of 10 feet"; NCAA 2025 Rule 1-2-5-a: "the top of which is 10 feet above the ground"). The uprights reach 35 ft over the bar in the NFL (Rule 1-3-2: 45 ft
+ * in all), 40 ft above the ground in the CFL (Rule 1-1-1: "extend 40 feet above ground level"), and at least 30 ft above the ground in the NCAA (Rule 1-2-5-a), the
+ * figure drawn for every other league.
+ */
+export const FOOTBALL_CROSSBAR = 10;
+/** The pylon is 18 in high: the NFL's Rule 1-2-3 names pylons but not their size; BAFA's Appendix D (14) recommends 4 in by 4 in and 18 in. */
+export const PYLON_HEIGHT = 1.5;
+/** A football field's uprights: the post at each end and the eight pylons. `shape` is the post of the season, `top` the height of the uprights above the ground. */
+export function footballUprights(spec, shape, top, thin) {
+    const L = footballLength(spec);
+    const W = spec.width;
+    const e = spec.endZone;
+    const items = [];
+    const post = Math.max(thin * 2.6, 0.8);
+    for (const end of ["left", "right"]) {
+        const left = end === "left";
+        const x = spec.posts === "end-line" ? (left ? 0 : L) : left ? e : L - e;
+        items.push(postPair({ id: `posts-${end}`, x, y: W / 2, out: left ? -1 : 1, gap: spec.postWidth ?? 18.5, crossbar: FOOTBALL_CROSSBAR, top, post, support: shape === "slingshot" ? "slingshot" : "centre", stem: 4, cls: "u-yellow" }));
+    }
+    if (spec.pylons !== false) {
+        // Eight pylons: at the four corners of the goal lines and two on each end line (NFL Rule 1-2-3), as the drawing puts them.
+        const corners = [[e, 0], [e, W], [L - e, 0], [L - e, W], [0, 0], [0, W], [L, 0], [L, W]];
+        const side = Math.max(thin * 1.6, 0.33);
+        items.push({ id: "pylons", kind: "pylons", at: [L / 2, W / 2], height: PYLON_HEIGHT, planes: corners.flatMap(([x, y], i) => pole(`pylon-${i}`, "pylon", x, y, 0, PYLON_HEIGHT, side, "u-orange")) });
+    }
+    return items;
+}
+/** A soccer pitch's uprights: both goals and, unless the options turn them off, the four corner flags. */
+export function soccerUprights(spec, flags, thin) {
+    const L = spec.length * M;
+    const W = spec.width * M;
+    const items = [];
+    const depth = spec.goalDepth * M;
+    for (const end of ["left", "right"]) {
+        const left = end === "left";
+        items.push(goalCage({ id: `goal-${end}`, x: left ? 0 : L, y: W / 2, out: left ? -1 : 1, width: spec.goalWidth * M, height: spec.goalHeight * M, depth, top: depth * 0.55, post: Math.max(thin * 1.3, 0.35), cell: Math.max(thin * 6, 0.9), tone: "white" }));
+    }
+    if (flags) {
+        // A corner flagpost is at least 1.5 m (5 ft) high (IFAB Laws of the Game 2025/26, Law 1, section 8); the goal is 7.32 m wide and 2.44 m to the crossbar's lower edge (section 10).
+        const planes = [[0, 0], [L, 0], [0, W], [L, W]].flatMap(([x, y], i) => flagPole(`flag-${i}`, x, y, 1.5 * M, Math.max(thin * 0.9, 0.15)));
+        items.push({ id: "flags", kind: "flags", at: [L / 2, W / 2], height: 1.5 * M, planes });
+    }
+    return items;
+}
+/** The dots of a plan with these ids: the posts, flags and stumps the plan places. */
+const dots = (plan, ...ids) => plan.shapes.flatMap((s) => (s.kind === "dot" && ids.includes(s.id) ? [{ x: s.cx, y: s.cy }] : []));
+/** The pairs of posts a plan places by their x: two dots at one x, the uprights of one end. */
+function pairs(points) {
+    const by = new Map();
+    for (const p of points)
+        by.set(n(p.x), [...(by.get(n(p.x)) ?? []), p]);
+    return [...by.values()].filter((list) => list.length === 2).map(([a, b]) => ({ x: a.x, y: (a.y + b.y) / 2, gap: Math.abs(a.y - b.y) }));
+}
+/** The rugby posts, Gaelic goal posts, Australian football posts and cricket stumps; a goal with a net for the sports that have one. */
+export function fieldUprights(plan, thin) {
+    const items = [];
+    const post = Math.max(thin * 1.4, 0.3);
+    const midX = plan.length / 2;
+    const outOf = (x) => (x < midX ? -1 : 1);
+    const flags = (points, height, id) => {
+        if (points.length === 0)
+            return;
+        items.push({ id, kind: "flags", at: [midX, plan.width / 2], height, planes: points.flatMap((p, i) => flagPole(`${id}-${i}`, p.x, p.y, height, Math.max(thin * 0.9, 0.15))) });
+    };
+    switch (plan.sport) {
+        case "rugby": {
+            // Union (World Rugby 2026 Law 1, goal posts and crossbar): the crossbar's top edge 3 m over the ground, a minimum post height of 3.4 m, which the Law's diagram
+            // draws over the bar and is drawn so (6.4 m); the flag posts at least 1.2 m (Law 1, flag posts 8). League (NRL Section 18, IRL Section 1): posts 16 m high.
+            const league = plan.league === "nrl" || plan.league === "irl";
+            for (const p of pairs(dots(plan, "goal-post")))
+                items.push(postPair({ id: p.x < midX ? "posts-left" : "posts-right", x: p.x, y: p.y, out: outOf(p.x), gap: p.gap, crossbar: 3 * M, top: league ? 16 * M : 3 * M + 3.4 * M, post, support: "none", cls: "u-white" }));
+            flags(dots(plan, "flag-post", "corner-post"), 1.2 * M, "flags");
+            break;
+        }
+        case "gaelic": {
+            // GAA Official Guide Part 2 (2026) Rule 1.3 (i), (ii): posts not less than 7 m above the ground and 6.5 m apart, the crossbar 2.5 m above the ground. Rule 1.7 gives
+            // the flags no height; 1.5 m is ours.
+            for (const p of pairs(dots(plan, "goalpost")))
+                items.push(postPair({ id: p.x < midX ? "posts-left" : "posts-right", x: p.x, y: p.y, out: outOf(p.x), gap: p.gap, crossbar: 2.5 * M, top: 7 * M, post, support: "none", cls: "u-white" }));
+            flags(dots(plan, "flag"), 1.5 * M, "flags");
+            break;
+        }
+        case "afl": {
+            // Laws of Australian Football 2026, Law 3.3.1: goal posts 6 to 15 m high and 6.4 m apart, behind posts 3 to 10 m high, 6.4 m either side of them: the least is drawn.
+            const goals = dots(plan, "goal-post");
+            const behinds = dots(plan, "behind-post");
+            for (const end of ["left", "right"]) {
+                const left = end === "left";
+                const mine = (p) => (p.x < midX) === left;
+                const planes = [
+                    ...goals.filter(mine).flatMap((p, i) => pole(`goal-post-${i}`, "post", p.x, p.y, 0, 6 * M, post, "u-white")),
+                    ...behinds.filter(mine).flatMap((p, i) => pole(`behind-post-${i}`, "post", p.x, p.y, 0, 3 * M, post, "u-white")),
+                ];
+                items.push({ id: `posts-${end}`, kind: "goalposts", at: [left ? 0 : plan.length, plan.width / 2], height: 6 * M, low: 3 * M, planes });
+            }
+            break;
+        }
+        case "cricket": {
+            // MCC Laws of Cricket, Law 8.1 and 8.2: three stumps across a wicket 9 in wide, their tops 28 in over the playing surface.
+            for (const s of plan.shapes) {
+                if (s.kind !== "bar" || s.id !== "wicket")
+                    continue;
+                const x = (s.x0 + s.x1) / 2;
+                const ys = [s.y0, (s.y0 + s.y1) / 2, s.y1];
+                items.push({ id: x < midX ? "stumps-left" : "stumps-right", kind: "stumps", at: [x, (s.y0 + s.y1) / 2], height: 28 / 12, planes: ys.flatMap((y, i) => pole(`stump-${i}`, "stump", x, y, 0, 28 / 12, Math.max(thin * 0.9, 0.12), "u-wood")) });
+            }
+            break;
+        }
+        case "lacrosse":
+        case "fieldhockey":
+        case "handball": {
+            // The goal: World Lacrosse 6 ft apart and high on a field, 4 ft high in a box; FIH 2.14 m to the crossbar's lower edge; IHF interior height 2 m (docs/sources.md).
+            const box = plan.league === "nll" || plan.league === "world-box";
+            for (const g of plan.goals) {
+                const height = plan.sport === "lacrosse" ? (box ? 4 : 6) : plan.sport === "handball" ? 2 * M : 2.14 * M;
+                items.push(goalCage({ id: `goal-${g.end}`, x: g.x, y: g.y, out: g.out, width: g.width, height, depth: g.depth, top: g.depth * (plan.sport === "lacrosse" ? 0.7 : 0.85), post: Math.max(thin * 1.3, 0.3), cell: Math.max(thin * 6, 0.5), tone: "white" }));
+            }
+            break;
+        }
+        default:
+    }
+    return items;
+}
+/** The fence's height where no wall is listed: 8 feet. */
+export const FENCE_HEIGHT = 8;
+/** How high the wall stands at an angle from dead centre, the wall that names it or the usual 8 feet. */
+export const wallHeightAt = (walls, angle) => walls.find((w) => angle >= Math.min(w.from, w.to) && angle <= Math.max(w.from, w.to))?.height_ft ?? FENCE_HEIGHT;
+/** The planes of a fence: one standing wall over each stretch of its line, as high as the wall there. */
+export function fencePlanes(points, walls, thin) {
+    const line = fenceOutline(points, 3).map(([u, v]) => [u, -v]);
+    const planes = [];
+    for (let i = 0; i < line.length - 1; i += 1) {
+        const [x0, y0] = line[i];
+        const [x1, y1] = line[i + 1];
+        const run = Math.hypot(x1 - x0, y1 - y0);
+        if (run < 1e-6)
+            continue;
+        const angle = Math.atan2((x0 + x1) / 2, -(y0 + y1) / 2) * (180 / Math.PI);
+        const height = wallHeightAt(walls, angle);
+        planes.push(wall(`fence-${i}`, "wall", x0, y0, x1, y1, 0, height, `<rect width="${n(run)}" height="${n(height)}" class="u-wall"/><rect width="${n(run)}" height="${n(Math.max(thin * 0.8, 0.2))}" class="u-cap"/>`));
+    }
+    return planes;
+}
+/**
+ * A ballpark's uprights: the fence, the two foul poles where the foul lines meet it, and the backstop behind home plate. Official Baseball Rules 2025, 2.01, gives no height
+ * for a fence or a foul pole, and only recommends the backstop 60 ft or more from home base: the 8 ft of the fence where no wall is listed, the poles' 30 ft and the
+ * screen's 70 ft by 20 ft are ours.
+ */
+export function ballparkUprights(points, walls, thin) {
+    const items = [];
+    const fence = fencePlanes(points, walls, thin);
+    const tops = fence.map((p) => -p.v[2]);
+    items.push({ id: "fence", kind: "fence", at: [0, -400], height: Math.min(...tops), low: Math.max(...tops), planes: fence });
+    const poles = [];
+    // The foul poles stand where the foul lines meet the fence, 45 degrees either side of dead centre.
+    for (const angle of [-45, 45]) {
+        const d = fenceAt(points, angle);
+        const t = (angle * Math.PI) / 180;
+        poles.push(...pole(`foul-pole-${angle < 0 ? "left" : "right"}`, "pole", d * Math.sin(t), -d * Math.cos(t), 0, 30, Math.max(thin * 1.6, 0.5), "u-yellow"));
+    }
+    items.push({ id: "foul-poles", kind: "foul-poles", at: [0, -330], height: 30, planes: poles });
+    // The backstop: the rules put it at least 60 feet behind home plate. A screen 70 feet wide and 20 high.
+    items.push({ id: "backstop", kind: "backstop", at: [0, 60], height: 20, planes: [wall("backstop", "screen", -35, 60, 35, 60, 0, 20, `<rect width="70" height="20" class="u-netfill"/>${threads(mesh(70, 20, 3), 3)}`)] });
+    return items;
+}

package/dist/uprights.goal.d.ts

@@ -0,0 +1,49 @@
+import { type Plane, type Upright } from "./turn.kit.ts";
+/** A goal with a net: the mouth on the line x, the net behind it. */
+export interface GoalCage {
+    id: string;
+    /** Where the middle of the mouth stands on its goal line, and which way the net lies behind it: +1 to larger x, -1 to smaller. */
+    x: number;
+    y: number;
+    out: 1 | -1;
+    /** The mouth: its width across the surface and its height. */
+    width: number;
+    height: number;
+    /** How far the net reaches behind the line at the ground, and at the top of the back. */
+    depth: number;
+    top: number;
+    /** The frame's thickness, and the mesh's cell, in feet. */
+    post: number;
+    cell: number;
+    /** The frame's paint: white, or red as a hockey goal's. */
+    tone: "white" | "red";
+}
+/** A goal: its mouth as three strips (two posts and the crossbar), and its net as four planes, framed. */
+export declare function goalCage(g: GoalCage): Upright;
+/** A pair of uprights with a crossbar between them, standing on the line x (a rugby, Gaelic football or football post). */
+export interface PostPair {
+    id: string;
+    x: number;
+    y: number;
+    /** Which way is behind the goal line, for a post's support. */
+    out: 1 | -1;
+    /** The space between the two uprights, to the middle of each. */
+    gap: number;
+    /** The crossbar's height, and the uprights' top, above the surface. */
+    crossbar: number;
+    top: number;
+    /** The strips' thickness. */
+    post: number;
+    /** `slingshot`: one support behind the goal, bent to carry the crossbar (a football post); `centre`: one pole straight under the crossbar's middle; `none`: the uprights alone. */
+    support: "slingshot" | "centre" | "none";
+    /** How far behind the goal line a slingshot's support stands. */
+    stem?: number;
+    /** The class of the paint: `u-yellow` for a football post, `u-white` for the others. */
+    cls: string;
+}
+/** A pair of uprights, a crossbar, and the support under them. */
+export declare function postPair(p: PostPair): Upright;
+/** A flag on a pole, the flag lying along x. */
+export declare function flagPole(id: string, x: number, y: number, height: number, post: number, cls?: string): Plane[];
+/** A short rectangle lying flat, such as the foot of a stanchion or the shadow of a table: used where a pole needs a base. */
+export declare function foot(id: string, x: number, y: number, w: number, d: number): Plane;

package/dist/uprights.goal.js

@@ -0,0 +1,69 @@
+// The parts that more than one sport has: a goal with its net behind it (soccer, hockey, handball, field hockey, lacrosse), a pair of upright posts with a
+// crossbar (football, rugby, Gaelic football), the posts of Australian football, a flag on a pole. Every number is in feet, in the drawing's own frame.
+import { bar, flat, mesh, n, plane, pole, polygon, threads, wall } from "./turn.kit.js";
+/** The mesh over the side of a net, a trapezoid: the front edge is straight up, the back leans out from `top` at the head to `depth` at the ground. */
+function sideMesh(depth, top, height, cell) {
+    const wide = Math.max(1, Math.round(depth / cell));
+    const high = Math.max(1, Math.round(height / cell));
+    let d = "";
+    for (let i = 1; i < wide; i += 1)
+        d += `M${n((top * i) / wide)} 0L${n((depth * i) / wide)} ${n(height)}`;
+    for (let j = 1; j < high; j += 1) {
+        const b = (height * j) / high;
+        d += `M0 ${n(b)}H${n(top + ((depth - top) * j) / high)}`;
+    }
+    return d;
+}
+/** A goal: its mouth as three strips (two posts and the crossbar), and its net as four planes, framed. */
+export function goalCage(g) {
+    const { id, x, y, out, width, height, depth, top, post, cell } = g;
+    const half = width / 2;
+    const cls = g.tone === "red" ? "u-red" : "u-white";
+    const line = `class="u-frame u-frame-${g.tone}" stroke-width="${n(post * 0.7)}" fill="none" stroke-linejoin="round"`;
+    const planes = [];
+    // The mouth.
+    planes.push(...pole(`${id}-post-a`, "post", x, y - half, 0, height, post, cls), ...pole(`${id}-post-b`, "post", x, y + half, 0, height, post, cls));
+    planes.push(...bar(`${id}-bar`, "post", [x, y - half, height], [x, y + half, height], post, cls));
+    // The two sides: a trapezoid hanging from the head, leaning out to the back.
+    for (const [tag, ys] of [["a", y - half], ["b", y + half]]) {
+        const shape = polygon([[0, 0], [top, 0], [depth, height], [0, height]]);
+        planes.push(plane(`${id}-side-${tag}`, "goal", [x, ys, height], [out * depth, 0, 0], [0, 0, -height], `<path d="${shape}" class="u-netfill"/>${threads(sideMesh(depth, top, height, cell), cell)}<path d="${shape}" ${line}/>`));
+    }
+    // The back leans from the head's depth out to the ground's.
+    const lean = out * (depth - top);
+    planes.push(plane(`${id}-back`, "goal", [x + out * top, y - half, height], [0, width, 0], [lean, 0, -height], `<rect width="${n(width)}" height="${n(Math.hypot(lean, height))}" class="u-netfill"/>${threads(mesh(width, Math.hypot(lean, height), cell), cell)}<rect width="${n(width)}" height="${n(Math.hypot(lean, height))}" ${line}/>`));
+    // The roof.
+    planes.push(plane(`${id}-roof`, "goal", [x, y - half, height], [0, width, 0], [out * top, 0, 0], `<rect width="${n(width)}" height="${n(top)}" class="u-netfill"/>${threads(mesh(width, top, cell), cell)}<rect width="${n(width)}" height="${n(top)}" ${line}/>`));
+    return { id, kind: "goal", at: [x, y], height, planes };
+}
+/** A pair of uprights, a crossbar, and the support under them. */
+export function postPair(p) {
+    const { id, x, y, gap, crossbar, top, post, cls } = p;
+    const half = gap / 2;
+    // A slingshot's uprights begin at the crossbar; the others stand on the ground.
+    const from = p.support === "slingshot" ? crossbar : 0;
+    const planes = [
+        ...pole(`${id}-upright-a`, "post", x, y - half, from, top, post, cls),
+        ...pole(`${id}-upright-b`, "post", x, y + half, from, top, post, cls),
+        ...bar(`${id}-bar`, "post", [x, y - half, crossbar], [x, y + half, crossbar], post, cls),
+    ];
+    if (p.support === "slingshot") {
+        const sx = x + p.out * (p.stem ?? 4);
+        planes.push(...pole(`${id}-stem`, "stanchion", sx, y, 0, crossbar, post * 1.4, cls), ...bar(`${id}-neck`, "stanchion", [sx, y, crossbar], [x, y, crossbar], post, cls));
+    }
+    else if (p.support === "centre")
+        planes.push(...pole(`${id}-stem`, "stanchion", x, y, 0, crossbar, post * 1.4, cls));
+    return { id, kind: "goalposts", at: [x, y], height: top, low: crossbar, planes };
+}
+/** A flag on a pole, the flag lying along x. */
+export function flagPole(id, x, y, height, post, cls = "u-white") {
+    const flag = Math.max(height * 0.28, post * 3);
+    return [
+        ...pole(id, "pole", x, y, 0, height, post, cls),
+        wall(`${id}-flag`, "flag", x, y, x + flag, y, height - flag * 0.7, height, `<path d="${polygon([[0, 0], [flag, flag * 0.35], [0, flag * 0.7]])}" class="u-flag"/>`),
+    ];
+}
+/** A short rectangle lying flat, such as the foot of a stanchion or the shadow of a table: used where a pole needs a base. */
+export function foot(id, x, y, w, d) {
+    return flat(id, "leg", x - w / 2, y - d / 2, x + w / 2, y + d / 2, 0.01, `<rect width="${n(w)}" height="${n(d)}" class="u-foot"/>`);
+}

package/dist/uprights.js

@@ -0,0 +1,160 @@
+// What stands on a surface, in 3D: `uprightsFor` reads the options as `drawKyogijo` does (the sport, the league, the season, the park) and says what stands on the
+// surface, where and how high, as planes in the drawing's own frame (x along the surface and y across it, in feet, z the height above it). Pure: no page, no
+// stylesheet. `describeUprights` says the same in words, for a reader who cannot see it.
+import { courtFor, courtGeometry, isNetSport } from "./court.js";
+import { drawingId, feetFence, lengthUnit } from "./common.js";
+import { drawKyogijo, pitchOf } from "./draw.js";
+import { rulesFor, footballIn } from "./eras.js";
+import { fieldPlan, isFieldSport } from "./fields.js";
+import { footballLength } from "./geometry.js";
+import { diamondFence } from "./leagues/baseball.js";
+import { NBA_COURT } from "./leagues/basketball.js";
+import { NHL_RINK } from "./leagues/hockey.js";
+import { chooseLeague, courtOf, diamondOf, fieldOf, rinkOf } from "./leagues.js";
+import { fenceFor, parkById, parkWallsIn } from "./parks.js";
+import { fenceOutline } from "./surfaces/baseball.js";
+import { KYOGIJO_STRINGS, fill } from "./strings.js";
+import { soccerSpec } from "./surfaces/soccer-spec.js";
+import { thinnest } from "./turn.kit.js";
+import { scoreboard } from "./uprights.board.js";
+import { ballparkUprights, fieldUprights, footballUprights, soccerUprights } from "./uprights.fields.js";
+import { netUprights } from "./uprights.net.js";
+import { isPoolSport, poolPlan, feet as poolFeet } from "./pool.js";
+import { poolUprights } from "./uprights.pools.js";
+import { athleticsUprights, skatingUprights } from "./uprights.track.js";
+import { courtUprights, rinkUprights } from "./uprights.rinks.js";
+import { convertLength } from "./units.js";
+import { sheetFor } from "./sheet.js";
+/** All the planes of all the things. */
+export const planesOf = (u) => u.items.flatMap((item) => item.planes);
+/** The unit each sport's rulebook gives its heights in, when the options name none. */
+const RULEBOOK_UNIT = { volleyball: "m", badminton: "m", tabletennis: "m", padel: "m", squash: "m", athletics: "m", skating: "m", swimming: "m", waterpolo: "m", diving: "m", artisticswimming: "m", sepaktakraw: "m", teqball: "m", roundnet: "m", netball: "m", soccer: "m", handball: "m", fieldhockey: "m", rugby: "m", afl: "m", gaelic: "m" };
+/** What stands on the surface the options draw: nothing on a curling sheet, which is flat. */
+export function uprightsFor(o, settings = {}) {
+    const { sport, league } = chooseLeague(o);
+    const unit = lengthUnit(o);
+    let items = [];
+    let lift = 0;
+    let thin = 0.2;
+    let area;
+    if (sport === "nfl" || sport === "cfl" || sport === "ifaf") {
+        const spec = league?.family === "football" ? fieldOf(league, o.year) : footballIn(sport, o.year);
+        const shape = league?.family === "football" || sport === "ifaf" ? "slingshot" : rulesFor(sport, o.year).rules.postShape;
+        thin = thinnest(footballLength(spec), spec.width);
+        area = { x0: 0, y0: 0, x1: footballLength(spec), y1: spec.width };
+        // Over the ground: the NFL's 10 + 35 ft, the CFL's 40 ft, and the NCAA's least 30 ft for the rest.
+        items = footballUprights(spec, shape, league !== undefined ? 30 : sport === "nfl" ? 45 : sport === "cfl" ? 40 : 30, thin);
+    }
+    else if (sport === "nhl") {
+        const rink = league?.family === "hockey" ? rinkOf(league, o.year) : NHL_RINK;
+        const goalLine = league?.family === "hockey" ? rink.goalLine : rulesFor("nhl", o.year).rules.goalLine;
+        thin = thinnest(rink.length, rink.width);
+        area = { x0: 0, y0: 0, x1: rink.length, y1: rink.width };
+        items = rinkUprights(rink, goalLine, thin, settings.boards !== false);
+    }
+    else if (sport === "nba") {
+        const court = league?.family === "basketball" ? courtOf(league, o.year) : NBA_COURT;
+        thin = thinnest(court.length, court.width);
+        area = { x0: 0, y0: 0, x1: court.length, y1: court.width };
+        items = courtUprights(court, thin, league?.id === "fiba");
+    }
+    else if (sport === "mlb") {
+        const diamond = league?.family === "baseball" ? diamondOf(league, o.year) : undefined;
+        const park = parkById(o.park);
+        const points = fenceFor(park, feetFence(o.fence, unit), o.year, diamond === undefined ? undefined : diamondFence(diamond));
+        thin = 0.4;
+        items = ballparkUprights(points, park === undefined ? [] : parkWallsIn(park, o.year), thin);
+        // The surface is the field out to the fence and the backstop behind home plate.
+        const out = fenceOutline(points, 3).map(([u, v]) => [u, -v]);
+        area = { x0: Math.min(...out.map((p) => p[0])), x1: Math.max(...out.map((p) => p[0])), y0: Math.min(...out.map((p) => p[1])), y1: 70 };
+    }
+    else if (sport === "soccer") {
+        const spec = soccerSpec(pitchOf(o), o.units === undefined ? "m" : unit);
+        thin = thinnest(spec.length * 3.2808, spec.width * 3.2808);
+        area = { x0: 0, y0: 0, x1: spec.length * 3.2808, y1: spec.width * 3.2808 };
+        items = soccerUprights(spec, o.cornerFlags !== false, thin);
+    }
+    else if (isNetSport(sport)) {
+        const plan = courtFor({ ...o, sport });
+        const geo = courtGeometry(plan);
+        thin = thinnest(geo.length, geo.width);
+        area = { x0: 0, y0: 0, x1: geo.length, y1: geo.width };
+        const built = netUprights(plan, geo, { netHeight: settings.netHeight, boards: settings.boards }, thin);
+        items = built.items;
+        lift = built.lift;
+    }
+    else if (isPoolSport(sport)) {
+        const plan = poolPlan({ sport, pool: o.pool });
+        const [w, h] = [poolFeet(plan.length), poolFeet(plan.width)];
+        thin = thinnest(w, h);
+        area = { x0: 0, y0: 0, x1: w, y1: h };
+        items = poolUprights({ ...o, sport }, thin).items;
+    }
+    else if (sport === "athletics") {
+        const built = athleticsUprights({ ...o, sport }, 0.3);
+        area = built.area;
+        thin = thinnest(area.x1, area.y1);
+        items = athleticsUprights({ ...o, sport }, thin).items;
+    }
+    else if (sport === "skating") {
+        const built = skatingUprights({ ...o, sport }, 0.3);
+        area = built.area;
+        thin = thinnest(area.x1, area.y1);
+        items = skatingUprights({ ...o, sport }, thin).items;
+    }
+    else if (isFieldSport(sport)) {
+        const plan = fieldPlan({ ...o, sport });
+        thin = thinnest(plan.length, plan.width);
+        area = { x0: 0, y0: 0, x1: plan.length, y1: plan.width };
+        items = fieldUprights(plan, thin);
+    }
+    if (sport === "curling") {
+        const sheet = sheetFor(o).spec;
+        thin = thinnest(sheet.length, sheet.width);
+        area = { x0: 0, y0: 0, x1: sheet.length, y1: sheet.width };
+    }
+    // The score, hung up: the badge on a board that turns to face the eye.
+    const scored = o.home !== undefined && o.away !== undefined && o.size !== "badge";
+    if (scored && settings.score !== "floor" && area !== undefined) {
+        const board = scoreboard(drawKyogijo({ ...o, size: "badge", style: "none", id: `${drawingId(o)}-board` }), sport, area, thin);
+        if (board !== undefined)
+            items.push(board);
+    }
+    if (settings.only !== undefined)
+        items = items.filter((item) => settings.only.includes(item.kind));
+    return { items, lift, thin, area };
+}
+/** A length in feet as a rulebook would print it in `unit`: metres to the centimetre, feet to a tenth. */
+function said(feet, unit, language) {
+    const value = convertLength(feet, "ft", unit);
+    const text = String(Math.round(value * (unit === "m" ? 100 : 10)) / (unit === "m" ? 100 : 10));
+    const units = KYOGIJO_STRINGS[language].league.units;
+    return `${text} ${units[unit === "m" || unit === "yd" ? unit : "ft"]}`;
+}
+/** The unit the heights are said in: the options' own, else the rulebook's of the sport. */
+export function heightUnit(o) {
+    if (o.units !== undefined)
+        return lengthUnit(o);
+    const { sport, league } = chooseLeague(o);
+    return league?.unit ?? RULEBOOK_UNIT[sport] ?? "ft";
+}
+/** What stands on the surface, in a sentence, with heights: for a reader who cannot see the 3D view. An empty string when nothing stands on it. */
+export function describeUprights(o, uprights, language = "en") {
+    const words = KYOGIJO_STRINGS[language].turn;
+    const unit = heightUnit(o);
+    // One entry for each kind, and for a kind that has two (a goal at each end) the first: both are the same.
+    const seen = new Set();
+    const list = [];
+    for (const item of uprights.items) {
+        if (seen.has(item.kind))
+            continue;
+        seen.add(item.kind);
+        if (item.height <= 0)
+            continue;
+        const name = words.parts[item.kind];
+        // A rink's boards are said by the top of the glass; a table by the height of its top.
+        const height = item.kind === "boards" ? (item.low ?? item.height) : item.height;
+        list.push(item.kind === "net" && item.low !== undefined && Math.abs(item.low - item.height) > 0.02 ? fill(words.itemSag, { name, h: said(height, unit, language), low: said(item.low, unit, language) }) : fill(words.item, { name, h: said(height, unit, language) }));
+    }
+    return list.length === 0 ? "" : fill(words.standing, { list: list.join(KYOGIJO_STRINGS[language].layers.listSep) });
+}

package/dist/uprights.more.d.ts

@@ -0,0 +1,7 @@
+import type { CourtGeometry, CourtPlan } from "./court.ts";
+import type { NetEnd } from "./uprights.net.ts";
+/** The uprights of the court sports that have walls, a table, a ring or a net of their own: padel, squash, racquetball, sepak takraw, teqball, roundnet and netball. */
+export declare function moreUprights(plan: CourtPlan, geo: CourtGeometry, settings: {
+    netHeight?: "men" | "women";
+    boards?: boolean;
+}, thin: number): NetEnd;

package/dist/uprights.more.js

@@ -0,0 +1,183 @@
+import { bar, mesh, n, plane, pole, polygon, shy, threads, wall } from "./turn.kit.js";
+import { netPlane, sag, tableBody } from "./uprights.netkit.js";
+import { convertLength } from "./units.js";
+const feet = (metres) => convertLength(metres, "m", "ft");
+/** The walls of a court, each giving way when it is between the eye and the court. */
+const shyAll = (planes, geo) => planes.map((p) => shy(p, [geo.length / 2, geo.width / 2]));
+/** The posts of a court at the fixtures' places, `height` high. */
+const postsOf = (geo, x, y0, y1, height, thin) => ({
+    id: "posts",
+    kind: "netposts",
+    at: [x, (y0 + y1) / 2],
+    height,
+    planes: geo.posts.flatMap((p, i) => pole(`post-${i === 0 ? "a" : "b"}`, "post", p.x, p.y, 0, height, Math.max(p.size, thin * 1.4), "u-pole")),
+});
+/** The line a wall stands on: the inner edge of the band that stands for it, from end to end of the court's side. */
+function standsOn(band, L, W) {
+    const [a, b, c, d] = band.rect;
+    if (c - a < d - b) {
+        const x = c <= L / 2 ? c : a;
+        return [x, Math.max(b, 0), x, Math.min(d, W)];
+    }
+    const y = d <= W / 2 ? d : b;
+    return [Math.max(a, 0), y, Math.min(c, L), y];
+}
+/** A solid or glass wall between two heights along a line, with a cap along its top. */
+function solidWall(id, x0, y0, x1, y1, z0, z1, cls, thin) {
+    const run = Math.hypot(x1 - x0, y1 - y0);
+    return wall(id, "wall", x0, y0, x1, y1, z0, z1, `<rect width="${n(run)}" height="${n(z1 - z0)}" class="${cls}"/><rect width="${n(run)}" height="${n(Math.max(thin * 0.8, 0.1))}" class="u-cap"/>`);
+}
+/** Metal fence between two heights: a mesh. */
+function fencing(id, x0, y0, x1, y1, z0, z1, cell) {
+    const run = Math.hypot(x1 - x0, y1 - y0);
+    const h = z1 - z0;
+    return wall(id, "wall", x0, y0, x1, y1, z0, z1, `<rect width="${n(run)}" height="${n(h)}" class="u-netfill"/>${threads(mesh(run, h, cell), cell)}`);
+}
+/**
+ * A padel court's enclosure (The Court: Enclosures): the end walls 3 m of wall with 1 m of metal fence over them, 4 m in all; at each end of each side a wall 3 m high and
+ * 4 m long, and the fence between. The part of the Rules read gives the fence along the sides no height of its own: it is drawn as high as the side walls, 3 m (ours).
+ */
+function padelWalls(f, geo, thin) {
+    const { length: L, width: W } = geo;
+    const cell = Math.max(feet(0.045), thin * 5);
+    const planes = [];
+    geo.bands.forEach((band, i) => {
+        const [x0, y0, x1, y1] = standsOn(band, L, W);
+        if (Math.hypot(x1 - x0, y1 - y0) <= 0)
+            return;
+        if (band.kind === "mesh")
+            planes.push(fencing(`fence-${i}`, x0, y0, x1, y1, 0, f.enclosure.sideHeight, cell));
+        else if (x0 === x1)
+            planes.push(solidWall(`wall-${i}`, x0, y0, x1, y1, 0, f.enclosure.endWall, "u-glass", thin), fencing(`fence-${i}`, x0, y0, x1, y1, f.enclosure.endWall, f.enclosure.endHeight, cell));
+        else
+            planes.push(solidWall(`wall-${i}`, x0, y0, x1, y1, 0, f.enclosure.sideHeight, "u-glass", thin));
+    });
+    return { id: "walls", kind: "walls", at: [L / 2, W / 2], height: f.enclosure.endHeight, planes: shyAll(planes, geo) };
+}
+/**
+ * A squash court's walls, up to their out lines: the front wall to the front wall line (4.57 m), the back wall to the back wall line (2.13 m), and each side wall between
+ * them, its top running straight from the one to the other (only its two ends are among the figures; the straight line is ours). The front wall is solid, the rest glass.
+ */
+function squashWalls(f, geo, thin) {
+    const { length: L, width: W } = geo;
+    const front = f.wall.frontWallLine;
+    const back = f.wall.backWallLine;
+    const planes = [solidWall("wall-front", 0, 0, 0, W, 0, front, "u-wall", thin), solidWall("wall-back", L, 0, L, W, 0, back, "u-glass", thin)];
+    const side = polygon([[0, 0], [L, front - back], [L, front], [0, front]]);
+    for (const [id, y] of [["wall-side-a", 0], ["wall-side-b", W]])
+        planes.push(wall(id, "wall", 0, y, L, y, 0, front, `<path d="${side}" class="u-glass"/>`));
+    return { id: "walls", kind: "walls", at: [L / 2, W / 2], height: front, planes: shyAll(planes, geo) };
+}
+/** A racquetball court's walls, 20 feet high all round (Rule 2.1(a): the court is 20 feet high, the back wall at least 12), the front wall solid and the others glass. */
+function racquetballWalls(f, geo, thin) {
+    const { length: L, width: W } = geo;
+    const h = f.height;
+    const planes = [
+        solidWall("wall-front", 0, 0, 0, W, 0, h, "u-wall", thin),
+        solidWall("wall-back", L, 0, L, W, 0, h, "u-glass", thin),
+        solidWall("wall-side-a", 0, 0, L, 0, 0, h, "u-glass", thin),
+        solidWall("wall-side-b", 0, W, L, W, 0, h, "u-glass", thin),
+    ];
+    return { id: "walls", kind: "walls", at: [L / 2, W / 2], height: h, planes: shyAll(planes, geo) };
+}
+/** A roundnet set: a net stretched in a ring 91.4 cm across, its rim 20.3 cm over the ground, on four legs (Rule 1.1.2). */
+function roundnetSet(f, geo, thin) {
+    const solid = geo.solids.find((one) => one.kind === "set");
+    const cx = solid?.kind === "set" ? solid.cx : geo.length / 2;
+    const cy = solid?.kind === "set" ? solid.cy : geo.width / 2;
+    const r = f.set.diameter / 2;
+    const h = f.set.height;
+    const rim = Math.max(feet(0.02), thin * 1.5);
+    const ring = (rr) => `M${n(r - rr)} ${n(r)}a${n(rr)} ${n(rr)} 0 1 0 ${n(2 * rr)} 0a${n(rr)} ${n(rr)} 0 1 0 ${n(-2 * rr)} 0`;
+    let lines = [0.34, 0.67].map((k) => ring(r * k)).join("");
+    for (let i = 0; i < 8; i += 1) {
+        const a = (Math.PI * i) / 8;
+        lines += `M${n(r - r * Math.cos(a))} ${n(r - r * Math.sin(a))}L${n(r + r * Math.cos(a))} ${n(r + r * Math.sin(a))}`;
+    }
+    const top = plane("set-net", "net", [cx - r, cy - r, h], [2 * r, 0, 0], [0, 2 * r, 0], `<circle cx="${n(r)}" cy="${n(r)}" r="${n(r)}" class="u-netfill"/>${threads(lines, r / 3)}<circle cx="${n(r)}" cy="${n(r)}" r="${n(r - rim / 2)}" class="u-rimline" stroke-width="${n(rim)}" fill="none"/>`);
+    const legs = [];
+    for (let i = 0; i < 4; i += 1) {
+        const a = Math.PI / 4 + (Math.PI * i) / 2;
+        legs.push(...pole(`leg-${i}`, "leg", cx + r * 0.9 * Math.cos(a), cy + r * 0.9 * Math.sin(a), 0, h, Math.max(feet(0.02), thin * 1.2), "u-leg"));
+    }
+    return { id: "net", kind: "net", at: [cx, cy], height: h, planes: [top, ...legs] };
+}
+/** A netball goalpost, 3.05 m high, at the middle of each goal line, with its ring on a bar that projects 150 mm from the pole (Rule 1, items 13 and 14). */
+function netballPosts(f, geo, thin) {
+    const { length: L, width: W } = geo;
+    const h = f.post.height;
+    const { inside, rod, bar: reach } = f.post.ring;
+    const d = f.post.poleDiameter;
+    const R = inside / 2 + rod;
+    const cy = W / 2;
+    const planes = [];
+    for (const left of [true, false]) {
+        const tag = left ? "left" : "right";
+        const sign = left ? 1 : -1;
+        const x = left ? d / 2 : L - d / 2;
+        const cx = x + sign * (d / 2 + reach + R);
+        planes.push(...pole(`pole-${tag}`, "post", x, cy, 0, h, Math.max(d, thin * 1.4), "u-pole"));
+        planes.push(...bar(`bar-${tag}`, "post", [x, cy, h], [cx - sign * R, cy, h], Math.max(rod, thin * 1.2), "u-pole"));
+        const line = Math.max(rod, thin * 1.6);
+        planes.push(plane(`ring-${tag}`, "rim", [cx - R, cy - R, h], [2 * R, 0, 0], [0, 2 * R, 0], `<circle cx="${n(R)}" cy="${n(R)}" r="${n(R - line / 2)}" class="u-rimline" stroke-width="${n(line)}" fill="none"/>`));
+    }
+    return { id: "goalposts", kind: "goalposts", at: [L / 2, cy], height: h, planes };
+}
+/** The uprights of the court sports that have walls, a table, a ring or a net of their own: padel, squash, racquetball, sepak takraw, teqball, roundnet and netball. */
+export function moreUprights(plan, geo, settings, thin) {
+    const items = [];
+    const { x, y0, y1 } = geo.net ?? { x: geo.length / 2, y0: 0, y1: geo.width };
+    const at = [x, (y0 + y1) / 2];
+    const walls = settings.boards !== false;
+    switch (plan.sport) {
+        case "padel": {
+            const f = plan.figures;
+            const { heightCentre: c, heightEnds: e, postHeight: p } = f.net;
+            const cell = Math.max(feet(0.045), thin * 5);
+            items.push({ id: "net", kind: "net", at, height: e, low: c, planes: [netPlane({ id: "net", x, y0, y1, top: sag(y0, y1, c, e), bottom: () => 0, cell, tape: Math.max(feet(0.05), thin) }, 0)] });
+            items.push(postsOf(geo, x, y0, y1, p, thin));
+            if (walls)
+                items.push(padelWalls(f, geo, thin));
+            break;
+        }
+        case "squash":
+            if (walls)
+                items.push(squashWalls(plan.figures, geo, thin));
+            break;
+        case "racquetball":
+            if (walls)
+                items.push(racquetballWalls(plan.figures, geo, thin));
+            break;
+        case "sepaktakraw": {
+            const f = plan.figures;
+            const women = settings.netHeight === "women";
+            const centre = women ? f.net.heightWomen : f.net.heightMen;
+            const post = women ? f.net.postWomen : f.net.postMen;
+            const top = sag(y0, y1, centre, post);
+            const cell = Math.max(feet(0.045), thin * 5);
+            items.push({ id: "net", kind: "net", at, height: post, low: centre, planes: [netPlane({ id: "net", x, y0, y1, top, bottom: (y) => top(y) - f.net.width, cell, tape: Math.max(feet(0.05), thin) }, 0)] });
+            items.push(postsOf(geo, x, y0, y1, post, thin));
+            break;
+        }
+        case "teqball": {
+            const f = plan.figures;
+            // The table is 900 mm high with its net (1.1.4) and the net stands 140 mm over it (1.2.3): the top is 760 mm up.
+            const lift = f.table.height - f.net.height;
+            const solid = geo.solids.find((one) => one.kind === "table");
+            const [tx0, ty0, tx1, ty1] = solid?.kind === "table" ? solid.rect : [0, 0, geo.length, geo.width];
+            const cell = Math.max(feet(0.02), thin * 3);
+            items.push({ id: "net", kind: "net", at, height: lift + f.net.height, planes: [netPlane({ id: "net", x, y0, y1, top: () => f.net.height, bottom: () => 0, cell, tape: Math.max(feet(0.02), thin * 0.8) }, lift)] });
+            items.push({ id: "table", kind: "table-legs", at: [(tx0 + tx1) / 2, (ty0 + ty1) / 2], height: lift, planes: tableBody(tx0, ty0, tx1, ty1, lift, thin, true) });
+            break;
+        }
+        case "roundnet":
+            items.push(roundnetSet(plan.figures, geo, thin));
+            break;
+        case "netball":
+            items.push(netballPosts(plan.figures, geo, thin));
+            break;
+        default:
+            break;
+    }
+    return { items, lift: 0 };
+}