@johnmorrisdotca/kyogijo-stadiums 0.4.0 → 0.5.0

package/dist/athletics/facilities.d.ts

@@ -0,0 +1,80 @@
+import type { Area, Shape } from "../fields.types.ts";
+import type { Parts } from "./oval.ts";
+import type { AthleticsFieldEvent } from "./types.ts";
+/** A point in the plan. */
+type Pt = readonly [number, number];
+/** What a facility is, as data: where it stands, which way it throws or jumps, and the figures that say how big it is. */
+export interface Facility {
+    id: string;
+    event: AthleticsFieldEvent;
+    /** The throw's circle centre, the javelin arc's centre point, the high jump's bar centre, the pole vault's box, the jump's take-off board. */
+    x: number;
+    y: number;
+    /** The direction of the throw or the jump, in radians clockwise from the right as the eye sees it. */
+    heading: number;
+    /** A box round all of it, for the ranges. */
+    box: {
+        x0: number;
+        y0: number;
+        x1: number;
+        y1: number;
+    };
+    /** The length of the sector, or the runway, or the run-up. */
+    reach?: number;
+}
+/** The angle of a throw's sector: 34.92 degrees (Rule 32, landing sector; Manual 2.4.1.4). Its lines are 12 m apart (the chord) 20 m from the circle's centre, 0.60 m more for each metre further: 2 asin(0.3). */
+export declare const SECTOR_ANGLE: number;
+/** The javelin sector's half angle: the arc's radius is 8 m and the runway 4 m wide, so the lines through the arc's ends make 28.96 degrees (Rule 32, landing sector; Figure 2.4.3.2). */
+export declare const JAVELIN_HALF: number;
+/** A rectangle in the plan, `w` along `heading` and `h` across it, centred at `c`, as an area. */
+export declare function rectArea(id: string, cls: Area["cls"], feature: string, c: Pt, heading: number, w: number, h: number): Area;
+/** The outline of the same rectangle as a line. */
+export declare function rectLine(id: string, feature: string, c: Pt, heading: number, w: number, h: number, wLine: number): Shape;
+/** The sector of a throw: its two lines from the circle's rim to the arc, and the arc, 50 mm wide, the inner edges through the circle's centre (Rule 32, landing sector). */
+export declare function sectorShapes(id: string, feature: string, c: Pt, heading: number, rim: number, reach: number, half?: number): Shape[];
+/** A throwing circle (Rule 32, throwing circle, and 32.8; Manual 2.4.1.2): the concrete inside the rim, the rim, the 0.75 m lines at right angles to the sector's axis, the centre. `d` is the inside diameter. */
+export declare function circleParts(id: string, event: AthleticsFieldEvent, c: Pt, heading: number, d: number, rim?: number): Parts;
+/** The shot put's stop board (Rule 33.2; Manual 2.4.4.3): an arc on the circle's inside edge, 1.21 m long (the chord), 0.112 m wide, centred on the sector's axis. */
+export declare function stopBoard(id: string, c: Pt, heading: number, d: number): Area;
+/**
+ * A discus or hammer cage in plan (Rules 35 and 37; Manual 2.4.1.3, Figure 2.4.1.2): U-shaped, its mouth 6 m wide and 7 m in front of the circle's centre, the netting no nearer than 3 m behind it. The
+ * mouth and the line the sides take to it are the rules'; the rear is drawn as an arc about the centre, which is ours.
+ */
+export declare function cageShapes(id: string, c: Pt, heading: number): Shape[];
+/** The javelin's runway and arc (Rule 32, javelin throw runway; Manual 2.4.3.2 and 2.4.3.3), about the centre point of the arc and the throwing direction `heading` (0 throws right). */
+export declare function javelinParts(id: string, c: Pt, heading: number, runway?: number): {
+    parts: Parts;
+    facility: Facility;
+};
+/** The box round some points. */
+export declare function bounds(points: readonly Pt[]): {
+    x0: number;
+    y0: number;
+    x1: number;
+    y1: number;
+};
+/**
+ * A high jump facility (Rule 27; Manual 2.3.3): the uprights 4.02 m apart (Rule 27.6: 4.00 to 4.04 m), the crossbar, the landing mat of 6 m by 4 m at the least (Rule 27, landing area; Manual 2.3.3.4) with the bar's
+ * plane 0.5 m inside its front edge, the 50 mm line 3 m outside each upright (Rule 27.2, note) and the run-up: a 16 m wide area, 15 m long (Rule 27.3: 25 m for the major competitions), drawn
+ * as a dashed outline cut by the arc of the 15 m radius. `heading` is the way the athlete jumps; the facility is about the bar's middle.
+ */
+export declare function highJumpParts(id: string, c: Pt, heading: number, runup?: number): {
+    parts: Parts;
+    facility: Facility;
+};
+/**
+ * A pole vault's box and 0-line at the end of a runway (Rule 28; Manual 2.3.4.2): the box 1.00 m long, 0.60 m wide at the front and 0.15 m at the stop board, set so that the top inside
+ * edge of the stop board is on the 0-line, which is 10 mm wide and runs on past the uprights (5.20 m apart at the least). `c` is the middle of the stop board and `heading` the way the athlete
+ * runs; the landing mat of 6.00 m by 6.00 m at the least with front pieces 2 m long (Rule 28; Manual 2.3.4.4) lies beyond, its front 0.10 to 0.15 m from the box.
+ */
+export declare function poleVaultEnd(id: string, c: Pt, heading: number): {
+    parts: Parts;
+    facility: Facility;
+};
+/** The runway of a jump: two lines 1.22 m apart (Rule 29; Manual 2.3.1.2) from `from` to `to` along `heading`, as lines. */
+export declare function runwayLines(id: string, event: AthleticsFieldEvent, from: Pt, to: Pt, width?: number): Shape[];
+/** A landing pit (Rule 30; Manual 2.3.1.4): the sand with its white border, `length` long along the jump and `width` across it, centred at `c`. */
+export declare function pitParts(id: string, event: AthleticsFieldEvent, c: Pt, heading: number, length: number, width: number): Parts;
+/** A take-off board (Rule 29, take-off board; Manual 2.3.1.3): 1.22 m by 0.20 m, white, whose edge nearer the pit is the take-off line, `d` metres from the pit's near end. `pitEdge` is that end's middle. */
+export declare function takeOffBoard(id: string, event: AthleticsFieldEvent, pitEdge: Pt, heading: number, d: number): Area;
+export {};

