@johnmorrisdotca/kyogijo-stadiums 0.4.0 → 0.5.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 25 June 2025):
+// 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 (CR 18.3.3), a net 0.30 m deep behind the line. */
+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 (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 (CR 27.2.8: at least 0.6 m, not more than 2 m from the edge), and the starting platform 0.7 m high (CR 27.2.7). */
+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[];

package/dist/uprights.rinks.js

@@ -0,0 +1,106 @@
+import { goalCage } from "./uprights.goal.js";
+import { bar, mesh, n, plane, polygon, pole, shy, threads, wall } from "./turn.kit.js";
+/** 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 const BOARD_HEIGHT = 3.5;
+export const GLASS_END = 8;
+export const GLASS_SIDE = 6;
+/** The height of a hockey goal, 4 feet (NHL Rule 2.1). */
+export 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 function rinkOutline(length, width, radius, steps = 6) {
+    const r = Math.min(radius, width / 2, length / 2);
+    const out = [];
+    const corner = (cx, cy, from) => {
+        for (let i = 0; i <= steps; i += 1) {
+            const a = ((from + (90 * i) / steps) * Math.PI) / 180;
+            out.push([cx + r * Math.cos(a), cy + r * Math.sin(a)]);
+        }
+    };
+    // Clockwise as the page shows it: the top left corner first.
+    corner(r, r, 180);
+    corner(length - r, r, 270);
+    corner(length - r, width - r, 0);
+    corner(r, width - r, 90);
+    return out;
+}
+/** 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 function boardPlanes(length, width, radius, boards, thin) {
+    const points = rinkOutline(length, width, radius);
+    const planes = [];
+    const cap = Math.max(thin * 0.8, 0.12);
+    for (let i = 0; i < points.length; i += 1) {
+        const [x0, y0] = points[i];
+        const [x1, y1] = points[(i + 1) % points.length];
+        const run = Math.hypot(x1 - x0, y1 - y0);
+        if (run < 1e-6)
+            continue;
+        const along = Math.abs(y1 - y0) < 1e-6 && (Math.abs(y0) < 1e-6 || Math.abs(y0 - width) < 1e-6) && Math.min(x0, x1) >= radius - 1e-6;
+        const glass = along ? GLASS_SIDE : GLASS_END;
+        const svg = `<rect y="${n(glass)}" width="${n(run)}" height="${n(boards)}" class="u-board"/><rect width="${n(run)}" height="${n(glass)}" class="u-glass"/><rect y="${n(glass)}" width="${n(run)}" height="${n(cap)}" class="u-cap"/><rect width="${n(run)}" height="${n(cap)}" class="u-cap"/>`;
+        planes.push(wall(`board-${i}`, "glass", x0, y0, x1, y1, 0, boards + glass, svg));
+    }
+    return planes;
+}
+/** 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 function rinkUprights(rink, goalLine, thin, boards) {
+    const { length: L, width: W } = rink;
+    const items = [];
+    if (boards)
+        items.push({ id: "boards", kind: "boards", at: [L / 2, W / 2], height: BOARD_HEIGHT, low: BOARD_HEIGHT + GLASS_END, planes: boardPlanes(L, W, rink.cornerRadius, BOARD_HEIGHT, thin).map((p) => shy(p, [L / 2, W / 2])) });
+    const { width, depth } = rink.net;
+    for (const end of ["left", "right"]) {
+        const left = end === "left";
+        items.push(goalCage({ id: `goal-${end}`, x: left ? goalLine : L - goalLine, y: W / 2, out: left ? -1 : 1, width, height: HOCKEY_GOAL_HEIGHT, depth, top: depth * 0.55, post: Math.max(thin * 1.2, 0.17), cell: Math.max(thin * 5, 0.35), tone: "red" }));
+    }
+    return items;
+}
+/** 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 const RIM_HEIGHT = 10;
+export const FIBA_RIM_HEIGHT = 3.05 * 3.280839895;
+/** 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 const BOARD_DROP = 0.15 * 3.280839895;
+/** The NBA's board is 3 1/2 ft tall, FIBA's 1,050 mm. */
+export const BOARD_TALL = 3.5;
+export const FIBA_BOARD_TALL = 1.05 * 3.280839895;
+/** The least distance of the support's padding behind the end line, FIBA 1.4.3 Level 1: 2,000 mm. */
+export const SUPPORT_BEHIND = 2 * 3.280839895;
+/** One basket: the backboard, the rim and its net, and the stanchion behind the baseline that holds them. `fiba` draws the board and the net at FIBA's size. */
+function basket(end, court, thin, fiba) {
+    const left = end === "left";
+    const sign = left ? 1 : -1;
+    const L = court.length;
+    const cy = court.width / 2;
+    const back = left ? court.backboard.fromBaseline : L - court.backboard.fromBaseline;
+    const rimX = left ? court.basket : L - court.basket;
+    const r = court.rim;
+    const bw = court.backboard.width;
+    const tall = fiba ? FIBA_BOARD_TALL : BOARD_TALL;
+    const rimTop = fiba ? FIBA_RIM_HEIGHT : RIM_HEIGHT;
+    const bottom = rimTop - BOARD_DROP;
+    const top = bottom + tall;
+    const line = Math.max(thin * 1.8, 0.2);
+    const id = `hoop-${end}`;
+    const planes = [];
+    // The backboard: glass in a frame, with the rectangle behind the ring, its base level with the ring's top (FIBA 1.1.5: 590 by 450 mm; NBA: 24 by 18 in).
+    const targetW = fiba ? 0.59 * 3.280839895 : 2;
+    const targetH = fiba ? 0.45 * 3.280839895 : 1.5;
+    const svg = `<rect width="${n(bw)}" height="${n(tall)}" class="u-backboard"/><rect x="${n(line / 2)}" y="${n(line / 2)}" width="${n(bw - line)}" height="${n(tall - line)}" class="u-outline" stroke-width="${n(line)}" fill="none"/><rect x="${n((bw - targetW) / 2)}" y="${n(top - (rimTop + targetH))}" width="${n(targetW)}" height="${n(targetH)}" class="u-outline" stroke-width="${n(line * 0.8)}" fill="none"/>`;
+    planes.push(wall(`${id}-backboard`, "board", back, cy - bw / 2, back, cy + bw / 2, bottom, top, svg));
+    // The rim, lying flat, and the net hanging from it: two crossed trapezoids, 18 in long (NBA Rule 1 Section II; FIBA 1.3.1: 400 to 450 mm).
+    planes.push(plane(`${id}-rim`, "rim", [rimX - r, cy - r, rimTop], [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 * 1.6)}" fill="none"/>`));
+    const drop = fiba ? 0.42 * 3.280839895 : 1.5;
+    const foot = r * 0.55;
+    const shape = polygon([[0, 0], [2 * r, 0], [r + foot, drop], [r - foot, drop]]);
+    const netSvg = `<path d="${shape}" class="u-netfill"/>${threads(mesh(2 * r, drop, 0.3), 0.3)}`;
+    planes.push(plane(`${id}-net-a`, "net", [rimX, cy - r, rimTop], [0, 2 * r, 0], [0, 0, -drop], netSvg), plane(`${id}-net-b`, "net", [rimX - r, cy, rimTop], [2 * r, 0, 0], [0, 0, -drop], netSvg));
+    // The stanchion: a padded base whose front is 2 m behind the end line, and an arm out to the back of the board.
+    const padWide = Math.max(1.1, thin * 5);
+    const stand = left ? -(SUPPORT_BEHIND + padWide / 2) : L + SUPPORT_BEHIND + padWide / 2;
+    const arm = top - 1.4;
+    planes.push(...pole(`${id}-pad`, "stanchion", stand, cy, 0, 7, padWide, "u-pad"));
+    planes.push(...pole(`${id}-mast`, "stanchion", stand, cy, 7, arm, Math.max(0.5, thin * 2.5), "u-pole"));
+    planes.push(...bar(`${id}-arm`, "stanchion", [stand, cy, arm], [back - sign * line, cy, arm], Math.max(0.4, thin * 2), "u-pole"));
+    return { id, kind: "hoop", at: [rimX, cy], height: rimTop, low: top, planes };
+}
+/** A court's uprights: its two baskets. */
+export const courtUprights = (court, thin, fiba = false) => [basket("left", court, thin, fiba), basket("right", court, thin, fiba)];

package/dist/uprights.track.d.ts

@@ -0,0 +1,50 @@
+import { type Upright } from "./turn.kit.ts";
+import type { SurfaceOptions } from "./types.ts";
+/** The hurdles' heights: the men's 110 m (and the covered 60 m) 1.067 m, the women's 100 m 0.838 m, the 400 m 0.914 m (Technical Rule 22); a steeplechase barrier 0.914 m (Rule 23.5). */
+export declare const HURDLE_HEIGHT: {
+    readonly "110m-hurdles": 1.067;
+    readonly "60m-hurdles": 1.067;
+    readonly "100m-hurdles": 0.838;
+    readonly "400m-hurdles": 0.914;
+    readonly steeplechase: 0.914;
+};
+/** The cage's netting is at least 4 m high, and at least 6 m for the 3 m nearest the front of each side (Facilities Manual 2.4.1.3). */
+export declare const CAGE: {
+    readonly low: 4;
+    readonly high: 6;
+    readonly highLength: 3;
+};
+/** The high jump's uprights are 4.02 m apart (Manual 2.3.3.3) and the pole vault's at least 5.20 m (2.3.4.3). The heights of the bars are ours. */
+export declare const JUMPS: {
+    readonly highUprights: 4.02;
+    readonly highBar: 2;
+    readonly highPost: 2.5;
+    readonly vaultUprights: 5.2;
+    readonly vaultBar: 5;
+    readonly vaultPost: 6;
+    readonly vaultBarLength: 4.5;
+};
+/** The padding round a track is at least 0.80 m high and 0.30 m thick (ISU Rule 228.2). */
+export declare const PADDING: {
+    readonly height: 0.8;
+};
+/** An athletics stadium's uprights, as the plan has its box. */
+export declare function athleticsUprights(o: SurfaceOptions, thin: number): {
+    items: Upright[];
+    area: {
+        x0: number;
+        y0: number;
+        x1: number;
+        y1: number;
+    };
+};
+/** What stands at a skating rink: the padding round a long or a short track, 0.80 m high (ISU Rule 228.2); the boards of a figure skating rink, as high as a hockey rink's and with no glass over them. */
+export declare function skatingUprights(o: SurfaceOptions, thin: number): {
+    items: Upright[];
+    area: {
+        x0: number;
+        y0: number;
+        x1: number;
+        y1: number;
+    };
+};