@johnmorrisdotca/kyogijo-stadiums 0.4.0 → 0.6.0

package/dist/athletics/infield.js

@@ -0,0 +1,166 @@
+// The standard stadium's field events, each in its usual place (Track and Field Facilities Manual 2019, 2.5, Figure 2.5a "Standard layout of competition facility", and the Marking Plan for the 400 m
+// Standard Track, Figure 2.2.1.6a, at 1:350): the pole vaults and the shot put circles in the first segment, the discus and hammer circle, the high jumps and the other shot put in the second, a
+// javelin runway through the middle of each, and the long and triple jumps beyond the back straight. The places are read off the Marking Plan to the metre, which is the precision of its scale; the
+// sizes of everything are the Manual's and the Rules'. Metres, in the frame of track.ts.
+import { line } from "../fields.kit.js";
+import { num } from "../format.js";
+import { bounds, cageShapes, circleParts, highJumpParts, javelinParts, pitParts, poleVaultEnd, rectArea, runwayLines, sectorShapes, stopBoard, takeOffBoard, } from "./facilities.js";
+import { addParts, emptyParts } from "./oval.js";
+/** The sectors' lengths (Manual 2.1.1.3 and Figures 2.4.1.1, 2.4.2.1, 2.4.3.1, 2.4.4.1): the shot's 25 m, the discus's 80 m, the hammer's 90 m, the javelin's 100 m. */
+export const SECTOR_REACH = { "shot-put": 25, "discus-throw": 80, "hammer-throw": 90, "javelin-throw": 100 };
+/** Where the standard stadium puts each facility, in metres from the centre of the semicircle of its segment (CP1 at the left, CP2 at the right), read from the Marking Plan. */
+export const ARENA = {
+    /** The synthetic surface of a segment ends, and the turf of the infield begins, this far from the semicircle's centre along the straights' axis (Marking Plan; 108.39 m of turf between: a 105 m pitch fits). */
+    turf: 12,
+    /** The javelin arc's apex is this far beyond the segment's centre; the centre point is 8 m behind it. */
+    javelinApex: 55.1 - 42.195,
+    /** The shot put circles: from the segment's centre outward along the axis, and the distance up or down. */
+    shotWest: { out: 13.5, across: 18.15 },
+    shotEast: { out: 14.2, across: 18.5 },
+    /** The combined discus and hammer circle of the second segment. */
+    discus: { out: 20.4, across: -24.1, heading: Math.PI * (1 - 0.097) },
+    /** The two pole vault runways of the first segment: their middle lines, the boxes' places and the length, from the axis. */
+    vaultA: { out: 23.26, box: 16.5 },
+    vaultB: { out: 15.82, box: 20.7 },
+    vaultReach: 26,
+    /** The high jumps: the bar's distance beyond the segment's centre and the distance of each from the axis (the spacing of two sets of uprights is 12 to 15 m: 13.5 m). */
+    highJump: { out: 15, across: 6.75 },
+    /** The long and triple jump beyond the back straight (Figure 2.5a, Marking Plan): the strip, the two runways' middle lines, and the pits' places along the straight. */
+    strip: { x0: -45.6, x1: 46.2, y0: -56.6 },
+    rows: [
+        { y: -54.2, west: [-39.7, -31.7], east: [23, 31.1] },
+        { y: -50.4, west: [-30.9, -22.9], east: [31.9, 40] },
+    ],
+};
+const rad = (deg) => (deg * Math.PI) / 180;
+void rad;
+/** The standard stadium's field events, those asked for. */
+export function infieldParts(o, events) {
+    const parts = emptyParts();
+    const facilities = [];
+    const S = o.straight;
+    const cp1x = -S / 2;
+    const cp2x = S / 2;
+    const has = (e) => events.has(e);
+    // The javelin: a runway through the middle of each segment, thrown towards the middle of the infield.
+    if (has("javelin-throw")) {
+        const apex = ARENA.javelinApex;
+        for (const [id, cx, heading] of [
+            ["javelin-west", cp1x - apex - 8 + 0, 0],
+            ["javelin-east", cp2x + apex + 8, Math.PI],
+        ]) {
+            // The centre point is 8 m behind the arc's apex, so beyond the segment's centre by `apex + 8` on its own side.
+            const made = javelinParts(id, [id === "javelin-west" ? cp1x - apex - 8 : cx, 0], heading);
+            addParts(parts, made.parts);
+            facilities.push(made.facility);
+        }
+    }
+    // The shot put: two circles in the first segment, throwing to the east, and one in the second, throwing to the west.
+    if (has("shot-put")) {
+        const circles = [
+            ["shot-west-north", [cp1x - ARENA.shotWest.out, -ARENA.shotWest.across], 0],
+            ["shot-west-south", [cp1x - ARENA.shotWest.out, ARENA.shotWest.across], 0],
+            ["shot-east-south", [cp2x + ARENA.shotEast.out, ARENA.shotEast.across], Math.PI],
+        ];
+        for (const [id, c, heading] of circles) {
+            addParts(parts, circleParts(id, "shot-put", c, heading, 2.135));
+            parts.areas.push(stopBoard(id, c, heading, 2.135));
+            parts.shapes.push(...sectorShapes(id, "shot-put", c, heading, 1.0675, SECTOR_REACH["shot-put"]));
+            const reach = SECTOR_REACH["shot-put"];
+            facilities.push({ id, event: "shot-put", x: c[0], y: c[1], heading, reach, box: bounds([c, [c[0] + Math.cos(heading) * reach, c[1] + Math.sin(heading) * reach + reach * 0.31], [c[0] + Math.cos(heading) * reach, c[1] + Math.sin(heading) * reach - reach * 0.31]]) });
+        }
+    }
+    // The discus and the hammer: one circle and cage in the second segment, near the 1500 m start, throwing across the infield.
+    if (has("discus-throw") || has("hammer-throw")) {
+        const c = [cp2x + ARENA.discus.out, ARENA.discus.across];
+        const heading = ARENA.discus.heading;
+        const both = has("discus-throw") && has("hammer-throw");
+        // A circle of 2.50 m, reduced to 2.135 m for the hammer by a ring inside it (Rule 32, throwing circle): both are drawn when both events are.
+        addParts(parts, circleParts("discus-hammer", has("discus-throw") ? "discus-throw" : "hammer-throw", c, heading, has("discus-throw") ? 2.5 : 2.135));
+        if (both)
+            parts.shapes.push(...circleParts("hammer-insert", "hammer-throw", c, heading, 2.135).shapes.filter((s) => s.kind === "ring"));
+        parts.shapes.push(...cageShapes("discus-hammer", c, heading));
+        const reach = has("hammer-throw") ? SECTOR_REACH["hammer-throw"] : SECTOR_REACH["discus-throw"];
+        parts.shapes.push(...sectorShapes("discus-hammer", has("discus-throw") ? "discus-throw" : "hammer-throw", c, heading, has("discus-throw") ? 1.25 : 1.0675, reach));
+        if (both) {
+            // The discus's shorter arc across the same sector.
+            const half = Math.asin(0.3);
+            const a = heading - half;
+            const b = heading + half;
+            const r = SECTOR_REACH["discus-throw"];
+            const p = [c[0] + r * Math.cos(a), c[1] + r * Math.sin(a)];
+            const q = [c[0] + r * Math.cos(b), c[1] + r * Math.sin(b)];
+            parts.shapes.push({ kind: "path", id: "discus-sector-arc", feature: "discus-throw", d: `M${num(p[0])} ${num(p[1])}A${num(r)} ${num(r)} 0 0 1 ${num(q[0])} ${num(q[1])}` });
+        }
+        const end = [c[0] + Math.cos(heading) * reach, c[1] + Math.sin(heading) * reach];
+        for (const event of ["discus-throw", "hammer-throw"])
+            if (has(event))
+                facilities.push({ id: event === "discus-throw" ? "discus" : "hammer", event, x: c[0], y: c[1], heading, reach: SECTOR_REACH[event], box: bounds([c, [end[0], end[1] + 0.31 * reach], [end[0], end[1] - 0.31 * reach], [c[0] - 5, c[1] - 5], [c[0] + 8, c[1] + 8]]) });
+    }
+    // The high jump: two, symmetrical about the javelin runway of the second segment, the athletes running up from the track and jumping towards the middle.
+    if (has("high-jump")) {
+        for (const [id, side] of [["high-jump-north", -1], ["high-jump-south", 1]]) {
+            const made = highJumpParts(id, [cp2x + ARENA.highJump.out, side * ARENA.highJump.across], Math.PI);
+            addParts(parts, made.parts);
+            facilities.push(made.facility);
+        }
+    }
+    // The pole vault: two runways in the first segment, each with a box and a mat at both ends, and the runway cut where the javelin's crosses it.
+    if (has("pole-vault")) {
+        for (const [name, v] of [["pole-vault-a", ARENA.vaultA], ["pole-vault-b", ARENA.vaultB]]) {
+            const x = cp1x - v.out;
+            const reach = ARENA.vaultReach;
+            const gap = has("javelin-throw") ? 2.1 : 0;
+            for (const side of [-1, 1]) {
+                const lo = side === -1 ? -reach : gap;
+                const hi = side === -1 ? -gap : reach;
+                parts.shapes.push(...runwayLines(`${name}-${side}`, "pole-vault", [x, lo], [x, hi]));
+            }
+            for (const side of [-1, 1]) {
+                const made = poleVaultEnd(`${name}-${side === -1 ? "north" : "south"}`, [x, side * v.box], side === -1 ? -Math.PI / 2 : Math.PI / 2);
+                // The vaulter runs towards the box from the far end, so the box's 0-line faces the mat beyond it, away from the runway's middle.
+                addParts(parts, made.parts);
+                facilities.push(made.facility);
+            }
+        }
+    }
+    // The long and the triple jump, beyond the back straight: two runways in a strip, each with a pit at either end, a take-off board for each run.
+    if (has("long-jump") || has("triple-jump")) {
+        const strip = { id: "jump-strip", feature: "track", cls: "ky-ath-track", d: `M${num(ARENA.strip.x0)} ${num(ARENA.strip.y0)}H${num(ARENA.strip.x1)}V${num(-o.radius - o.lanes * o.lane + 0.3)}H${num(ARENA.strip.x0)}Z` };
+        parts.areas.push(strip);
+        const boxes = [];
+        for (const [r, row] of ARENA.rows.entries()) {
+            const west = row.west;
+            const east = row.east;
+            // The runway between the pits' near ends, and across both to the pits' far ends so that it reads as one facility with a pit at either end.
+            parts.shapes.push(...runwayLines(`jump-${r}`, has("long-jump") ? "long-jump" : "triple-jump", [west[1], row.y], [east[0], row.y]));
+            for (const [pit, edge, heading, name] of [
+                [west, west[1], Math.PI, "west"],
+                [east, east[0], 0, "east"],
+            ]) {
+                const id = `jump-${r}-${name}`;
+                const event = has("long-jump") ? "long-jump" : "triple-jump";
+                addParts(parts, pitParts(id, event, [(pit[0] + pit[1]) / 2, row.y], 0, pit[1] - pit[0], 3));
+                const jumpHeading = heading;
+                // The athlete runs towards the pit: for the west pit that is westward, so the board is east of the pit's near end (the east edge), and the run comes from the east.
+                const near = [edge, row.y];
+                if (has("long-jump"))
+                    parts.areas.push(takeOffBoard(`${id}-lj-board`, "long-jump", near, jumpHeading + 0, 3));
+                if (has("triple-jump")) {
+                    parts.areas.push(takeOffBoard(`${id}-tj-board-men`, "triple-jump", near, jumpHeading, 13), takeOffBoard(`${id}-tj-board-women`, "triple-jump", near, jumpHeading, 11));
+                }
+                boxes.push({ x0: pit[0] - 1, x1: pit[1] + 1, y0: row.y - 2, y1: row.y + 2 });
+                // One facility for each of the two events that jump into this pit, the pit's near end being its place.
+                for (const e of ["long-jump", "triple-jump"])
+                    if (has(e))
+                        facilities.push({ id, event: e, x: edge, y: row.y, heading: jumpHeading, reach: 45, box: { x0: Math.min(pit[0], pit[1]) - 1, x1: Math.max(pit[0], pit[1]) + 1, y0: row.y - 2.5, y1: row.y + 2.5 } });
+            }
+        }
+        void boxes;
+    }
+    void line;
+    void rectArea;
+    return { parts, facilities };
+}
+/** The strip beyond the back straight where the long and the triple jumps are, as a box, when they are drawn. */
+export const jumpStrip = () => ({ x0: ARENA.strip.x0, y0: ARENA.strip.y0, x1: ARENA.strip.x1, y1: -46 });