package/dist/athletics/facilities.js

@@ -0,0 +1,176 @@
+// The field events' facilities, each at the size the World Athletics Track and Field Facilities Manual (2019 edition, 2.3 and 2.4, 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)
+// and Technical Rules 25 to 38 of Book C2.1 give, in metres, and each made about its own origin and the direction of its throw or its run: a circle, a runway, a pit, a mat, a sector. The standard
+// stadium's places for them (Figure 2.5a and the Marking Plan) are in infield.ts. Nothing here draws SVG.
+import { arc, line, path, poly, ring } from "../fields.kit.js";
+import { num } from "../format.js";
+import { arcD } from "./track.js";
+import { emptyParts } from "./oval.js";
+/** The angle of a throw's sector: 34.92 degrees (Rule 32, landing sector; Manual 2.4.1.4). Its lines are 12 m apart (the chord) 20 m from the circle's centre, 0.60 m more for each metre further: 2 asin(0.3). */
+export const SECTOR_ANGLE = 2 * Math.asin(0.3);
+/** The javelin sector's half angle: the arc's radius is 8 m and the runway 4 m wide, so the lines through the arc's ends make 28.96 degrees (Rule 32, landing sector; Figure 2.4.3.2). */
+export const JAVELIN_HALF = Math.asin(2 / 8);
+const f = (n) => num(n);
+const at = (c, theta, k, side = 0) => [c[0] + k * Math.cos(theta) - side * Math.sin(theta), c[1] + k * Math.sin(theta) + side * Math.cos(theta)];
+/** The path of a closed polygon filled as an area. */
+const polyArea = (id, cls, feature, points) => ({ id, feature, cls, d: `M${points.map(([x, y]) => `${f(x)} ${f(y)}`).join("L")}Z` });
+/** A rectangle in the plan, `w` along `heading` and `h` across it, centred at `c`, as an area. */
+export function rectArea(id, cls, feature, c, heading, w, h) {
+    return polyArea(id, cls, feature, [at(c, heading, -w / 2, -h / 2), at(c, heading, w / 2, -h / 2), at(c, heading, w / 2, h / 2), at(c, heading, -w / 2, h / 2)]);
+}
+/** The outline of the same rectangle as a line. */
+export function rectLine(id, feature, c, heading, w, h, wLine) {
+    return poly(id, feature, [at(c, heading, -w / 2, -h / 2), at(c, heading, w / 2, -h / 2), at(c, heading, w / 2, h / 2), at(c, heading, -w / 2, h / 2)], { closed: true, w: wLine });
+}
+/** The sector of a throw: its two lines from the circle's rim to the arc, and the arc, 50 mm wide, the inner edges through the circle's centre (Rule 32, landing sector). */
+export function sectorShapes(id, feature, c, heading, rim, reach, half = SECTOR_ANGLE / 2) {
+    const a = heading - half;
+    const b = heading + half;
+    const p0 = at(c, a, rim);
+    const p1 = at(c, a, reach);
+    const q0 = at(c, b, rim);
+    const q1 = at(c, b, reach);
+    const thin = { cls: "ky-ath-s", least: 0.07 };
+    return [poly(`${id}-sector-line`, feature, [p0, p1], thin), poly(`${id}-sector-line`, feature, [q0, q1], thin), path(`${id}-sector-arc`, feature, arcD(c[0], c[1], reach, a, b), thin)];
+}
+/** A throwing circle (Rule 32, throwing circle, and 32.8; Manual 2.4.1.2): the concrete inside the rim, the rim, the 0.75 m lines at right angles to the sector's axis, the centre. `d` is the inside diameter. */
+export function circleParts(id, event, c, heading, d, rim = 0.06) {
+    const parts = emptyParts();
+    const r = d / 2;
+    parts.areas.push({ id: `${id}-circle`, feature: event, cls: "ky-ath-concrete", d: `M${f(c[0] - r)} ${f(c[1])}A${f(r)} ${f(r)} 0 1 0 ${f(c[0] + r)} ${f(c[1])}A${f(r)} ${f(r)} 0 1 0 ${f(c[0] - r)} ${f(c[1])}Z` });
+    parts.shapes.push(ring(`${id}-rim`, event, c[0], c[1], r + rim / 2, r + rim / 2, { w: rim }));
+    for (const side of [-1, 1]) {
+        const p = at(c, heading, 0, side * (r + rim));
+        const q = at(c, heading, 0, side * (r + rim + 0.75));
+        parts.shapes.push(line(`${id}-circle-line`, event, p[0], p[1], q[0], q[1], { w: 0.05 }));
+    }
+    return parts;
+}
+/** The shot put's stop board (Rule 33.2; Manual 2.4.4.3): an arc on the circle's inside edge, 1.21 m long (the chord), 0.112 m wide, centred on the sector's axis. */
+export function stopBoard(id, c, heading, d) {
+    const r = d / 2;
+    const half = Math.asin(1.21 / 2 / r);
+    const inner = r;
+    const outer = r + 0.112;
+    const p = (k, th) => at(c, th, k);
+    const a = heading - half;
+    const b = heading + half;
+    const [i0, i1, o0, o1] = [p(inner, a), p(inner, b), p(outer, a), p(outer, b)];
+    return { id: `${id}-stop-board`, feature: "shot-put", cls: "ky-ath-board", d: `M${f(i0[0])} ${f(i0[1])}A${f(inner)} ${f(inner)} 0 0 1 ${f(i1[0])} ${f(i1[1])}L${f(o1[0])} ${f(o1[1])}A${f(outer)} ${f(outer)} 0 0 0 ${f(o0[0])} ${f(o0[1])}Z` };
+}
+/**
+ * A discus or hammer cage in plan (Rules 35 and 37; Manual 2.4.1.3, Figure 2.4.1.2): U-shaped, its mouth 6 m wide and 7 m in front of the circle's centre, the netting no nearer than 3 m behind it. The
+ * mouth and the line the sides take to it are the rules'; the rear is drawn as an arc about the centre, which is ours.
+ */
+export function cageShapes(id, c, heading) {
+    const mouth = [7, 3];
+    const wide = 4.4;
+    const pts = (u, v) => at(c, heading, u, v);
+    const back = 4.4;
+    const left = [pts(mouth[0], -mouth[1]), pts(0, -wide)];
+    const right = [pts(mouth[0], mouth[1]), pts(0, wide)];
+    const a0 = heading - Math.PI / 2;
+    const a1 = heading + Math.PI / 2;
+    const rear = arcD(c[0], c[1], back, a0 + Math.PI, a1 + Math.PI);
+    return [poly(`${id}-cage`, "cage", [left[0], left[1]], { w: 0.12, cls: "ky-ath-k" }), poly(`${id}-cage`, "cage", [right[0], right[1]], { w: 0.12, cls: "ky-ath-k" }), path(`${id}-cage`, "cage", rear, { w: 0.12, cls: "ky-ath-k" })];
+}
+/** The javelin's runway and arc (Rule 32, javelin throw runway; Manual 2.4.3.2 and 2.4.3.3), about the centre point of the arc and the throwing direction `heading` (0 throws right). */
+export function javelinParts(id, c, heading, runway = 36.5) {
+    const parts = emptyParts();
+    const xe = 8 * Math.cos(JAVELIN_HALF);
+    const w = 2;
+    // The runway: two lines 4 m apart from the ends of the arc back `runway` metres, the arc, and the 0.75 m lines at right angles to the runway at the arc's ends.
+    for (const side of [-1, 1]) {
+        const p = at(c, heading, xe, side * w);
+        const q = at(c, heading, xe - runway, side * w);
+        parts.shapes.push(line(`${id}-runway-line`, "javelin-throw", p[0], p[1], q[0], q[1], { w: 0.05 }));
+        const m0 = at(c, heading, xe, side * w);
+        const m1 = at(c, heading, xe, side * (w + 0.75));
+        parts.shapes.push(line(`${id}-arc-mark`, "javelin-throw", m0[0], m0[1], m1[0], m1[1], { w: 0.07 }));
+        // Two white squares of 0.05 m beside the runway, 4 m back from the ends of the arc.
+        const sq = at(c, heading, xe - 4, side * (w + 0.12));
+        parts.shapes.push(line(`${id}-square`, "javelin-throw", sq[0], sq[1], sq[0], sq[1], { w: 0.05 }));
+    }
+    parts.shapes.push(arc(`${id}-arc`, "javelin-throw", c[0], c[1], 8, (heading - JAVELIN_HALF) * (180 / Math.PI), (heading + JAVELIN_HALF) * (180 / Math.PI), { w: 0.07 }));
+    parts.shapes.push(...sectorShapes(id, "javelin-throw", c, heading, 8, 100, JAVELIN_HALF));
+    const end = at(c, heading, xe - runway, 0);
+    const box = bounds([end, at(c, heading, 100, -25), at(c, heading, 100, 25), at(c, heading, 0, 0), at(c, heading, 100, 0)]);
+    return { parts, facility: { id, event: "javelin-throw", x: c[0], y: c[1], heading, box, reach: 100 } };
+}
+/** The box round some points. */
+export function bounds(points) {
+    const xs = points.map((p) => p[0]);
+    const ys = points.map((p) => p[1]);
+    return { x0: Math.min(...xs), y0: Math.min(...ys), x1: Math.max(...xs), y1: Math.max(...ys) };
+}
+/**
+ * A high jump facility (Rule 27; Manual 2.3.3): the uprights 4.02 m apart (Rule 27.6: 4.00 to 4.04 m), the crossbar, the landing mat of 6 m by 4 m at the least (Rule 27, landing area; Manual 2.3.3.4) with the bar's
+ * plane 0.5 m inside its front edge, the 50 mm line 3 m outside each upright (Rule 27.2, note) and the run-up: a 16 m wide area, 15 m long (Rule 27.3: 25 m for the major competitions), drawn
+ * as a dashed outline cut by the arc of the 15 m radius. `heading` is the way the athlete jumps; the facility is about the bar's middle.
+ */
+export function highJumpParts(id, c, heading, runup = 15) {
+    const parts = emptyParts();
+    parts.areas.push(rectArea(`${id}-mat`, "ky-ath-mat", "high-jump", at(c, heading, 1.5), heading, 4, 6));
+    parts.shapes.push(rectLine(`${id}-mat-edge`, "high-jump", at(c, heading, 1.5), heading, 4, 6, 0.05));
+    const a = at(c, heading, 0, -5.01);
+    const b = at(c, heading, 0, 5.01);
+    parts.shapes.push(line(`${id}-take-off-line`, "high-jump", a[0], a[1], b[0], b[1], { w: 0.05 }));
+    const bar0 = at(c, heading, 0, -2.01);
+    const bar1 = at(c, heading, 0, 2.01);
+    parts.shapes.push(line(`${id}-crossbar`, "high-jump", bar0[0], bar0[1], bar1[0], bar1[1], { w: 0.04, cls: "ky-ath-k" }));
+    for (const side of [-1, 1]) {
+        const p = at(c, heading, 0, side * 2.01);
+        parts.shapes.push({ kind: "dot", id: `${id}-upright`, feature: "high-jump", cx: p[0], cy: p[1], r: 0.1, paint: "post" });
+    }
+    // The run-up: 8 m either side of the middle of the bar, to 15 m back, rounded by the arc of 15 m about the bar's middle.
+    const half = 8;
+    const x = Math.sqrt(runup * runup - half * half);
+    const [p0, p1] = [at(c, heading, 0, -half), at(c, heading, -x, -half)];
+    const [q0, q1] = [at(c, heading, -x, half), at(c, heading, 0, half)];
+    const sweep = 0;
+    const d = `M${f(p0[0])} ${f(p0[1])}L${f(p1[0])} ${f(p1[1])}A${f(runup)} ${f(runup)} 0 0 ${sweep} ${f(q0[0])} ${f(q0[1])}L${f(q1[0])} ${f(q1[1])}`;
+    parts.shapes.push(path(`${id}-run-up`, "high-jump", d, { w: 0.04, dash: [0.6, 0.6], least: 0.04 }));
+    const box = bounds([at(c, heading, 4.5, -3.2), at(c, heading, 4.5, 3.2), at(c, heading, -runup, -half), at(c, heading, -runup, half)]);
+    return { parts, facility: { id, event: "high-jump", x: c[0], y: c[1], heading, box, reach: runup } };
+}
+/**
+ * A pole vault's box and 0-line at the end of a runway (Rule 28; Manual 2.3.4.2): the box 1.00 m long, 0.60 m wide at the front and 0.15 m at the stop board, set so that the top inside
+ * edge of the stop board is on the 0-line, which is 10 mm wide and runs on past the uprights (5.20 m apart at the least). `c` is the middle of the stop board and `heading` the way the athlete
+ * runs; the landing mat of 6.00 m by 6.00 m at the least with front pieces 2 m long (Rule 28; Manual 2.3.4.4) lies beyond, its front 0.10 to 0.15 m from the box.
+ */
+export function poleVaultEnd(id, c, heading) {
+    const parts = emptyParts();
+    parts.areas.push(polyArea(`${id}-box`, "ky-ath-pad", "pole-vault", [at(c, heading, -1, -0.3), at(c, heading, 0, -0.075), at(c, heading, 0, 0.075), at(c, heading, -1, 0.3)]));
+    parts.areas.push(rectArea(`${id}-mat`, "ky-ath-mat", "pole-vault", at(c, heading, 0.15 + 4), heading, 8, 6));
+    parts.shapes.push(rectLine(`${id}-mat-edge`, "pole-vault", at(c, heading, 0.15 + 4), heading, 8, 6, 0.05));
+    const a = at(c, heading, 0, -2.8);
+    const b = at(c, heading, 0, 2.8);
+    parts.shapes.push(line(`${id}-zero-line`, "pole-vault", a[0], a[1], b[0], b[1], { w: 0.03, least: 0.08, cls: "ky-ath-r" }));
+    for (const side of [-1, 1]) {
+        const p = at(c, heading, 0.1, side * 2.6);
+        parts.shapes.push({ kind: "dot", id: `${id}-upright`, feature: "pole-vault", cx: p[0], cy: p[1], r: 0.1, paint: "post" });
+    }
+    const box = bounds([at(c, heading, -45, -0.7), at(c, heading, -45, 0.7), at(c, heading, 8.2, -3), at(c, heading, 8.2, 3)]);
+    return { parts, facility: { id, event: "pole-vault", x: c[0], y: c[1], heading, box, reach: 45 } };
+}
+/** The runway of a jump: two lines 1.22 m apart (Rule 29; Manual 2.3.1.2) from `from` to `to` along `heading`, as lines. */
+export function runwayLines(id, event, from, to, width = 1.22) {
+    const heading = Math.atan2(to[1] - from[1], to[0] - from[0]);
+    return [-1, 1].map((side) => {
+        const a = at(from, heading, 0, (side * width) / 2);
+        const b = at(to, heading, 0, (side * width) / 2);
+        return line(`${id}-runway-line`, event, a[0], a[1], b[0], b[1], { w: 0.05 });
+    });
+}
+/** A landing pit (Rule 30; Manual 2.3.1.4): the sand with its white border, `length` long along the jump and `width` across it, centred at `c`. */
+export function pitParts(id, event, c, heading, length, width) {
+    const parts = emptyParts();
+    parts.areas.push(rectArea(`${id}-pit`, "ky-ath-sand", event, c, heading, length, width));
+    parts.shapes.push(rectLine(`${id}-pit-border`, event, c, heading, length, width, 0.05));
+    return parts;
+}
+/** A take-off board (Rule 29, take-off board; Manual 2.3.1.3): 1.22 m by 0.20 m, white, whose edge nearer the pit is the take-off line, `d` metres from the pit's near end. `pitEdge` is that end's middle. */
+export function takeOffBoard(id, event, pitEdge, heading, d) {
+    // The board lies behind the take-off line, away from the pit: along the run, `d` from the pit's near end is the line and the board is the 0.20 m before it.
+    const line0 = at(pitEdge, heading, -d);
+    return rectArea(id, "ky-ath-board", event, at(line0, heading, -0.1), heading, 0.2, 1.22);
+}

