@johnmorrisdotca/kyogijo-stadiums 0.4.0 → 0.6.0

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

package/dist/uprights.net.d.ts

@@ -0,0 +1,12 @@
+import type { CourtGeometry, CourtPlan } from "./court.ts";
+import { type Upright } from "./turn.kit.ts";
+export interface NetEnd {
+    items: Upright[];
+    /** How high the surface stands over the ground: a table's top. */
+    lift: number;
+}
+/** The uprights of a court: what hangs on its posts. `thin` is the least thickness drawn, in feet. */
+export declare function netUprights(plan: CourtPlan, geo: CourtGeometry, settings: {
+    netHeight?: "men" | "women";
+    boards?: boolean;
+}, thin: number): NetEnd;

package/dist/uprights.net.js

@@ -0,0 +1,109 @@
+import { bar, flat, n, pole } from "./turn.kit.js";
+import { moreUprights } from "./uprights.more.js";
+import { netPlane, sag, tableBody } from "./uprights.netkit.js";
+import { convertLength } from "./units.js";
+/** The uprights of a court: what hangs on its posts. `thin` is the least thickness drawn, in feet. */
+export function netUprights(plan, geo, settings, thin) {
+    const { x, y0, y1 } = geo.net ?? { x: geo.length / 2, y0: 0, y1: geo.width };
+    const items = [];
+    const posts = (height, cls = "u-pole") => ({
+        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), cls)),
+    });
+    switch (plan.sport) {
+        case "tennis": {
+            const f = plan.figures;
+            const { heightPosts: p, heightCentre: c } = f.net;
+            const cell = Math.max(0.25, thin * 6);
+            items.push({ id: "net", kind: "net", at: [x, (y0 + y1) / 2], height: p, low: c, planes: [netPlane({ id: "net", x, y0, y1, top: sag(y0, y1, c, p), bottom: () => 0, cell, tape: Math.max(0.17, thin) }, 0)] });
+            items.push(posts(p));
+            if (geo.sticks.length > 0)
+                items.push({ id: "sticks", kind: "netposts", at: [x, (y0 + y1) / 2], height: p, planes: geo.sticks.flatMap((s, i) => pole(`stick-${i === 0 ? "a" : "b"}`, "post", s.x, s.y, 0, p, Math.max(s.size, thin * 1.1), "u-tape")) });
+            return { items, lift: 0 };
+        }
+        case "volleyball": {
+            const f = plan.figures;
+            const top = settings.netHeight === "women" ? f.net.heightWomen : f.net.heightMen;
+            const strip = f.net.width;
+            const cell = Math.max(convertLength(0.1, "m", "ft"), thin * 6);
+            const side = Math.max(convertLength(0.05, "m", "ft"), thin * 1.2);
+            items.push({
+                id: "net",
+                kind: "net",
+                at: [x, (y0 + y1) / 2],
+                height: top,
+                planes: [netPlane({ id: "net", x, y0, y1, top: () => top, bottom: () => top - strip, cell, tape: Math.max(convertLength(0.07, "m", "ft"), thin * 1.6), bands: { at: [0, geo.width], width: side } }, 0)],
+            });
+            // The FIVB's posts are 2.55 m, 12 cm over the men's net; sitting volleyball's rules cited give their distance from the side lines only, so the same 12 cm is ours.
+            items.push(posts(f.net.heightMen + convertLength(0.12, "m", "ft")));
+            // An antenna is 1.8 m long and stands 80 cm over the net's top, in bands of 10 cm, red and white.
+            const reach = f.net.antenna.length;
+            const above = convertLength(0.8, "m", "ft");
+            const stripe = convertLength(0.1, "m", "ft");
+            const antenna = (long, wide) => {
+                let rects = "";
+                for (let a = 0, i = 0; a < long; a += stripe, i += 1)
+                    rects += `<rect x="${n(a)}" width="${n(Math.min(stripe, long - a))}" height="${n(wide)}" class="${i % 2 === 0 ? "u-red" : "u-white"}"/>`;
+                return rects;
+            };
+            items.push({
+                id: "antennae",
+                kind: "antennae",
+                at: [x, (y0 + y1) / 2],
+                height: top + above,
+                planes: geo.antennae.flatMap((a, i) => bar(`antenna-${i === 0 ? "a" : "b"}`, "antenna", [a.x, a.y, top + above - reach], [a.x, a.y, top + above], Math.max(a.size, thin * 1.1), "u-red", antenna)),
+            });
+            return { items, lift: 0 };
+        }
+        case "badminton": {
+            const f = plan.figures;
+            const { postHeight: p, heightCentre: c, heightSides: s, depth } = f.net;
+            const cell = Math.max(convertLength(0.02, "m", "ft") * 4, thin * 5);
+            items.push({
+                id: "net",
+                kind: "net",
+                at: [x, (y0 + y1) / 2],
+                height: s,
+                low: c,
+                planes: [netPlane({ id: "net", x, y0, y1, top: sag(y0, y1, c, s), bottom: (y) => sag(y0, y1, c, s)(y) - depth, cell, tape: Math.max(convertLength(0.075, "m", "ft"), thin) }, 0)],
+            });
+            items.push(posts(p));
+            return { items, lift: 0 };
+        }
+        case "pickleball": {
+            const f = plan.figures;
+            const { heightSides: s, heightCentre: c } = f.net;
+            const cell = Math.max(0.25, thin * 6);
+            items.push({ id: "net", kind: "net", at: [x, (y0 + y1) / 2], height: s, low: c, planes: [netPlane({ id: "net", x, y0, y1, top: sag(y0, y1, c, s), bottom: () => 0, cell, tape: Math.max(0.17, thin) }, 0)] });
+            items.push(posts(s * 1.04));
+            return { items, lift: 0 };
+        }
+        case "tabletennis": {
+            const f = plan.figures;
+            const lift = f.height;
+            const { height: h, postHeight } = f.net;
+            const cell = Math.max(convertLength(0.01, "m", "ft") * 1.5, thin * 3);
+            items.push({ id: "net", kind: "net", at: [x, (y0 + y1) / 2], height: lift + h, planes: [netPlane({ id: "net", x, y0, y1, top: () => h, bottom: () => 0, cell, tape: Math.max(0.03, thin * 0.8) }, lift)] });
+            items.push({
+                id: "clamps",
+                kind: "netposts",
+                at: [x, (y0 + y1) / 2],
+                height: lift + postHeight,
+                planes: geo.posts.flatMap((p, i) => pole(`post-${i === 0 ? "a" : "b"}`, "post", p.x, p.y, lift, lift + postHeight, Math.max(p.size, thin * 1.6), "u-pole")),
+            });
+            // The table: a skirt under its top, and four legs set in from its ends.
+            const L = geo.length;
+            const W = geo.width;
+            items.push({ id: "table", kind: "table-legs", at: [L / 2, W / 2], height: lift, planes: tableBody(0, 0, L, W, lift, thin, false) });
+            // The floor of the hall, under the table.
+            const room = Math.max(L, W) * 5;
+            items.push({ id: "ground", kind: "table-legs", at: [L / 2, W / 2], height: 0, planes: [flat("ground", "ground", -room, -room, L + room, W + room, 0, `<rect width="${n(L + 2 * room)}" height="${n(W + 2 * room)}" class="u-ground"/>`)] });
+            return { items, lift };
+        }
+        default:
+            return moreUprights(plan, geo, settings, thin);
+    }
+}

