@johnmorrisdotca/kyogijo-stadiums 0.4.0 → 0.6.0

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

package/dist/uprights.track.js

@@ -0,0 +1,246 @@
+// What stands in an athletics stadium and at a skating rink, in 3D: the hurdles of the races drawn and the steeplechase's barriers with the water jump's, the uprights and bars of the high jump and the
+// pole vault, the discus and hammer cage; the padding round a long or short track and the boards of a figure skating rink. 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 heights are cited in docs/sources.md ("Heights in the 3D view"): the cage's from the Track and Field
+// Facilities Manual 2019 (2.4.1.3), the hurdles' and the barriers' from the Technical Rules (22, 23), the padding's from the ISU's Rule 228.2; the bars' heights are ours, a bar being set at the height of
+// the competition.
+import { athleticsPlan } from "./athletics/plan.js";
+import { outward, ahead } from "./athletics/races.js";
+import { HURDLE, INSIDE, OUTSIDE, scPose } from "./athletics/steeplechase.js";
+import { laneRadius, pose } from "./athletics/track.js";
+import { feet } from "./pool.js";
+import { iceRadius } from "./skating/long.js";
+import { skatingPlan } from "./skating/plan.js";
+import { bar, mesh, n, plane, pole, shy, threads, wall } from "./turn.kit.js";
+import { BOARD_HEIGHT } from "./uprights.rinks.js";
+/** 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 const HURDLE_HEIGHT = { "110m-hurdles": 1.067, "60m-hurdles": 1.067, "100m-hurdles": 0.838, "400m-hurdles": 0.914, steeplechase: 0.914 };
+/** A hurdle is 1.18 to 1.20 m wide (Rule 22): 1.2 m is drawn. */
+const HURDLE_WIDTH = 1.2;
+/** 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 const CAGE = { low: 4, high: 6, 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 const JUMPS = { highUprights: 4.02, highBar: 2, highPost: 2.5, vaultUprights: 5.2, vaultBar: 5, vaultPost: 6, 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 const PADDING = { height: 0.8 };
+/** A hurdle: a bar across the lane with stripes on its top, and its two uprights. */
+function hurdlePlane(id, a, b, height, thin) {
+    const run = Math.hypot(b[0] - a[0], b[1] - a[1]);
+    const top = Math.max(feet(0.07), thin);
+    const stripes = 8;
+    let bands = "";
+    for (let i = 0; i < stripes; i += 1)
+        bands += `<rect x="${n((run * i) / stripes)}" width="${n(run / stripes)}" height="${n(top)}" class="${i % 2 === 0 ? "u-white" : "u-leg"}"/>`;
+    const side = Math.max(feet(0.04), thin * 0.8);
+    const sides = `<rect width="${n(side)}" height="${n(height)}" class="u-leg"/><rect x="${n(run - side)}" width="${n(side)}" height="${n(height)}" class="u-leg"/>`;
+    return wall(id, "wall", a[0], a[1], b[0], b[1], 0, height, `${sides}${bands}`);
+}
+/** The hurdles of the races a drawing marks, and the steeplechase's barriers. */
+function hurdles(plan, at, thin) {
+    const planes = [];
+    const o = plan.oval;
+    for (const race of plan.races) {
+        if (race.hurdles === undefined)
+            continue;
+        const height = feet(HURDLE_HEIGHT[race.race.id] ?? HURDLE_HEIGHT["110m-hurdles"]);
+        for (const { lane, at: marks } of race.hurdles) {
+            marks.forEach((s, k) => {
+                const id = `hurdle-${race.race.id}-${lane}-${k + 1}`;
+                if (race.race.kind === "straight") {
+                    // The lane of the straight: from its top line to the next, the 50 mm line on its right left out.
+                    const top = plan.straight?.y0 ?? o.radius;
+                    const sl = plan.straight?.lane ?? o.lane;
+                    const y = top + (lane - 0.5) * sl - 0.025;
+                    planes.push(hurdlePlane(id, at(s + 0.1, y - HURDLE_WIDTH / 2), at(s + 0.1, y + HURDLE_WIDTH / 2), height, thin));
+                }
+                else {
+                    // On the oval: the point of the running line at that distance, and the middle of the lane across from it.
+                    const run = laneRadius(o, lane);
+                    const p = pose(o, run, s);
+                    const [nx, ny] = outward(p.heading);
+                    const rc = o.radius + (lane - 0.5) * o.lane - 0.025;
+                    const c = [p.x + (rc - run) * nx, p.y + (rc - run) * ny];
+                    planes.push(hurdlePlane(id, at(c[0] - (HURDLE_WIDTH / 2) * nx, c[1] - (HURDLE_WIDTH / 2) * ny), at(c[0] + (HURDLE_WIDTH / 2) * nx, c[1] + (HURDLE_WIDTH / 2) * ny), height, thin));
+                }
+            });
+        }
+    }
+    const items = [];
+    if (planes.length > 0)
+        items.push({ id: "hurdles", kind: "hurdles", at: [0, 0], height: Math.max(...planes.map((p) => -p.v[2])), planes });
+    if (plan.waterJump !== undefined) {
+        const barriers = [];
+        const variant = plan.waterJump;
+        const h = feet(HURDLE_HEIGHT.steeplechase);
+        (variant === "outside" ? OUTSIDE.hurdles : INSIDE.hurdles).forEach((s, i) => {
+            const p = scPose(o, variant, s);
+            const [nx, ny] = outward(p.heading);
+            const width = i === 3 ? HURDLE.pit : HURDLE.width;
+            const a = -p.innerOffset - HURDLE.inside;
+            const [x0, y0] = at(p.x + a * nx, p.y + a * ny);
+            const [x1, y1] = at(p.x + (a + width) * nx, p.y + (a + width) * ny);
+            const run = Math.hypot(x1 - x0, y1 - y0);
+            const cap = Math.max(feet(HURDLE.bar), thin);
+            barriers.push(wall(i === 3 ? "water-jump-barrier" : `steeplechase-barrier-${i + 1}`, "wall", x0, y0, x1, y1, 0, h, `<rect width="${n(run)}" height="${n(h)}" class="u-board"/><rect width="${n(run)}" height="${n(cap)}" class="u-leg"/>`));
+            if (i === 3) {
+                // The pit, 3.66 m along the run from its barrier and 3.66 m across: the water, level with the track.
+                const [fx, fy] = ahead(p.heading);
+                const lift = 0.04;
+                barriers.push(plane("water-pit", "board", [x0, y0, lift], [fx * feet(HURDLE.pit), fy * feet(HURDLE.pit), 0], [x1 - x0, y1 - y0, 0], `<rect width="${n(feet(HURDLE.pit))}" height="${n(run)}" class="u-pad"/>`));
+            }
+        });
+        items.push({ id: "steeplechase", kind: "steeplechase", at: [0, 0], height: h, planes: barriers });
+    }
+    return items;
+}
+/** The high jump's two sets of uprights with their bars, and the pole vault's. */
+function jumps(plan, at, thin) {
+    const items = [];
+    const posts = Math.max(feet(0.05), thin * 1.2);
+    const bars = Math.max(feet(0.03), thin * 0.7);
+    const high = [];
+    const vault = [];
+    for (const f of plan.facilities) {
+        if (f.event !== "high-jump" && f.event !== "pole-vault")
+            continue;
+        const [ux, uy] = ahead(f.heading);
+        const [vx, vy] = outward(f.heading);
+        const isHigh = f.event === "high-jump";
+        const half = (isHigh ? JUMPS.highUprights : JUMPS.vaultUprights) / 2;
+        // The pole vault's uprights stand 0.1 m beyond the middle of the stop board (the drawing's); the high jump's on the take-off line.
+        const along = isHigh ? 0 : 0.1;
+        const a = at(f.x + along * ux - half * vx, f.y + along * uy - half * vy);
+        const b = at(f.x + along * ux + half * vx, f.y + along * uy + half * vy);
+        const top = feet(isHigh ? JUMPS.highPost : JUMPS.vaultPost);
+        const barZ = feet(isHigh ? JUMPS.highBar : JUMPS.vaultBar);
+        const out = isHigh ? high : vault;
+        out.push(...pole(`${f.id}-upright-a`, "post", a[0], a[1], 0, top, posts, "u-pole"), ...pole(`${f.id}-upright-b`, "post", b[0], b[1], 0, top, posts, "u-pole"));
+        // The high jump's bar runs from upright to upright; the vault's rests on supports between them and is 4.5 m long.
+        if (isHigh)
+            out.push(...bar(`${f.id}-bar`, "post", [a[0], a[1], barZ], [b[0], b[1], barZ], bars, "u-white"));
+        else {
+            const m = [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2];
+            const d = Math.hypot(b[0] - a[0], b[1] - a[1]);
+            const k = (feet(JUMPS.vaultBarLength) / 2) / d;
+            out.push(...bar(`${f.id}-bar`, "post", [m[0] - (b[0] - a[0]) * k, m[1] - (b[1] - a[1]) * k, barZ], [m[0] + (b[0] - a[0]) * k, m[1] + (b[1] - a[1]) * k, barZ], bars, "u-white"));
+        }
+    }
+    if (high.length > 0)
+        items.push({ id: "high-jump", kind: "high-jump", at: [0, 0], height: feet(JUMPS.highBar), planes: high });
+    if (vault.length > 0)
+        items.push({ id: "pole-vault", kind: "pole-vault", at: [0, 0], height: feet(JUMPS.vaultBar), planes: vault });
+    return items;
+}
+/** The discus and hammer cage: netting 4 m high, 6 m for the 3 m nearest the front of each side, along the plan's U (the mouth 6 m wide 7 m in front of the circle's centre). */
+function cage(plan, at, thin) {
+    const seen = new Set();
+    const planes = [];
+    const cell = Math.max(feet(0.5), thin * 4);
+    const netting = (id, a, b, z, h) => {
+        const [x0, y0] = at(a[0], a[1]);
+        const [x1, y1] = at(b[0], b[1]);
+        const run = Math.hypot(x1 - x0, y1 - y0);
+        if (run <= 0)
+            return;
+        planes.push(wall(id, "wall", x0, y0, x1, y1, z, z + h, `<rect width="${n(run)}" height="${n(h)}" class="u-netfill"/>${threads(mesh(run, h, cell), cell)}<rect width="${n(run)}" height="${n(Math.max(thin * 0.5, 0.1))}" class="u-cap"/>`));
+    };
+    for (const f of plan.facilities) {
+        if (f.event !== "discus-throw" && f.event !== "hammer-throw")
+            continue;
+        const key = `${f.x.toFixed(2)},${f.y.toFixed(2)}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        const [ux, uy] = ahead(f.heading);
+        const [vx, vy] = outward(f.heading);
+        const pt = (u, v) => [f.x + u * ux + v * vx, f.y + u * uy + v * vy];
+        // The sides, from the mouth back to the circle's level: the first 3 m of each at 6 m, the rest at 4 m. The line is the plan's own: (7, ±3) to (0, ±4.4).
+        for (const side of [-1, 1]) {
+            const mouth = pt(7, side * 3);
+            const back = pt(0, side * 4.4);
+            const length = Math.hypot(back[0] - mouth[0], back[1] - mouth[1]);
+            const t = CAGE.highLength / length;
+            const mid = [mouth[0] + (back[0] - mouth[0]) * t, mouth[1] + (back[1] - mouth[1]) * t];
+            netting(`cage-side-${side < 0 ? "a" : "b"}-front`, mouth, mid, 0, feet(CAGE.high));
+            netting(`cage-side-${side < 0 ? "a" : "b"}-back`, mid, back, 0, feet(CAGE.low));
+        }
+        // The rear: the half circle of 4.4 m about the centre, behind it, in eight chords.
+        const steps = 8;
+        for (let i = 0; i < steps; i += 1) {
+            const p0 = (Math.PI * i) / steps;
+            const p1 = (Math.PI * (i + 1)) / steps;
+            const g = (p) => pt(-4.4 * Math.sin(p), -4.4 * Math.cos(p));
+            netting(`cage-rear-${i + 1}`, g(p0), g(p1), 0, feet(CAGE.low));
+        }
+    }
+    return planes.length === 0 ? [] : [{ id: "cage", kind: "cage", at: [0, 0], height: feet(CAGE.high), planes }];
+}
+/** An athletics stadium's uprights, as the plan has its box. */
+export function athleticsUprights(o, thin) {
+    const plan = athleticsPlan({ ...o, detail: o.detail });
+    const at = (x, y) => [feet(x - plan.box.x0), feet(y - plan.box.y0)];
+    return {
+        items: [...hurdles(plan, at, thin), ...jumps(plan, at, thin), ...cage(plan, at, thin)],
+        area: { x0: 0, y0: 0, x1: feet(plan.box.x1 - plan.box.x0), y1: feet(plan.box.y1 - plan.box.y0) },
+    };
+}
+/** The walls of a closed outline of points, as planes of `height`: each segment is a wall whose inner face is drawn, giving way to the eye. */
+function walls(id, points, height, side, top, thin, centre) {
+    const planes = [];
+    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 cap = Math.max(thin * 0.8, 0.1);
+        planes.push(shy(wall(`${id}-${i}`, "wall", x0, y0, x1, y1, 0, height, `<rect width="${n(run)}" height="${n(height)}" class="${side}"/><rect width="${n(run)}" height="${n(cap)}" class="${top}"/>`), centre));
+    }
+    return planes;
+}
+/** A stadium's outline (two straights of `f` between the centres of two half circles of radius `r`) as points about the origin, in metres. */
+function stadiumPoints(f, r, steps = 14) {
+    const out = [[-f / 2, -r]];
+    for (let i = 0; i <= steps; i += 1) {
+        const a = (Math.PI * i) / steps;
+        out.push([f / 2 + r * Math.sin(a), -r * Math.cos(a)]);
+    }
+    for (let i = 0; i <= steps; i += 1) {
+        const a = (Math.PI * i) / steps;
+        out.push([-f / 2 - r * Math.sin(a), r * Math.cos(a)]);
+    }
+    return out;
+}
+/** A rounded rectangle's outline, half sizes `hx`, `hy` and corner radius `k`, as points about the origin, in metres. */
+function roundedPoints(hx, hy, k, steps = 6) {
+    const out = [];
+    const corners = [[hx - k, -hy + k, -Math.PI / 2], [hx - k, hy - k, 0], [-hx + k, hy - k, Math.PI / 2], [-hx + k, -hy + k, Math.PI]];
+    for (const [cx, cy, a0] of corners)
+        for (let i = 0; i <= steps; i += 1)
+            out.push([cx + k * Math.cos(a0 + ((Math.PI / 2) * i) / steps), cy + k * Math.sin(a0 + ((Math.PI / 2) * i) / steps)]);
+    return out;
+}
+/** 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 function skatingUprights(o, thin) {
+    const plan = skatingPlan({ ...o, detail: o.detail });
+    const at = (p) => [feet(p[0] - plan.box.x0), feet(p[1] - plan.box.y0)];
+    const area = { x0: 0, y0: 0, x1: feet(plan.box.x1 - plan.box.x0), y1: feet(plan.box.y1 - plan.box.y0) };
+    const centre = at([0, 0]);
+    const items = [];
+    const style = o.skating;
+    const padding = style?.padding !== false;
+    if (plan.oval !== undefined && padding) {
+        const R = iceRadius(plan.oval);
+        const points = stadiumPoints(plan.oval.straight, R).map(at);
+        items.push({ id: "padding", kind: "padding", at: centre, height: feet(PADDING.height), planes: walls("padding", points, feet(PADDING.height), "u-pad", "u-cap", thin, centre) });
+    }
+    else if (plan.short !== undefined && padding) {
+        const points = roundedPoints(plan.short.length / 2, plan.short.width / 2, 8.5).map(at);
+        items.push({ id: "padding", kind: "padding", at: centre, height: feet(PADDING.height), planes: walls("padding", points, feet(PADDING.height), "u-pad", "u-cap", thin, centre) });
+    }
+    else if (plan.rink !== undefined) {
+        const fig = plan.figures;
+        const points = roundedPoints(plan.rink.length / 2, plan.rink.width / 2, fig.corner ?? 8.5).map(at);
+        items.push({ id: "rink-boards", kind: "rink-boards", at: centre, height: BOARD_HEIGHT, planes: walls("board", points, BOARD_HEIGHT, "u-board", "u-cap", thin, centre) });
+    }
+    return { items, area };
+}

package/dist/version.d.ts

@@ -1,2 +1,2 @@
 /** The package's version: the same as package.json's, and a test holds them to each other. */
-export declare const VERSION = "0.4.0";
+export declare const VERSION = "0.6.0";

package/dist/version.js

@@ -1,2 +1,2 @@
 /** The package's version: the same as package.json's, and a test holds them to each other. */
-export const VERSION = "0.4.0";
+export const VERSION = "0.6.0";

package/dist/zones-entry.d.ts

@@ -0,0 +1,2 @@
+export { PARKS_WITHOUT_WALL_HEIGHTS, RULE_IDS, betweenHashes, homeRun, inCrease, inPaint, inPenaltyArea, inRedZone, inRestrictedArea, inSixYardBox, inSlot, isFair, isHomeRun, isThreePointer, onWarningTrack, overWall, wallHeightAt, zoneAt, zoneAtSurface, zoneName, zoneResolver } from "./rules.ts";
+export type { HomeRunOptions, HomeRunVerdict, PlaceLike, RuleId, ZoneAnswer, ZoneOptions } from "./rules.ts";

package/dist/zones-entry.js

@@ -0,0 +1,2 @@
+// The rulebook as code: where a point lies on a surface in the sport's own terms (the zone, the area in it, every other area that holds), and the yes-or-no questions a coach asks.
+export { PARKS_WITHOUT_WALL_HEIGHTS, RULE_IDS, betweenHashes, homeRun, inCrease, inPaint, inPenaltyArea, inRedZone, inRestrictedArea, inSixYardBox, inSlot, isFair, isHomeRun, isThreePointer, onWarningTrack, overWall, wallHeightAt, zoneAt, zoneAtSurface, zoneName, zoneResolver } from "./rules.js";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@johnmorrisdotca/kyogijo-stadiums",
-  "version": "0.4.0",
-  "description": "Kyogijo Stadiums 競技場, sports surfaces as SVG, drawn to scale from the rulebooks: NFL, CFL and IFAF football fields, an NHL rink, an NBA court and MLB ballparks, with each team's name and logo on its side and the score in the middle. Light and dark, accessible, a compact badge for lists, a helper for React and a custom element. Zero dependencies.",
+  "version": "0.6.0",
+  "description": "Kyogijo Stadiums 競技場, 39 sports' surfaces as SVG, drawn to scale from the rulebooks: NFL, CFL and IFAF football fields, an NHL rink, an NBA court, MLB ballparks, soccer pitches, curling sheets, athletics stadiums, speed skating, short track and figure skating rinks, swimming pools, water polo fields, diving wells, artistic swimming areas, and the courts and fields of tennis, volleyball (indoor, beach and sitting), badminton, pickleball, table tennis, padel, squash, racquetball, sepak takraw, teqball, roundnet, netball, lacrosse, rugby, Australian football, Gaelic games, cricket, field hockey and handball, and the budo of judo, karate, kendo, sumo and kyudo with a dojo of tatami laid as real units, with each team's name and logo on its side and the score in the middle, stands and a crowd, a pageant of flags, and a 3D view. Light and dark, accessible, a compact badge for lists, a helper for React and a custom element. Zero dependencies.",
   "keywords": [
     "sports",
     "scoreboard",
@@ -43,7 +43,14 @@
     "zero-dependencies",
     "browser",
     "node",
-    "itsutsu"
+    "itsutsu",
+    "judo",
+    "karate",
+    "kendo",
+    "sumo",
+    "kyudo",
+    "dojo",
+    "tatami"
   ],
   "homepage": "https://johnmorrisdotca.github.io/kyogijo-stadiums/",
   "repository": {
@@ -114,6 +121,11 @@
       "import": "./dist/eras-entry.js",
       "default": "./dist/eras-entry.js"
     },
+    "./arenas": {
+      "types": "./dist/arenas-entry.d.ts",
+      "import": "./dist/arenas-entry.js",
+      "default": "./dist/arenas-entry.js"
+    },
     "./grounds": {
       "types": "./dist/grounds-entry.d.ts",
       "import": "./dist/grounds-entry.js",
@@ -129,6 +141,21 @@
       "import": "./dist/atlas-entry.js",
       "default": "./dist/atlas-entry.js"
     },
+    "./athletics": {
+      "types": "./dist/athletics-entry.d.ts",
+      "import": "./dist/athletics-entry.js",
+      "default": "./dist/athletics-entry.js"
+    },
+    "./skating": {
+      "types": "./dist/skating-entry.d.ts",
+      "import": "./dist/skating-entry.js",
+      "default": "./dist/skating-entry.js"
+    },
+    "./budo": {
+      "types": "./dist/budo-entry.d.ts",
+      "import": "./dist/budo-entry.js",
+      "default": "./dist/budo-entry.js"
+    },
     "./charts": {
       "types": "./dist/charts-entry.d.ts",
       "import": "./dist/charts-entry.js",
@@ -174,6 +201,26 @@
       "import": "./dist/png-entry.js",
       "default": "./dist/png-entry.js"
     },
+    "./zones": {
+      "types": "./dist/zones-entry.d.ts",
+      "import": "./dist/zones-entry.js",
+      "default": "./dist/zones-entry.js"
+    },
+    "./pointer": {
+      "types": "./dist/pointer-entry.d.ts",
+      "import": "./dist/pointer-entry.js",
+      "default": "./dist/pointer-entry.js"
+    },
+    "./target": {
+      "types": "./dist/target-entry.d.ts",
+      "import": "./dist/target-entry.js",
+      "default": "./dist/target-entry.js"
+    },
+    "./turn": {
+      "types": "./dist/turn-entry.d.ts",
+      "import": "./dist/turn-entry.js",
+      "default": "./dist/turn-entry.js"
+    },
     "./element/define": {
       "types": "./dist/element-define.d.ts",
       "import": "./dist/element-define.js",
@@ -213,15 +260,21 @@
     "test:readme": "pnpm build && node scripts/check-readme-examples.mjs",
     "docs:make": "node scripts/docs.mjs",
     "parks": "node scripts/build-parks.mjs",
+    "arenas": "node scripts/build-arenas.mjs",
+    "arenas:fetch": "node scripts/fetch-arenas.mjs",
+    "arenas:check": "node scripts/check-arenas.mjs",
     "grounds": "node scripts/build-grounds.mjs",
     "grounds:check": "node scripts/check-grounds.mjs",
     "parks:coordinates": "node scripts/fetch-park-coordinates.mjs",
     "names:fetch": "node scripts/fetch-names.mjs",
+    "tenants": "node scripts/build-tenants.mjs",
+    "tenants:fetch": "node scripts/fetch-tenants.mjs",
     "parks:check": "node scripts/check-parks.mjs"
   },
   "devDependencies": {
     "@eslint/js": "^9.0.0",
     "@johnmorrisdotca/chizu": "1.4.0",
+    "@johnmorrisdotca/dougu-sports": "0.2.0",
     "@playwright/test": "^1.63.0",
     "eslint": "^9.0.0",
     "marked": "^18.1.1",