@johnmorrisdotca/kyogijo-stadiums 0.4.0 → 0.6.0

package/dist/uprights.budo.js

@@ -0,0 +1,87 @@
+// What stands on a budō surface, in 3D: the dohyō's clay mound (the clay square stands 34 cm to 60 cm over the floor of the hall, Sumo Rules, Dohyō Regulations, Article 1), the azuchi of a kyūdōjō with the
+// targets on it (36 cm across and 27 cm over the mound's base, tilted 5 degrees; 100 cm, 97 cm and 15 degrees for enteki), and the walls of a dojo. A judo, karate or kendo surface lies flat: nothing stands on it
+// (a judo platform's height is not in the rules: "it depends on the sightlines"). The plans are in metres in the frame of their own origin, and the drawing's frame is feet from the corner of the plan's
+// box, so every point goes through `at`. The mound's height is the option's; the azuchi's (1.5 m or 1.8 m) and a dojo wall's (3 m) are ours: no rule gives them.
+import { budoPlan } from "./budo/plan.js";
+import { n, plane, shy, wall } from "./turn.kit.js";
+const K = 1 / 0.3048;
+/** The walls of a dojo, 3 m high (ours). */
+export const DOJO_WALL = 3;
+/** The planes of the dohyō's clay mound: its four sides, from the floor of the hall up to the clay. */
+function moundPlanes(plan, at, height) {
+    const L = plan.sumo;
+    if (L === undefined)
+        return [];
+    const b = L.platform;
+    const corners = [at(b.x0, b.y0), at(b.x1, b.y0), at(b.x1, b.y1), at(b.x0, b.y1)];
+    const planes = [];
+    corners.forEach((a, i) => {
+        const c = corners[(i + 1) % 4];
+        planes.push(wall(`mound-${i + 1}`, "wall", a[0], a[1], c[0], c[1], 0, height, `<rect width="${n(Math.hypot(c[0] - a[0], c[1] - a[1]))}" height="${n(height)}" class="u-clay"/>`));
+    });
+    return planes;
+}
+/** The azuchi's face, a slope from the foot of the mound up to its top, and the target of each shooter standing against it. */
+function azuchiPlanes(plan, at) {
+    const L = plan.kyudo;
+    if (L === undefined)
+        return { mound: [], targets: [], height: 0 };
+    const fig = plan.figures;
+    const h = fig.azuchi.height * K;
+    const a = L.azuchi;
+    // The face runs from the foot, in front of the target's line, up to the top at the target's line: a slope of about 50 degrees reaches 1.5 m in 1.26 m.
+    const run = (fig.azuchi.height / Math.tan((50 * Math.PI) / 180)) * K;
+    const [fx, fy0] = at(a.x0, a.y0);
+    const [, fy1] = at(a.x0, a.y1);
+    const topX = fx + run;
+    const mound = plane("azuchi-face", "wall", [topX, fy0, h], [0, fy1 - fy0, 0], [-run, 0, -h], `<rect width="${n(fy1 - fy0)}" height="${n(Math.hypot(run, h))}" class="u-clay"/>`);
+    const d = fig.target.diameter * K;
+    const tilt = (fig.target.tilt * Math.PI) / 180;
+    const centre = fig.target.centre * K;
+    const targets = L.lanes.map((y, i) => {
+        const [tx, ty] = at(L.target, y);
+        // The face leans back at the top: its top is further from the shooters than its bottom.
+        const top = [tx + (d / 2) * Math.sin(tilt), ty - d / 2, centre + (d / 2) * Math.cos(tilt)];
+        return plane(`target-${i + 1}`, "target", top, [0, d, 0], [-d * Math.sin(tilt), 0, -d * Math.cos(tilt)], `<circle cx="${n(d / 2)}" cy="${n(d / 2)}" r="${n(d / 2)}" class="u-white"/><circle cx="${n(d / 2)}" cy="${n(d / 2)}" r="${n(d * 0.33)}" class="u-outline" fill="none"/><circle cx="${n(d / 2)}" cy="${n(d / 2)}" r="${n(d * 0.16)}" class="u-outline" fill="none"/>`);
+    });
+    return { mound: [mound], targets, height: h };
+}
+/** What stands on the budō surface the options draw. */
+export function budoUprights(o, thin) {
+    const plan = budoPlan(o);
+    const ox = plan.box.x0;
+    const oy = plan.box.y0;
+    const at = (x, y) => [(x - ox) * K, (y - oy) * K];
+    const area = { x0: 0, y0: 0, x1: (plan.box.x1 - ox) * K, y1: (plan.box.y1 - oy) * K };
+    const items = [];
+    let lift = 0;
+    if (plan.sumo !== undefined) {
+        lift = plan.sumo.height * K;
+        items.push({ id: "mound", kind: "mound", at: at(plan.sumo.centre[0], plan.sumo.centre[1]), height: lift, planes: moundPlanes(plan, at, lift) });
+    }
+    if (plan.kyudo !== undefined) {
+        const built = azuchiPlanes(plan, at);
+        items.push({ id: "azuchi", kind: "azuchi", at: at(plan.kyudo.target, plan.kyudo.lanes[0]), height: built.height, planes: built.mound });
+        if (built.targets.length > 0)
+            items.push({ id: "targets", kind: "targets", at: at(plan.kyudo.target, plan.kyudo.lanes[0]), height: Math.max(...built.targets.map((p) => p.o[2])), planes: built.targets });
+    }
+    if (plan.dojo !== undefined && plan.dojo.wall > 0) {
+        const f = plan.dojo.room;
+        const h = DOJO_WALL * K;
+        const w = plan.dojo.wall;
+        const centre = [area.x1 / 2, area.y1 / 2];
+        const planes = [
+            [f.x0 - w / 2, f.y0 - w / 2, f.x1 + w / 2, f.y0 - w / 2],
+            [f.x1 + w / 2, f.y0 - w / 2, f.x1 + w / 2, f.y1 + w / 2],
+            [f.x1 + w / 2, f.y1 + w / 2, f.x0 - w / 2, f.y1 + w / 2],
+            [f.x0 - w / 2, f.y1 + w / 2, f.x0 - w / 2, f.y0 - w / 2],
+        ].map(([x0, y0, x1, y1], i) => {
+            const [a, b] = [at(x0, y0), at(x1, y1)];
+            const run = Math.hypot(b[0] - a[0], b[1] - a[1]);
+            return shy(wall(`wall-${i + 1}`, "wall", a[0], a[1], b[0], b[1], 0, h, `<rect width="${n(run)}" height="${n(h)}" class="u-wall"/>`), centre);
+        });
+        items.push({ id: "walls", kind: "walls", at: centre, height: h, planes });
+    }
+    void thin;
+    return { items, lift, area };
+}