package/dist/uprights.netkit.d.ts

@@ -0,0 +1,28 @@
+import { type Plane } from "./turn.kit.ts";
+/** What a net on a court is: where it hangs, between which posts, and the line of its top and of its bottom. */
+export interface NetBody {
+    id: string;
+    x: number;
+    y0: number;
+    y1: number;
+    /** The height of the top edge and of the bottom edge over a place across the court, above the court's own surface. */
+    top: (y: number) => number;
+    bottom: (y: number) => number;
+    /** The mesh's cell, and the tape along the top, in feet. */
+    cell: number;
+    tape: number;
+    /** Vertical white bands across the net at these places across the court (volleyball's side bands), and their width. */
+    bands?: {
+        at: readonly number[];
+        width: number;
+    };
+}
+/** The net: a mesh between a top line and a bottom line, with its tape, on one plane standing over the line x. */
+export declare function netPlane(b: NetBody, lift: number): Plane;
+/** A parabola from the centre height to the post height: the sag of a net hung between two posts. */
+export declare const sag: (y0: number, y1: number, centre: number, posts: number) => (y: number) => number;
+/**
+ * A table: a skirt under its top and four legs set in from its ends, over the rectangle (x0, y0) to (x1, y1), its top `lift` feet over the floor. `top` also draws the top
+ * itself (a teqball table stands on a court; a table tennis table is the surface, which the drawing already shows).
+ */
+export declare function tableBody(x0: number, y0: number, x1: number, y1: number, lift: number, thin: number, top: boolean): Plane[];