package/dist/athletics/layout.d.ts

@@ -0,0 +1,13 @@
+import { type Facility } from "./facilities.ts";
+import { type Parts } from "./oval.ts";
+import type { MBox, MMark } from "./plan.ts";
+import type { AthleticsFieldEvent } from "./types.ts";
+/** What a field event alone is: its shapes, its facility as data, the box round it and the parts to label. */
+export interface Layout {
+    parts: Parts;
+    facility: Facility;
+    box: MBox;
+    marks: MMark[];
+}
+/** The layout of one field event alone. */
+export declare function layoutOf(event: AthleticsFieldEvent): Layout;

package/dist/athletics/layout.js

@@ -0,0 +1,98 @@
+// One field event alone, at a large scale, from the diagram of its facility (Track and Field Facilities Manual 2019, Figures 2.3.1.1a, 2.3.2.1, 2.3.3.1, 2.3.4.1, 2.4.1.1 to 2.4.4.2; Technical Rules 25 to 38 of
+// Book C2.1): the athlete throws or jumps to the right, from a point at the origin (a circle's centre, a javelin arc's centre point, a jump's take-off line, the bar, the vault's zero line). Metres.
+import { line } from "../fields.kit.js";
+import { num } from "../format.js";
+import { bounds, cageShapes, circleParts, highJumpParts, javelinParts, pitParts, poleVaultEnd, runwayLines, sectorShapes, stopBoard, takeOffBoard, SECTOR_ANGLE, } from "./facilities.js";
+import { addParts, emptyParts } from "./oval.js";
+import { SECTOR_REACH } from "./infield.js";
+const O = [0, 0];
+/** The landing sector as ground: mown grass between the sector lines from `rim` out to the arc (a circle's rim, or a javelin arc's). */
+function sectorGrass(id, event, reach, half, rim = 0) {
+    const at = (k, a) => `${num(k * Math.cos(a))} ${num(k * Math.sin(a))}`;
+    return { id: `${id}-sector-ground`, feature: event, cls: "ky-ath-grass", d: `M${at(rim, -half)}L${at(reach, -half)}A${num(reach)} ${num(reach)} 0 0 1 ${at(reach, half)}L${at(rim, half)}Z` };
+}
+/** A runway as ground: the track's own surface, `width` wide from `x0` to `x1`. */
+function runwayGround(id, event, x0, x1, width) {
+    return { id: `${id}-runway-ground`, feature: event, cls: "ky-ath-track", d: `M${num(x0)} ${num(-width / 2)}H${num(x1)}V${num(width / 2)}H${num(x0)}Z` };
+}
+/** The long jump's and the triple jump's facility: the runway 45 m long (Rule 29; Manual 2.3.1.2), the take-off boards, the landing area 3 m wide and 8 m long. */
+function jumpLayout(event) {
+    const parts = emptyParts();
+    parts.areas.push(runwayGround(event, event, -45, event === "long-jump" ? 3 : 13, 1.22));
+    // The pit: 8 m long, 3 m wide, its near end 3 m past the long jump's take-off line (Manual 2.3.1.4) or 13 m past the men's triple jump line (Rule 31: not less than 13 m for men, 11 for women).
+    const near = event === "long-jump" ? 3 : 13;
+    const len = 8;
+    addParts(parts, pitParts(event, event, [near + len / 2, 0], 0, len, 3));
+    parts.shapes.push(...runwayLines(event, event, [-45, 0], [near + len, 0]));
+    parts.areas.push(takeOffBoard(`${event}-board`, event, [near, 0], 0, near));
+    if (event === "triple-jump")
+        parts.areas.push(takeOffBoard(`${event}-board-women`, event, [near, 0], 0, 11));
+    // The window shows the last 24 m of the runway: the rest runs off its edge.
+    const box = { x0: -24, y0: -3.2, x1: near + len + 2, y1: 3.2 };
+    const facility = { id: event, event, x: 0, y: 0, heading: 0, box, reach: 45 };
+    const marks = [
+        { id: "runway", x: -25, y: -0.61, side: "top" },
+        { id: "take-off-board", x: -0.1, y: 0.6, side: "bottom" },
+        { id: "landing-area", x: near + len / 2, y: -1.5, side: "top" },
+    ];
+    return { parts, facility, box, marks };
+}
+/** The throws: a circle with its sector and, for the discus and the hammer, the cage; the shot's stop board. */
+function throwLayout(event) {
+    const parts = emptyParts();
+    const d = event === "discus-throw" ? 2.5 : 2.135;
+    const reach = SECTOR_REACH[event];
+    parts.areas.push(sectorGrass(event, event, reach, SECTOR_ANGLE / 2));
+    addParts(parts, circleParts(event, event, O, 0, d));
+    if (event === "shot-put")
+        parts.areas.push(stopBoard(event, O, 0, d));
+    else
+        parts.shapes.push(...cageShapes(event, O, 0));
+    parts.shapes.push(...sectorShapes(event, event, O, 0, d / 2, reach));
+    const half = SECTOR_ANGLE / 2;
+    const box = { x0: -8, y0: -reach * Math.sin(half) - 2, x1: reach + 2, y1: reach * Math.sin(half) + 2 };
+    const facility = { id: event, event, x: 0, y: 0, heading: 0, box, reach };
+    const marks = [
+        { id: "throwing-circle", x: 0, y: -d / 2 - 0.6, side: "top" },
+        { id: "sector", x: reach * 0.5, y: -reach * 0.5 * Math.tan(half), side: "top" },
+    ];
+    if (event === "shot-put")
+        marks.push({ id: "stop-board", x: d / 2, y: d / 2 + 0.5, side: "bottom" });
+    else
+        marks.push({ id: "cage", x: 7, y: -3, side: "top" });
+    return { parts, facility, box, marks };
+}
+/** The layout of one field event alone. */
+export function layoutOf(event) {
+    switch (event) {
+        case "long-jump":
+        case "triple-jump":
+            return jumpLayout(event);
+        case "shot-put":
+        case "discus-throw":
+        case "hammer-throw":
+            return throwLayout(event);
+        case "javelin-throw": {
+            const made = javelinParts("javelin", O, 0);
+            const half = Math.asin(2 / 8);
+            made.parts.areas.unshift(runwayGround("javelin", "javelin-throw", -36.5 + 8 * Math.cos(half), 8 * Math.cos(half), 4), sectorGrass("javelin", "javelin-throw", 100, half, 8));
+            const box = { x0: -18, y0: -100 * Math.sin(half) - 2, x1: 102, y1: 100 * Math.sin(half) + 2 };
+            return { parts: made.parts, facility: made.facility, box, marks: [{ id: "runway", x: -20, y: -2.1, side: "top" }, { id: "throwing-arc", x: 8, y: -1.5, side: "top" }, { id: "sector", x: 50, y: -50 * Math.tan(half), side: "top" }] };
+        }
+        case "high-jump": {
+            const made = highJumpParts("high-jump", O, 0);
+            made.parts.areas.unshift({ id: "high-jump-runway-ground", feature: "high-jump", cls: "ky-ath-track", d: `M0 -8H${num(-Math.sqrt(15 * 15 - 64))}A15 15 0 0 0 ${num(-Math.sqrt(15 * 15 - 64))} 8H0Z` });
+            const box = made.facility.box;
+            return { parts: made.parts, facility: made.facility, box: { x0: box.x0 - 1, y0: box.y0 - 1, x1: box.x1 + 1, y1: box.y1 + 1 }, marks: [{ id: "crossbar", x: 0, y: -2, side: "top" }, { id: "landing-mat", x: 1.5, y: 3.2, side: "bottom" }, { id: "run-up", x: -9, y: -8, side: "top" }] };
+        }
+        default: {
+            // The pole vault: a runway of 45 m to the box, the box, the zero line and the mat beyond.
+            const made = poleVaultEnd("pole-vault", O, 0);
+            made.parts.areas.unshift(runwayGround("pole-vault", "pole-vault", -45, 0, 1.22));
+            made.parts.shapes.push(...runwayLines("pole-vault", "pole-vault", [-45, 0], [0, 0]));
+            made.parts.shapes.push(line("pole-vault-runway-end", "pole-vault", -45, -0.61, -45, 0.61, { w: 0.05 }));
+            const box = bounds([[-24, -3.5], [9, 3.5]]);
+            return { parts: made.parts, facility: made.facility, box, marks: [{ id: "runway", x: -25, y: -0.61, side: "top" }, { id: "zero-line", x: 0, y: -2.9, side: "top" }, { id: "landing-mat", x: 4.2, y: 3.1, side: "bottom" }, { id: "box", x: -0.5, y: 0.5, side: "bottom" }] };
+        }
+    }
+}