package/dist/uprights.d.ts

@@ -0,0 +1,37 @@
+import { type Plane, type Upright, type UprightKind } from "./turn.kit.ts";
+import { type Unit } from "./units.ts";
+import type { Language, SurfaceOptions } from "./types.ts";
+/** What can be asked of the uprights. */
+export interface UprightOptions {
+    /** Volleyball: the net at the men's height (2.43 m, the default) or the women's (2.24 m). */
+    netHeight?: "men" | "women";
+    /** Where the score of a score drawing goes: `board` (the default) hangs it up as a scoreboard (over the middle of a court or a rink, behind an end of a field) and takes the panel off the floor; `floor` leaves it on the floor. */
+    score?: "board" | "floor";
+    /** Leave the boards and the glass off a rink, and the walls and fence off a padel, squash or racquetball court, so that it can be seen into. On by default. */
+    boards?: boolean;
+    /** Only these kinds of thing; every kind the surface has when missing. */
+    only?: readonly UprightKind[];
+}
+/** What stands on a surface. */
+export interface Uprights {
+    items: Upright[];
+    /** How far the surface itself stands over the ground, in feet: a table tennis table's top, 0 on every other surface. */
+    lift: number;
+    /** The thinnest line or strip drawn on this surface, in feet. */
+    thin: number;
+    /** The playing surface itself in feet, the part the view is fitted to (the ground round it may run out of the picture): `undefined` for a surface with no uprights, which is fitted whole. */
+    area?: {
+        x0: number;
+        y0: number;
+        x1: number;
+        y1: number;
+    };
+}
+/** All the planes of all the things. */
+export declare const planesOf: (u: Pick<Uprights, "items">) => Plane[];
+/** What stands on the surface the options draw: nothing on a curling sheet, which is flat. */
+export declare function uprightsFor(o: SurfaceOptions, settings?: UprightOptions): Uprights;
+/** The unit the heights are said in: the options' own, else the rulebook's of the sport. */
+export declare function heightUnit(o: Pick<SurfaceOptions, "sport" | "league" | "units">): Unit;
+/** 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 declare function describeUprights(o: SurfaceOptions, uprights: Uprights, language?: Language): string;

package/dist/uprights.fields.d.ts

@@ -0,0 +1,32 @@
+import type { FieldPlan } from "./fields.types.ts";
+import { type FencePoint, type FootballSpec } from "./geometry.ts";
+import type { SoccerSpec } from "./surfaces/soccer-spec.ts";
+import type { ParkWall } from "./parks.ts";
+import { type Plane, type Upright } from "./turn.kit.ts";
+/**
+ * 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 declare 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 declare 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 declare function footballUprights(spec: FootballSpec, shape: "h" | "slingshot", top: number, thin: number): Upright[];
+/** A soccer pitch's uprights: both goals and, unless the options turn them off, the four corner flags. */
+export declare function soccerUprights(spec: SoccerSpec, flags: boolean, thin: number): Upright[];
+/** The rugby posts, Gaelic goal posts, Australian football posts and cricket stumps; a goal with a net for the sports that have one. */
+export declare function fieldUprights(plan: FieldPlan, thin: number): Upright[];
+/** The fence's height where no wall is listed: 8 feet. */
+export declare 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 declare const wallHeightAt: (walls: readonly ParkWall[], angle: number) => number;
+/** The planes of a fence: one standing wall over each stretch of its line, as high as the wall there. */
+export declare function fencePlanes(points: readonly FencePoint[], walls: readonly ParkWall[], thin: number): Plane[];
+/**
+ * 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 declare function ballparkUprights(points: readonly FencePoint[], walls: readonly ParkWall[], thin: number): Upright[];

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,169 @@
+// 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 { budoUprights } from "./uprights.budo.js";
+import { isBudoSport } from "./budo/plan.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", judo: "m", karate: "m", kendo: "m", sumo: "m", kyudo: "m", dojo: "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 (isBudoSport(sport)) {
+        const built = budoUprights({ ...o, sport }, 0.3);
+        area = built.area;
+        thin = thinnest(area.x1, area.y1);
+        items = budoUprights({ ...o, sport }, thin).items;
+        lift = built.lift;
+    }
+    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;