package/dist/uprights.netkit.js

@@ -0,0 +1,67 @@
+// The pieces the net sports' uprights share: a net hung between a top line and a bottom line, the sag of a net between its posts, and a table lifted on its legs.
+import { flat, n, plane, pole, threads, wall } from "./turn.kit.js";
+import { convertLength } from "./units.js";
+/** The net: a mesh between a top line and a bottom line, with its tape, on one plane standing over the line x. */
+export function netPlane(b, lift) {
+    const { y0, y1 } = b;
+    const steps = 24;
+    const ys = Array.from({ length: steps + 1 }, (_, i) => y0 + ((y1 - y0) * i) / steps);
+    const high = Math.max(...ys.map(b.top));
+    const low = Math.min(...ys.map(b.bottom));
+    const span = y1 - y0;
+    const fromTop = (z) => high - z;
+    const edge = (f) => ys.map((y) => `${n(y - y0)} ${n(fromTop(f(y)))}`).join("L");
+    const top = ys.map((y) => `${n(y - y0)} ${n(fromTop(b.top(y)))}`);
+    const bottom = [...ys].reverse().map((y) => `${n(y - y0)} ${n(fromTop(b.bottom(y)))}`);
+    const outline = `M${top.join("L")}L${bottom.join("L")}Z`;
+    let lines = "";
+    // Upright threads, one every cell, from the top line to the bottom line.
+    const across = Math.max(2, Math.round(span / b.cell));
+    for (let i = 1; i < across; i += 1) {
+        const y = y0 + (span * i) / across;
+        lines += `M${n(y - y0)} ${n(fromTop(b.top(y)))}V${n(fromTop(b.bottom(y)))}`;
+    }
+    // Level threads, wherever the net reaches that height.
+    const levels = Math.max(1, Math.round((high - low) / b.cell));
+    for (let j = 1; j < levels; j += 1) {
+        const z = low + ((high - low) * j) / levels;
+        let pen = false;
+        for (const y of ys) {
+            const inside = z <= b.top(y) && z >= b.bottom(y);
+            lines += `${inside ? (pen ? "L" : "M") : ""}${inside ? `${n(y - y0)} ${n(fromTop(z))}` : ""}`;
+            pen = inside;
+        }
+    }
+    const tape = `<path d="M${edge(b.top)}" class="u-tapeline" fill="none" stroke-width="${n(b.tape)}"/>`;
+    const bands = (b.bands?.at ?? []).map((y) => `<rect x="${n(y - y0 - b.bands.width / 2)}" y="${n(fromTop(b.top(y)))}" width="${n(b.bands.width)}" height="${n(b.top(y) - b.bottom(y))}" class="u-tape"/>`).join("");
+    return plane(b.id, "net", [b.x, y0, lift + high], [0, span, 0], [0, 0, -(high - low)], `<path d="${outline}" class="u-netfill"/>${threads(lines, b.cell)}${bands}${tape}`);
+}
+/** A parabola from the centre height to the post height: the sag of a net hung between two posts. */
+export const sag = (y0, y1, centre, posts) => (y) => {
+    const middle = (y0 + y1) / 2;
+    const t = (y - middle) / ((y1 - y0) / 2);
+    return centre + (posts - centre) * t * t;
+};
+/**
+ * A table: a skirt under its top and four legs set in from its ends, over the rectangle (x0, y0) to (x1, y1), its top `lift` feet over the floor. `top` also draws the top
+ * itself (a teqball table stands on a court; a table tennis table is the surface, which the drawing already shows).
+ */
+export function tableBody(x0, y0, x1, y1, lift, thin, top) {
+    const L = x1 - x0;
+    const W = y1 - y0;
+    const skirt = Math.max(convertLength(0.05, "m", "ft"), thin * 2);
+    const rect = (w) => `<rect width="${n(w)}" height="${n(skirt)}" class="u-table"/>`;
+    const planes = [
+        wall("table-side-a", "table", x0, y0, x1, y0, lift - skirt, lift, rect(L)),
+        wall("table-side-b", "table", x0, y1, x1, y1, lift - skirt, lift, rect(L)),
+        wall("table-end-a", "table", x0, y0, x0, y1, lift - skirt, lift, rect(W)),
+        wall("table-end-b", "table", x1, y0, x1, y1, lift - skirt, lift, rect(W)),
+    ];
+    if (top)
+        planes.unshift(flat("table-top", "table", x0, y0, x1, y1, lift, `<rect width="${n(L)}" height="${n(W)}" class="u-table"/>`));
+    const leg = Math.max(convertLength(0.05, "m", "ft"), thin * 2.2);
+    const inset = Math.max(L * 0.07, leg * 2);
+    for (const [i, [lx, ly]] of [[x0 + inset, y0 + inset], [x0 + inset, y1 - inset], [x1 - inset, y0 + inset], [x1 - inset, y1 - inset]].entries())
+        planes.push(...pole(`leg-${i}`, "leg", lx, ly, 0, lift - skirt, leg, "u-leg"));
+    return planes;
+}