package/dist/athletics/oval.d.ts

@@ -0,0 +1,57 @@
+import type { Area, Shape } from "../fields.types.ts";
+import type { AthleticsFigures } from "../leagues/athletics.ts";
+import { type Oval } from "./track.ts";
+/** A string of lane numbers painted on the track: the digits, how tall, where they are centred. They stand upright whatever way the page is turned. */
+export interface Digits {
+    id: string;
+    feature: string;
+    text: string;
+    x: number;
+    y: number;
+    h: number;
+    /** Drawn on a disc of the plate's colour, in the plate's ink, at a size that reads in a close-up (a tag), not painted on the track. */
+    tag?: boolean;
+    /** For a number behind a start line: the point of the line in this lane and the unit vector the athlete runs along, so that a tag can be moved back to clear the line. */
+    from?: readonly [x: number, y: number, fx: number, fy: number];
+}
+/** What a part of a plan adds: shapes and areas in painter's order, and digits. */
+export interface Parts {
+    areas: Area[];
+    shapes: Shape[];
+    digits: Digits[];
+}
+export declare const emptyParts: () => Parts;
+/** Add `more` to `into`. */
+export declare function addParts(into: Parts, more: Parts): void;
+/** The path of a stadium: two semicircles of radius `r` joined by straights of length `s`, about the origin. */
+export declare const stadiumD: (s: number, r: number) => string;
+/**
+ * A lane line of the oval, cut where the straight's surface lies over its bends (the straight runs on beyond the oval's, and the Marking Plan draws only the straight's own lines there): the bottom
+ * straight between the bends, the east bend from where it leaves the straight's run-out round to the top, the top straight, and the west bend as far as the straight's starting area.
+ */
+export declare function laneLineD(o: Oval, r: number, straight: StraightPlan | undefined): string;
+/** The radius of the outer edge of an oval's last lane. */
+export declare const outerRadius: (o: Oval) => number;
+/** The straight's geometry: its first and last x (the starting area before the longest race, the run-out beyond the finish line), its lanes and how wide each is. */
+export interface StraightPlan {
+    lanes: number;
+    lane: number;
+    x0: number;
+    x1: number;
+    /** The start of the longest race of the straight, in metres before the finish line. */
+    longest: number;
+    /** The straight's inside edge (the top of lane 1) and its finish line, in the plan's frame: the oval's finish straight runs on, the covered track's lies inside it. */
+    y0: number;
+    finish: number;
+}
+/** The straight that runs on beyond the oval's finish straight (Manual 2.2.2.1): at least six lanes, a starting area of 3 m before its longest race and a run-out of 17 m. */
+export declare function straightOf(o: Oval, fig: AthleticsFigures, lanes: number, longest: number): StraightPlan;
+/**
+ * The straight of a covered track (Rules 41 to 43; the Marking Plan for the Standard Short Track): lanes 1.22 m wide inside the oval, parallel to its straights, with a starting area of 3 m before a
+ * 60 m start line and a run-out beyond the finish line. Its place in the infield is ours: the Rules and the plan give its lanes and its length, not where it lies.
+ */
+export declare function indoorStraightOf(o: Oval, fig: AthleticsFigures, lanes: number, length: number): StraightPlan;
+/** The infield straight of a covered track: its surface, its lane lines, its start area's and run-out's ends and its finish line, and the lane numbers before the finish. */
+export declare function indoorStraightParts(st: StraightPlan, numbers: boolean, w: number): Parts;
+/** The surface of the oval and of the straight, the kerb, the lane lines, the finish line and the numbers before it. */
+export declare function ovalParts(o: Oval, fig: AthleticsFigures, straight: StraightPlan | undefined, numbers: boolean, hole?: string): Parts;