package/dist/athletics/infield.d.ts

@@ -0,0 +1,79 @@
+import type { Shape } from "../fields.types.ts";
+import { type Facility } from "./facilities.ts";
+import { type Parts } from "./oval.ts";
+import type { Oval } from "./track.ts";
+import type { AthleticsFieldEvent } from "./types.ts";
+/** 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 declare const SECTOR_REACH: {
+    readonly "shot-put": 25;
+    readonly "discus-throw": 80;
+    readonly "hammer-throw": 90;
+    readonly "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 declare 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). */
+    readonly turf: 12;
+    /** The javelin arc's apex is this far beyond the segment's centre; the centre point is 8 m behind it. */
+    readonly javelinApex: number;
+    /** The shot put circles: from the segment's centre outward along the axis, and the distance up or down. */
+    readonly shotWest: {
+        readonly out: 13.5;
+        readonly across: 18.15;
+    };
+    readonly shotEast: {
+        readonly out: 14.2;
+        readonly across: 18.5;
+    };
+    /** The combined discus and hammer circle of the second segment. */
+    readonly discus: {
+        readonly out: 20.4;
+        readonly across: -24.1;
+        readonly heading: number;
+    };
+    /** The two pole vault runways of the first segment: their middle lines, the boxes' places and the length, from the axis. */
+    readonly vaultA: {
+        readonly out: 23.26;
+        readonly box: 16.5;
+    };
+    readonly vaultB: {
+        readonly out: 15.82;
+        readonly box: 20.7;
+    };
+    readonly 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). */
+    readonly highJump: {
+        readonly out: 15;
+        readonly 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. */
+    readonly strip: {
+        readonly x0: -45.6;
+        readonly x1: 46.2;
+        readonly y0: -56.6;
+    };
+    readonly rows: readonly [{
+        readonly y: -54.2;
+        readonly west: readonly [-39.7, -31.7];
+        readonly east: readonly [23, 31.1];
+    }, {
+        readonly y: -50.4;
+        readonly west: readonly [-30.9, -22.9];
+        readonly east: readonly [31.9, 40];
+    }];
+};
+/** What the infield is made of: shapes and areas, the facilities as data, and the box of what lies beyond the oval. */
+export interface Infield {
+    parts: Parts;
+    facilities: Facility[];
+}
+/** The standard stadium's field events, those asked for. */
+export declare function infieldParts(o: Oval, events: ReadonlySet<AthleticsFieldEvent>): Infield;
+/** The strip beyond the back straight where the long and the triple jumps are, as a box, when they are drawn. */
+export declare const jumpStrip: () => {
+    x0: number;
+    y0: number;
+    x1: number;
+    y1: number;
+};
+export type { Shape };

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