package/dist/uprights.pools.d.ts

@@ -0,0 +1,8 @@
+import { type PoolPlan } from "./pool.ts";
+import { type Upright } from "./turn.kit.ts";
+import type { SurfaceOptions } from "./types.ts";
+/** What stands on a pool of the options' sport, as the drawing has it, with the plan's metres put into the drawing's feet. A natatorium of several pools has none. */
+export declare function poolUprights(o: SurfaceOptions, thin: number): {
+    items: Upright[];
+    plan: PoolPlan;
+};

package/dist/uprights.pools.js

@@ -0,0 +1,190 @@
+// What stands on the pools, in 3D: a swimming pool's starting blocks, its backstroke flag lines and its false start rope; a diving well's springboards and platforms on their stands; a water
+// polo field's two floating goals; an artistic swimming area's judges' stand and starting platform. The heights are World Aquatics' (the Competition Regulations in force from February 2026, bar the few figures `pool.figures.ts` marks as the June 2025 edition's):
+// docs/sources.md, "Heights in the 3D view", says which rule each comes from, and `pool.figures.ts` holds the figures. A plan is in metres and the drawing's frame in feet, with the pool's
+// top left corner for the origin and the water level for the floor, so every length goes through `feet`. What the rules leave to the maker (the thickness of a stand, a rope, the sides of a
+// box) is ours and is said so there.
+import { ARTISTIC, DIVING, SWIMMING, WATER_POLO } from "./pool.figures.js";
+import { feet, poolPlan } from "./pool.js";
+import { GUTTER } from "./surfaces/pool.js";
+import { goalCage } from "./uprights.goal.js";
+import { flat, n, pole, polygon, wall } from "./turn.kit.js";
+/** A box over the rectangle (x0, y0) to (x1, y1) between the heights z0 and z1: its top and the sides named, the top in `top` and the sides in `side`. */
+function box(id, x0, y0, x1, y1, z0, z1, top, side, sides, withTop = true) {
+    const planes = [];
+    if (withTop)
+        planes.push(flat(`${id}-top`, "board", x0, y0, x1, y1, z1, `<rect width="${n(x1 - x0)}" height="${n(y1 - y0)}" class="${top}"/>`));
+    const face = (tag, ax, ay, bx, by) => wall(`${id}-${tag}`, "wall", ax, ay, bx, by, z0, z1, `<rect width="${n(Math.hypot(bx - ax, by - ay))}" height="${n(z1 - z0)}" class="${side}"/>`);
+    if (sides.includes("x0"))
+        planes.push(face("x0", x0, y0, x0, y1));
+    if (sides.includes("x1"))
+        planes.push(face("x1", x1, y0, x1, y1));
+    if (sides.includes("y0"))
+        planes.push(face("y0", x0, y0, x1, y0));
+    if (sides.includes("y1"))
+        planes.push(face("y1", x0, y1, x1, y1));
+    return planes;
+}
+/** The swimming pool: a block in each lane at each end, a flagged rope 5 m from each wall, the false start rope 15 m from the starting end, each rope on a standard at either side. */
+function swimmingUprights(plan, thin) {
+    const items = [];
+    const L = plan.length;
+    const W = plan.width;
+    const standard = Math.max(feet(0.05), thin * 1.4);
+    const standards = (id, x, height, outside) => [-outside, W + outside].flatMap((y, i) => pole(`${id}-standard-${i === 0 ? "a" : "b"}`, "post", feet(x), feet(y), 0, height, standard, "u-pole"));
+    if (plan.blocks) {
+        const { width, length, height } = SWIMMING.block;
+        const planes = [];
+        for (const lane of plan.lanes) {
+            for (const end of [0, 1]) {
+                // 0.08 m of deck between the wall and the block, as the drawing has it (the drawing stands them 0.08 m behind the wall).
+                const x0 = end === 0 ? -0.08 - length : L + 0.08;
+                const id = `block-${lane.number}-${end === 0 ? "start" : "turn"}`;
+                const bx0 = feet(x0);
+                const bx1 = feet(x0 + length);
+                const by0 = feet(lane.y - width / 2);
+                const by1 = feet(lane.y + width / 2);
+                const number = `<text x="${n((bx1 - bx0) / 2)}" y="${n((by1 - by0) * 0.74)}" text-anchor="middle" font-size="${n((by1 - by0) * 0.66)}" font-weight="800" font-family="system-ui,sans-serif" fill="#1f2320">${lane.number}</text>`;
+                planes.push(flat(`${id}-top`, "board", bx0, by0, bx1, by1, feet(height), `<rect width="${n(bx1 - bx0)}" height="${n(by1 - by0)}" class="u-board"/>${number}`));
+                // The face towards the water.
+                const fx = end === 0 ? bx1 : bx0;
+                planes.push(wall(`${id}-front`, "wall", fx, by0, fx, by1, 0, feet(height), `<rect width="${n(by1 - by0)}" height="${n(feet(height))}" class="u-leg"/>`));
+            }
+        }
+        items.push({ id: "starting-blocks", kind: "starting-blocks", at: [feet(L) / 2, feet(W) / 2], height: feet(height), planes });
+    }
+    if (plan.flags) {
+        const { at, height, side } = SWIMMING.flags;
+        const hang = side * 0.87;
+        const planes = [];
+        for (const [i, x] of [at, L - at].entries()) {
+            const outside = 0.6;
+            const run = feet(W + 2 * outside);
+            const tri = feet(side);
+            const gap = feet(SWIMMING.flags.apart);
+            let flags = "";
+            for (let k = 0, a = gap / 2; a + tri <= run; k += 1, a += tri + gap)
+                flags += `<path d="${polygon([[a, 0], [a + tri, 0], [a + tri / 2, feet(hang)]])}" class="${k % 2 === 0 ? "u-red" : "u-white"}"/>`;
+            const rope = `<path d="M0 0H${n(run)}" class="u-tapeline" fill="none" stroke-width="${n(Math.max(feet(0.02), thin * 0.5))}"/>`;
+            planes.push(wall(`flags-${i === 0 ? "start" : "turn"}`, "tape", feet(x), -feet(outside), feet(x), feet(W + outside), feet(height - hang), feet(height), flags + rope), ...standards(`flags-${i === 0 ? "start" : "turn"}`, x, feet(height), outside));
+        }
+        items.push({ id: "backstroke-flags", kind: "backstroke-flags", at: [feet(L) / 2, feet(W) / 2], height: feet(height), planes });
+    }
+    if (plan.falseStart) {
+        const { at, height } = SWIMMING.falseStart;
+        const outside = 0.7;
+        const run = feet(W + 2 * outside);
+        const thick = Math.max(feet(0.06), thin * 1.1);
+        const rope = wall("false-start-rope", "tape", feet(at), -feet(outside), feet(at), feet(W + outside), feet(height) - thick, feet(height), `<rect width="${n(run)}" height="${n(thick)}" class="u-red"/>`);
+        items.push({ id: "false-start-rope", kind: "false-start-rope", at: [feet(at), feet(W) / 2], height: feet(height), planes: [rope, ...standards("false-start", at, feet(height), outside)] });
+    }
+    return items;
+}
+/** The two goals of a water polo field, floating on the goal lines: 3 m between the posts, the crossbar's underside 0.9 m over the water (Part Six 21.6.3.2 and 21.6.4.2), a net 0.30 m deep behind the line (21.6.5). */
+function poloUprights(plan, thin) {
+    const { goal } = WATER_POLO;
+    const g0 = goal.netClear;
+    const g1 = plan.length - goal.netClear;
+    const posts = Math.max(feet(goal.post), thin * 1.2);
+    const items = [];
+    for (const [i, from] of ["left", "right"].entries()) {
+        const cage = goalCage({
+            id: `goal-${from}`,
+            x: feet(i === 0 ? g0 : g1),
+            y: feet(plan.width) / 2,
+            out: i === 0 ? -1 : 1,
+            width: feet(goal.width + goal.post),
+            height: feet(goal.crossbarHeight + goal.post),
+            depth: feet(goal.netClear),
+            top: feet(goal.netClear) * 0.5,
+            post: posts,
+            cell: Math.max(feet(0.1), thin * 3),
+            tone: "white",
+        });
+        // The height said is the clear one, to the underside of the bar.
+        items.push({ ...cage, height: feet(goal.crossbarHeight) });
+    }
+    return items;
+}
+/**
+ * A diving well: each springboard 4.88 m long and 0.50 m wide at 1 m or 3 m, its plummet over the water, on a stand behind the wall (Part Four, Appendix 2); each platform at its height of 1, 3, 5, 7.5 or 10 m with
+ * the length and width of the table, on a tower behind the wall. The stands and towers are ours: the rules give where the plummet is and not what holds the board up.
+ */
+function diveUprights(plan) {
+    const springPlanes = [];
+    const platformPlanes = [];
+    let lowest = Infinity;
+    const stand = DIVING.springboard.width + 0.5;
+    for (const [i, b] of plan.boards.entries()) {
+        const x0 = feet(b.x - b.length);
+        const x1 = feet(b.x);
+        const y0 = feet(b.y - b.width / 2);
+        const y1 = feet(b.y + b.width / 2);
+        const h = feet(b.height);
+        const id = `${b.kind === "springboard" ? "springboard" : "platform"}-${String(b.height).replace(".", "-")}m-${i}`;
+        lowest = Math.min(lowest, b.height);
+        if (b.kind === "springboard") {
+            // The board, a stand under its rear half (from the rear end to the wall) as wide as the board and a little more.
+            const sy0 = feet(b.y - stand / 2);
+            const sy1 = feet(b.y + stand / 2);
+            springPlanes.push(...box(id, x0, y0, x1, y1, h - feet(0.1), h, "u-pad", "u-pad", ["y0", "y1"]));
+            springPlanes.push(...box(`${id}-stand`, x0 + feet(0.4), sy0, 0, sy1, 0, h - feet(0.1), "u-leg", "u-leg", ["x1", "y0", "y1"], false));
+        }
+        else {
+            // The table, with its front lip over the water, and a tower 2.5 m deep behind the wall under its rear part, as wide as the table up to 2.2 m.
+            platformPlanes.push(...box(id, x0, y0, x1, y1, h - feet(0.25), h, "u-board", "u-board", ["x1"]));
+            const half = Math.min(b.width / 2, 1.1);
+            platformPlanes.push(...box(`${id}-tower`, Math.max(x0, -feet(2.5)), feet(b.y - half), 0, feet(b.y + half), 0, h - feet(0.25), "u-leg", "u-leg", ["x1", "y0", "y1"], false));
+        }
+    }
+    const items = [];
+    const tall = (kind) => Math.max(0, ...plan.boards.filter((b) => b.kind === kind).map((b) => b.height));
+    if (springPlanes.length > 0)
+        items.push({ id: "springboards", kind: "springboards", at: [0, feet(plan.width) / 2], height: feet(tall("springboard")), planes: springPlanes });
+    if (platformPlanes.length > 0)
+        items.push({ id: "platforms", kind: "platforms", at: [0, feet(plan.width) / 2], height: feet(tall("platform")), planes: platformPlanes });
+    return items;
+}
+/** An artistic swimming area: the judges' platform along the top side, 0.6 m high (Part Seven 12.2.5: at least 0.6 m, not more than 2 m from the edge), and the starting platform 0.7 m high (Part Seven 12.2.4). */
+function artisticUprights(plan) {
+    const { judges, start } = ARTISTIC.drawn;
+    const L = plan.length;
+    const W = plan.width;
+    const jy = -GUTTER - 1 - judges.depth;
+    const jx0 = L / 2 - judges.length / 2;
+    const jh = feet(ARTISTIC.judges.height);
+    const sx = L / 2 - start.length / 2;
+    const sy = W + GUTTER + 0.4;
+    const sh = feet(ARTISTIC.start.heightOlympic);
+    return [
+        {
+            id: "judges-stand",
+            kind: "judges-stand",
+            at: [feet(L / 2), feet(jy + judges.depth / 2)],
+            height: jh,
+            planes: box("judges", feet(jx0), feet(jy), feet(jx0 + judges.length), feet(jy + judges.depth), 0, jh, "u-board", "u-leg", ["x0", "x1", "y1"]),
+        },
+        {
+            id: "starting-platform",
+            kind: "starting-blocks",
+            at: [feet(L / 2), feet(sy + start.depth / 2)],
+            height: sh,
+            planes: box("start", feet(sx), feet(sy), feet(sx + start.length), feet(sy + start.depth), 0, sh, "u-board", "u-leg", ["x0", "x1", "y0"]),
+        },
+    ];
+}
+/** What stands on a pool of the options' sport, as the drawing has it, with the plan's metres put into the drawing's feet. A natatorium of several pools has none. */
+export function poolUprights(o, thin) {
+    const plan = poolPlan(o);
+    if (o.pool?.venue !== undefined)
+        return { items: [], plan };
+    switch (plan.sport) {
+        case "swimming":
+            return { items: swimmingUprights(plan, thin), plan };
+        case "waterpolo":
+            return { items: poloUprights(plan, thin), plan };
+        case "diving":
+            return { items: diveUprights(plan), plan };
+        default:
+            return { items: artisticUprights(plan), plan };
+    }
+}