package/dist/athletics/oval.js

@@ -0,0 +1,116 @@
+// The oval, the straight that runs on beyond it and the finish: the surface of the track between its kerb and its outer edge, the lane lines, the kerb, the finish line and the lane numbers
+// before it. Every figure is the Track and Field Facilities Manual's (2019 edition, 2.2.1 and 2.2.2) or Technical Rule 14's of Book C2.1, in metres. Nothing here draws SVG: it makes the shapes.
+import { line, path } from "../fields.kit.js";
+import { num } from "../format.js";
+import { laneEdge } from "./track.js";
+export const emptyParts = () => ({ areas: [], shapes: [], digits: [] });
+/** Add `more` to `into`. */
+export function addParts(into, more) {
+    into.areas.push(...more.areas);
+    into.shapes.push(...more.shapes);
+    into.digits.push(...more.digits);
+}
+/** The path of a stadium: two semicircles of radius `r` joined by straights of length `s`, about the origin. */
+export const stadiumD = (s, r) => `M${num(-s / 2)} ${num(-r)}H${num(s / 2)}A${num(r)} ${num(r)} 0 0 1 ${num(s / 2)} ${num(r)}H${num(-s / 2)}A${num(r)} ${num(r)} 0 0 1 ${num(-s / 2)} ${num(-r)}Z`;
+/**
+ * A lane line of the oval, cut where the straight's surface lies over its bends (the straight runs on beyond the oval's, and the Marking Plan draws only the straight's own lines there): the bottom
+ * straight between the bends, the east bend from where it leaves the straight's run-out round to the top, the top straight, and the west bend as far as the straight's starting area.
+ */
+export function laneLineD(o, r, straight) {
+    if (straight === undefined)
+        return stadiumD(o.straight, r);
+    const S = o.straight;
+    const R = o.radius;
+    const wEast = straight.x1 - S / 2;
+    const wWest = -S / 2 - straight.x0;
+    // East bend, from the bottom (f = 0): inside the straight while its depth below the kerb line is positive and it is no further out than the run-out.
+    const fEast = Math.min(Math.acos(Math.min(1, R / r)), Math.asin(Math.min(1, wEast / r)));
+    // West bend, from the top: inside the straight from where it comes back below the kerb line and within the starting area.
+    const fWest = Math.max(Math.PI - Math.acos(Math.min(1, R / r)), Math.PI - Math.asin(Math.min(1, wWest / r)));
+    const e = [S / 2 + r * Math.sin(fEast), r * Math.cos(fEast)];
+    const w = [-S / 2 - r * Math.sin(fWest), -r * Math.cos(fWest)];
+    return `M${num(e[0])} ${num(e[1])}A${num(r)} ${num(r)} 0 0 0 ${num(S / 2)} ${num(-r)}H${num(-S / 2)}A${num(r)} ${num(r)} 0 0 0 ${num(w[0])} ${num(w[1])}M${num(-S / 2)} ${num(r)}H${num(S / 2)}`;
+}
+/** The radius of the outer edge of an oval's last lane. */
+export const outerRadius = (o) => laneEdge(o, o.lanes);
+/** The straight that runs on beyond the oval's finish straight (Manual 2.2.2.1): at least six lanes, a starting area of 3 m before its longest race and a run-out of 17 m. */
+export function straightOf(o, fig, lanes, longest) {
+    return { lanes, lane: fig.straightLane, x0: o.straight / 2 - longest - fig.startArea, x1: o.straight / 2 + fig.runOut, longest, y0: o.radius, finish: o.straight / 2 };
+}
+/**
+ * The straight of a covered track (Rules 41 to 43; the Marking Plan for the Standard Short Track): lanes 1.22 m wide inside the oval, parallel to its straights, with a starting area of 3 m before a
+ * 60 m start line and a run-out beyond the finish line. Its place in the infield is ours: the Rules and the plan give its lanes and its length, not where it lies.
+ */
+export function indoorStraightOf(o, fig, lanes, length) {
+    const total = fig.startArea + length + fig.runOut;
+    const x0 = -total / 2;
+    const width = lanes * fig.straightLane;
+    return { lanes, lane: fig.straightLane, x0, x1: x0 + total, longest: length, y0: -width / 2, finish: x0 + fig.startArea + length };
+}
+/** The infield straight of a covered track: its surface, its lane lines, its start area's and run-out's ends and its finish line, and the lane numbers before the finish. */
+export function indoorStraightParts(st, numbers, w) {
+    const parts = emptyParts();
+    const edge = st.y0 + st.lanes * st.lane;
+    parts.areas.push({ id: "infield-straight", feature: "track", cls: "ky-ath-track", d: `M${num(st.x0)} ${num(st.y0)}H${num(st.x1)}V${num(edge)}H${num(st.x0)}Z` });
+    for (let k = 0; k <= st.lanes; k += 1) {
+        const y = k === 0 ? st.y0 : st.y0 + k * st.lane - w / 2;
+        parts.shapes.push(line_("straight-line", st.x0, y, st.x1, y, w));
+    }
+    parts.shapes.push(line_("straight-end", st.x0, st.y0, st.x0, edge, w), line_("straight-end", st.x1, st.y0, st.x1, edge, w));
+    parts.shapes.push(line_("finish-line", st.finish, st.y0, st.finish, edge, w));
+    for (let n = 1; n <= st.lanes; n += 1) {
+        const y = st.y0 + (n - 0.5) * st.lane;
+        parts.shapes.push(line("finish-tick", "finish-line", st.finish - 1, y - 0.4, st.finish - 1, y + 0.4, { w: 0.03, least: 0.08 }));
+        if (numbers)
+            parts.digits.push({ id: "finish-number", feature: "lane-numbers", text: String(n), x: st.finish - 2.6, y, h: Math.min(0.6, st.lane * 0.55) });
+    }
+    return parts;
+}
+const line_ = (id, x0, y0, x1, y1, w) => line(id, "lane-lines", x0, y0, x1, y1, { w });
+/** The surface of the oval and of the straight, the kerb, the lane lines, the finish line and the numbers before it. */
+export function ovalParts(o, fig, straight, numbers, hole) {
+    const parts = emptyParts();
+    const S = o.straight;
+    const R = o.radius;
+    const Rout = outerRadius(o);
+    const w = o.line;
+    // The surface: the ring between the kerb and the outer edge, and the straight's.
+    // The surface is one shape: the oval's outer edge less the turf's (or, with none, the kerb's) outline, so that the synthetic surface of the segments joins the oval's with no seam.
+    parts.areas.push({ id: "track", feature: "track", cls: "ky-ath-track", d: stadiumD(S, Rout) + (hole ?? stadiumD(S, R)), evenodd: true });
+    if (straight !== undefined) {
+        const edge = R + straight.lanes * straight.lane;
+        parts.areas.push({ id: "straight", feature: "track", cls: "ky-ath-track", d: `M${num(straight.x0)} ${num(R)}H${num(straight.x1)}V${num(edge)}H${num(straight.x0)}Z` });
+    }
+    // The lane lines: the line on the right of each lane, whose outer edge is at the lane's edge (Rule 14.4), so that a line's middle is half its width inside.
+    for (let k = 1; k <= o.lanes; k += 1)
+        parts.shapes.push(path(`lane-line-${k}`, "lane-lines", laneLineD(o, laneEdge(o, k) - w / 2, straight), { w }));
+    // The kerb, 50 mm wide at the least (Rule 14.1); the rules allow it as wide as 250 mm, and it is drawn a little wider than the lines when the drawing is not at true widths.
+    parts.shapes.push(path("kerb", "kerb", stadiumD(S, R - fig.kerb / 2), { w: fig.kerb, least: fig.kerb * 3 }));
+    if (straight !== undefined) {
+        const sl = straight.lane;
+        for (let k = 0; k <= straight.lanes; k += 1) {
+            // The inside line of lane 1 is the straight's inside edge; each other line is the outer edge of the lane before it.
+            const y = k === 0 ? R : R + k * sl - w / 2;
+            if (k <= o.lanes && sl === o.lane) {
+                // Between the bends these are the oval's own lines; the straight's run on beyond them.
+                parts.shapes.push(line(`straight-line-${k}`, "lane-lines", straight.x0, y, -S / 2, y, { w }), line(`straight-line-${k}`, "lane-lines", S / 2, y, straight.x1, y, { w }));
+            }
+            else
+                parts.shapes.push(line(`straight-line-${k}`, "lane-lines", straight.x0, y, straight.x1, y, { w }));
+        }
+        // The ends of the straight, across it.
+        parts.shapes.push(line("straight-end", "lane-lines", straight.x0, R, straight.x0, R + straight.lanes * sl, { w }), line("straight-end", "lane-lines", straight.x1, R, straight.x1, R + straight.lanes * sl, { w }));
+    }
+    // The finish line: all lanes, at right angles to the lane lines, on the axis through the centre of the second semicircle (Manual 2.2.1.1).
+    const lanesAt = straight === undefined ? o.lanes : straight.lanes;
+    const sl = straight === undefined ? o.lane : straight.lane;
+    parts.shapes.push(line("finish-line", "finish-line", S / 2, R, S / 2, R + lanesAt * sl, { w }));
+    // A white line 0.03 m wide and 0.80 m long may be marked in each lane 1 m before the finish line (Manual 2.2.1.6, "Finish Line").
+    for (let n = 1; n <= lanesAt; n += 1) {
+        const y = R + (n - 0.5) * sl;
+        parts.shapes.push(line("finish-tick", "finish-line", S / 2 - 1, y - 0.4, S / 2 - 1, y + 0.4, { w: 0.03, least: 0.08 }));
+        if (numbers)
+            parts.digits.push({ id: "finish-number", feature: "lane-numbers", text: String(n), x: S / 2 - 2.6, y, h: Math.min(0.6, sl * 0.55) });
+    }
+    return parts;
+}

package/dist/athletics/plan.d.ts

@@ -0,0 +1,97 @@
+import type { Area, Shape } from "../fields.types.ts";
+import { WA_SHORT_TRACK, WA_STANDARD_TRACK, type AthleticsFigures, type AthleticsLeague } from "../leagues/athletics.ts";
+import { type SoccerSpec } from "../surfaces/soccer-spec.ts";
+import type { SurfaceOptions } from "../types.ts";
+import type { Facility } from "./facilities.ts";
+import { type Digits, type StraightPlan } from "./oval.ts";
+import { type RaceMarks } from "./races.ts";
+import { type Oval } from "./track.ts";
+import type { AthleticsFieldEvent, AthleticsInfield, AthleticsRace, AthleticsStyle, AthleticsTrackLook, RaceInfo, WaterJump } from "./types.ts";
+/** A box in metres. */
+export interface MBox {
+    x0: number;
+    y0: number;
+    x1: number;
+    y1: number;
+}
+/** A named part of the plan to crop to, in metres: one box, or one at each end (`left` and `right` as the stadium is drawn wide). */
+export type MRange = MBox | {
+    left: MBox;
+    right: MBox;
+};
+/** A part of the plan to label (`landmarks`): where it is, in metres, and the side of the drawing its label stands on. */
+export interface MMark {
+    id: string;
+    x: number;
+    y: number;
+    side: "top" | "bottom";
+}
+/** What an athletics drawing is. */
+export interface AthleticsPlan {
+    sport: "athletics";
+    league: string;
+    /** True for the covered 200 m track. */
+    indoor: boolean;
+    figures: AthleticsFigures;
+    oval: Oval;
+    lanes: number;
+    straight: StraightPlan | undefined;
+    track: AthleticsTrackLook;
+    infield: AthleticsInfield;
+    /** The playing surface: the outer edge of the oval. The data frame's own box. */
+    box: MBox;
+    /** Everything drawn: the box and what lies beyond it (the jump strip, the runways' ends, the straight). */
+    extent: MBox;
+    areas: Area[];
+    shapes: Shape[];
+    digits: Digits[];
+    /** The turf: its outline and the lighter bands, for the mown look. */
+    turf: {
+        d: string;
+        stripes: string;
+    } | undefined;
+    /** The soccer pitch laid inside the track, and where its corner is. */
+    pitch: {
+        spec: SoccerSpec;
+        x: number;
+        y: number;
+    } | undefined;
+    facilities: Facility[];
+    races: RaceMarks[];
+    /** The steeplechase's lap, when it is drawn. */
+    waterJump: WaterJump | undefined;
+    events: AthleticsFieldEvent[];
+    /** The width the ordinary line is painted at by the rules, and the width it is drawn at unless `exactLines` says otherwise. */
+    lineWidth: number;
+    drawnLine: number;
+    ranges: Readonly<Record<string, MRange>>;
+    marks: MMark[];
+    /** The race a close-up of a start (`range: "start"`) shows. */
+    start: AthleticsRace;
+    /** The close-up of the start of that race, when the options ask for one (`range: "start"`): where it is turned about, and the part shown, in the frame in which the athletes run to the right. */
+    startView: {
+        pivot: {
+            x: number;
+            y: number;
+            heading: number;
+        };
+        window: MBox;
+    } | undefined;
+    /** True when the lane numbers are painted. */
+    numbers: boolean;
+    /** The field event drawn alone at a large scale, when the options ask for one: its facility is the whole plan. */
+    layout?: AthleticsFieldEvent;
+}
+/** The league a set of options asks for: the outdoor standard track, or the covered one. */
+export declare function athleticsLeague(o: Pick<SurfaceOptions, "sport" | "league">): AthleticsLeague;
+/** The field events the options ask for: all of them, none, or a list. @throws Error for a name that is not a field event. */
+export declare function eventsOf(style: AthleticsStyle | undefined): AthleticsFieldEvent[];
+/** The races the options ask to be marked. @throws Error for a name that is not a race. */
+export declare function racesOf(style: AthleticsStyle | undefined, indoor?: boolean): RaceInfo[];
+/** The races the covered track marks: the 60 m and its hurdles on the infield straight, and the races of 200 m to 5000 m on the oval. */
+export declare const INDOOR_RACES: readonly AthleticsRace[];
+/** The number of lanes of the oval the options ask for. */
+export declare function athleticsLanes(o: Pick<SurfaceOptions, "sport" | "league" | "athletics">): number;
+/** The standard track and everything the options ask to be marked on it, as a plan. */
+export declare function athleticsPlan(o: Pick<SurfaceOptions, "sport" | "league" | "athletics" | "units" | "pitch" | "detail"> & Partial<Pick<SurfaceOptions, "range" | "ground">>): AthleticsPlan;
+export { WA_SHORT_TRACK, WA_STANDARD_TRACK };