package/dist/uprights.rinks.d.ts

@@ -0,0 +1,27 @@
+import type { CourtFigures } from "./leagues/basketball.ts";
+import type { RinkFigures } from "./leagues/hockey.ts";
+import { type Plane, type Upright } from "./turn.kit.ts";
+/** The boards of a rink, 42 in (NHL Rule 1.3: 40 to 48 in, 42 the ideal), the glass over them 8 ft at each end and 6 ft along the sides (Rule 1.3: not less than 6 ft). */
+export declare const BOARD_HEIGHT = 3.5;
+export declare const GLASS_END = 8;
+export declare const GLASS_SIDE = 6;
+/** The height of a hockey goal, 4 feet (NHL Rule 2.1). */
+export declare const HOCKEY_GOAL_HEIGHT = 4;
+/** The line round a rink's ice, as points: the straight sides and the quarter circles of its corners. */
+export declare function rinkOutline(length: number, width: number, radius: number, steps?: number): [number, number][];
+/** The boards with the glass above them, one plane for each straight stretch of the line: the glass is 8 ft at the ends and in the corners and 6 ft along the sides. */
+export declare function boardPlanes(length: number, width: number, radius: number, boards: number, thin: number): Plane[];
+/** A rink's uprights: the boards and glass, and the two goals. `goalLine` is the distance of the goal line from the end boards. */
+export declare function rinkUprights(rink: RinkFigures, goalLine: number, thin: number, boards: boolean): Upright[];
+/** The ring's upper edge is 10 ft over the floor (NBA Rule 1 Section II) and 3,050 mm in FIBA's (1.2.4). */
+export declare const RIM_HEIGHT = 10;
+export declare const FIBA_RIM_HEIGHT: number;
+/** The board's lower edge is 150 mm under the ring's top (FIBA 1.1.5); NBA Rule 1 gives the board's size and the ring's height but not the lower edge, which is drawn the same. */
+export declare const BOARD_DROP: number;
+/** The NBA's board is 3 1/2 ft tall, FIBA's 1,050 mm. */
+export declare const BOARD_TALL = 3.5;
+export declare const FIBA_BOARD_TALL: number;
+/** The least distance of the support's padding behind the end line, FIBA 1.4.3 Level 1: 2,000 mm. */
+export declare const SUPPORT_BEHIND: number;
+/** A court's uprights: its two baskets. */
+export declare const courtUprights: (court: CourtFigures, thin: number, fiba?: boolean) => Upright[];