@johnmorrisdotca/kyogijo-stadiums 0.4.0 → 0.6.0

package/dist/athletics/races.js

@@ -0,0 +1,355 @@
+// The marks of the races: where each starts and how its start line is made (a straight line across the lane, a staggered one, a curved one), the breakline of the 800 m, the group starts of
+// the long races, the takeover zones of the relays and the hurdles' marks. The distances are the Track and Field Facilities Manual's (2019 edition, 2.2.1.6, 2.2.3 and Tables 2.2.1.6a, 2.2.1.6b
+// and 2.2.3.1) and Book C2.1's Technical Rules (Rules 14.3, 16.1, 17.5, 22 and 24 in the edition in force from 1 July 2026). Everything is metres, in the frame of track.ts.
+import { line, poly } from "../fields.kit.js";
+import { WA_SHORT_STAGGER_TABLE } from "../leagues/athletics.js";
+import { emptyParts, outerRadius } from "./oval.js";
+import { distanceOn, involutePoint, laneEdge, laneRadius, lap, pose, stagger, breaklineStagger } from "./track.js";
+/** The unit normal of a heading, pointing out from the middle of the track: to the right of the athlete. */
+export const outward = (heading) => [-Math.sin(heading), Math.cos(heading)];
+/** The unit vector of a heading. */
+export const ahead = (heading) => [Math.cos(heading), Math.sin(heading)];
+/** The ends of the line across lane `n` at distance `s` of its running line, from radius `ra` to radius `rb` (measured as the track's radii are: outward from the middle of a bend). */
+export function across(o, n, s, ra, rb) {
+    const r = laneRadius(o, n);
+    const p = pose(o, r, s);
+    const [nx, ny] = outward(p.heading);
+    return [
+        [p.x + (ra - r) * nx, p.y + (ra - r) * ny],
+        [p.x + (rb - r) * nx, p.y + (rb - r) * ny],
+    ];
+}
+/** Where a point `back` metres behind `s` on lane `n` is, and the unit vector out from the middle there. */
+export function atLane(o, n, s, side = 0) {
+    const r = laneRadius(o, n);
+    const p = pose(o, r + side, s);
+    return p;
+}
+/** The inside and the outside radius of the paintable width of lane `n`: between the line on its left and the line on its right (1.17 m of a 1.22 m lane). */
+export function laneSpan(o, n) {
+    return [laneEdge(o, n - 1), laneEdge(o, n) - o.line];
+}
+/** The distance of lane 1's start from the finish line for a race of `distance` metres: the least start that is a whole number of laps before the finish line, round to the distance (Rule 14.3). */
+export function firstStart(o, distance, nominal) {
+    const L = nominal ?? lap(o, 1);
+    const k = Math.ceil(distance / L - 1e-9);
+    return k * L - distance;
+}
+/** The stagger of lane `n` for a race run in lanes round `bends` bends, with the breakline's correction where the race has one (Manual Tables 2.2.1.6a and 2.2.1.6b). */
+export function staggerOf(o, n, bends, breakline, fig) {
+    if (n <= 1)
+        return 0;
+    if (fig.banking !== null) {
+        // The covered track's own table (Marking Plan, 1 January 2026).
+        const row = bends === 1 ? WA_SHORT_STAGGER_TABLE["one-bend"] : bends === 3 ? WA_SHORT_STAGGER_TABLE["three-bends"] : WA_SHORT_STAGGER_TABLE["two-bends"];
+        return row[n - 2] ?? stagger(o, n, bends);
+    }
+    return breakline ? (bends - 1) * stagger(o, n, 1) + breaklineStagger(o, n) : stagger(o, n, bends);
+}
+/** Where a curved start line begins on a circle of radius `a`, from its distance `s` along that circle's running line: the bend it is on or runs into, the angle there, and the wire already unwound. */
+export function curveOrigin(o, a, s) {
+    const S = o.straight;
+    const L = 2 * S + 2 * Math.PI * a;
+    const d = ((s % L) + L) % L;
+    const bend = Math.PI * a;
+    if (d < bend)
+        return { side: "right", f0: d / a, wire: 0 };
+    if (d < bend + S)
+        return { side: "left", f0: 0, wire: bend + S - d };
+    if (d <= 2 * bend + S)
+        return { side: "left", f0: (d - bend - S) / a, wire: 0 };
+    return { side: "right", f0: 0, wire: L - d };
+}
+/** The distance of a point out from the circle of radius `a` of the track, whichever part of the track it is over. */
+function offsetOf(o, a, x, y) {
+    const S = o.straight;
+    if (x >= S / 2)
+        return Math.hypot(x - S / 2, y) - a;
+    if (x <= -S / 2)
+        return Math.hypot(x + S / 2, y) - a;
+    return Math.abs(y) - a;
+}
+/**
+ * A curved start line, or a breakline, as points: the involute of the circle of radius `a` (see `involutePoint`) that starts where `origin` says, from `rIn` out to `rOut` (radii about the bend's
+ * centre; a start line on the straight is the same curve). Where `rIn` is less than `a` a short run in to the kerb along the line across the track joins it.
+ */
+export function curveAcross(o, origin, a, rIn, rOut, steps = 30) {
+    const w0 = origin.wire - a * origin.f0;
+    const at = (f) => involutePoint(o, origin.side, a, w0, f);
+    const out = [];
+    const f0 = origin.f0;
+    if (rIn < a - 1e-9) {
+        const p0 = at(f0);
+        const nx = origin.side === "right" ? Math.sin(f0) : -Math.sin(f0);
+        const ny = origin.side === "right" ? Math.cos(f0) : -Math.cos(f0);
+        out.push([p0[0] + (rIn - a) * nx, p0[1] + (rIn - a) * ny]);
+    }
+    const solve = (d) => {
+        let lo = f0;
+        let hi = f0 + 2.4;
+        for (let i = 0; i < 60; i += 1) {
+            const mid = (lo + hi) / 2;
+            const [x, y] = at(mid);
+            if (offsetOf(o, a, x, y) < d)
+                lo = mid;
+            else
+                hi = mid;
+        }
+        return (lo + hi) / 2;
+    };
+    const d0 = Math.max(rIn - a, 0);
+    const d1 = rOut - a;
+    for (let i = 0; i <= steps; i += 1)
+        out.push(at(solve(d0 + ((d1 - d0) * i) / steps)));
+    return out;
+}
+const W = 0.05;
+/** A line across a lane at distance `s`, from radius `ra` to `rb`. */
+function crossLine(o, id, feature, n, s, ra, rb, w, cls) {
+    const [a, b] = across(o, n, s, ra, rb);
+    return line(id, feature, a[0], a[1], b[0], b[1], { w, ...(cls === undefined ? {} : { cls }) });
+}
+/** A takeover zone's line: `len` metres across the lane from its inside line, with a hook of 0.15 m turned 45 degrees, to point into the zone (`into` = +1: ahead of the line). */
+function zoneLine(o, id, cls, n, s, len, into) {
+    const [ra] = laneSpan(o, n);
+    const r = laneRadius(o, n);
+    const p = pose(o, r, s);
+    const [fx, fy] = ahead(p.heading);
+    const [nx, ny] = outward(p.heading);
+    const base = [p.x + (ra - r) * nx, p.y + (ra - r) * ny];
+    const tip = [base[0] + len * nx, base[1] + len * ny];
+    const k = 0.15 * Math.SQRT1_2;
+    return poly(id, "relay-zones", [base, tip, [tip[0] - k * nx + into * k * fx, tip[1] - k * ny + into * k * fy]], { w: W, cls });
+}
+/** A mark in the middle of a lane, `len` long across it, at distance `s`. */
+function middleLine(o, id, feature, n, s, len, cls) {
+    const r = laneRadius(o, n);
+    const [lo, hi] = laneSpan(o, n);
+    const mid = (lo + hi) / 2;
+    void r;
+    return crossLine(o, id, feature, n, s, mid - len / 2, mid + len / 2, W, cls);
+}
+/** The marks of one race on the oval or the straight. */
+export function markRace(ctx, race) {
+    const { oval: o, fig, lanes } = ctx;
+    const parts = emptyParts();
+    const out = { race, s1: 0, starts: [], parts };
+    const S = o.straight;
+    const R = o.radius;
+    const Rout = outerRadius(o);
+    const kind = race.kind;
+    const digitAt = (n, s) => {
+        if (!ctx.numbers)
+            return;
+        const p = pose(o, laneRadius(o, n), s - ctx.numberHeight * 1.2);
+        const q = pose(o, laneRadius(o, n), s);
+        parts.digits.push({ id: "start-number", feature: "lane-numbers", text: String(n), x: p.x, y: p.y, h: ctx.numberHeight, from: [q.x, q.y, Math.cos(q.heading), Math.sin(q.heading)] });
+    };
+    if (kind === "straight") {
+        const st = ctx.straight;
+        const sl = st?.lane ?? o.lane;
+        const n = st?.lanes ?? lanes;
+        const top = st?.y0 ?? R;
+        const x = (st?.finish ?? S / 2) - race.distance;
+        for (let k = 1; k <= n; k += 1) {
+            const y0 = top + (k - 1) * sl;
+            const y1 = top + k * sl - W;
+            parts.shapes.push(line("start-line", "start-lines", x, y0, x, y1, { w: W }));
+            out.starts.push({ lane: k, s: lap(o, 1) - race.distance, x, y: (y0 + y1) / 2, heading: 0, stagger: 0 });
+            if (ctx.numbers)
+                parts.digits.push({ id: "start-number", feature: "lane-numbers", text: String(k), x: x - ctx.numberHeight * 1.2, y: (y0 + y1) / 2, h: ctx.numberHeight });
+        }
+        if (race.hurdles === true)
+            addStraightHurdles(parts, out, race, st?.finish ?? S / 2, top, sl, n);
+        return out;
+    }
+    // The covered track's running line is 200.000 m by the plan, which counts its banking's transitions; the circle drawn here is a little shorter, so a start is a whole number of nominal laps back.
+    const indoor = fig.banking !== null;
+    const s1 = firstStart(o, race.distance, indoor ? 200 : undefined);
+    out.s1 = s1;
+    if (kind === "stagger") {
+        const bends = indoor ? 2 : (race.bends ?? 2);
+        for (let n = 1; n <= lanes; n += 1) {
+            const st = staggerOf(o, n, bends, race.breakline === true, fig);
+            const s = s1 + st;
+            const p = pose(o, laneRadius(o, n), s);
+            out.starts.push({ lane: n, s, x: p.x, y: p.y, heading: p.heading, stagger: st });
+            const [ra, rb] = laneSpan(o, n);
+            parts.shapes.push(crossLine(o, "start-line", "start-lines", n, s, ra, rb, W));
+            digitAt(n, s);
+        }
+        if (race.breakline === true) {
+            const a = laneRadius(o, 1);
+            // Outdoors the 800 m's breakline is at the end of the first bend, the involute of the second bend's circle; on the covered track it is at the end of the second bend (Rule 44), the first bend's.
+            out.breakline = curveAcross(o, { side: indoor ? "right" : "left", f0: 0, wire: S }, a, laneEdge(o, 1), Rout);
+            parts.shapes.push(poly("breakline", "breakline", out.breakline, { w: W, cls: "ky-ath-g" }));
+        }
+        if (race.legs !== undefined)
+            relayZones(ctx, race, out);
+        if (race.hurdles === true)
+            oval400Hurdles(ctx, race, out);
+        return out;
+    }
+    if (kind === "curved") {
+        const a = laneRadius(o, 1);
+        const origin = curveOrigin(o, a, s1);
+        out.curve = curveAcross(o, origin, a, R, Rout);
+        parts.shapes.push(poly("start-line", "start-lines", out.curve, { w: W }));
+        // The number of each lane, behind the curved line where it crosses the lane's middle.
+        if (ctx.numbers) {
+            for (let n = 1; n <= lanes; n += 1) {
+                const r = laneRadius(o, n);
+                const [lo, hi] = laneSpan(o, n);
+                const mid = (lo + hi) / 2;
+                const [px, py] = curveAcross(o, origin, a, mid, mid, 1)[0];
+                const sMid = distanceOn(o, mid, px, py);
+                const p = pose(o, mid, sMid - ctx.numberHeight * 1.2);
+                void r;
+                const q = pose(o, mid, sMid);
+                parts.digits.push({ id: "start-number", feature: "lane-numbers", text: String(n), x: p.x, y: p.y, h: ctx.numberHeight, from: [q.x, q.y, Math.cos(q.heading), Math.sin(q.heading)] });
+            }
+        }
+        // Where each lane's middle crosses the line: for the athletes' places, and the replay's.
+        for (let n = 1; n <= lanes; n += 1) {
+            const r = laneRadius(o, n);
+            const [px, py] = curveAcross(o, origin, a, r, r, 1)[0];
+            const sRun = distanceOn(o, r, px, py);
+            const p = pose(o, r, sRun);
+            out.starts.push({ lane: n, s: sRun, x: px, y: py, heading: p.heading, stagger: sRun - s1 });
+        }
+        if (race.group === true) {
+            // The outer half starts from lane 5 (lane 4 on a six-lane track), a line of its own whose inside is 0.20 m outside the line between lanes 4 and 5 (Rule 17.5.2, Manual 2.2.1.6).
+            const gl = lanes <= 6 ? 4 : 5;
+            const ag = laneRadius(o, gl);
+            const sg = s1 + breaklineStagger(o, gl);
+            out.group = curveAcross(o, curveOrigin(o, ag, sg), ag, laneEdge(o, gl - 1), Rout);
+            parts.shapes.push(poly("group-start-line", "start-lines", out.group, { w: W }));
+        }
+        return out;
+    }
+    return out;
+}
+/** The hurdles' marks of the sprint hurdles on the finish straight (Manual Table 2.2.3.1; Rule 22.2). */
+function addStraightHurdles(parts, out, race, finish, R, sl, lanes) {
+    const men = race.id === "110m-hurdles" || race.id === "60m-hurdles";
+    const first = men ? 13.72 : 13;
+    const between = men ? 9.14 : 8.5;
+    const cls = men ? "ky-ath-b" : "ky-ath-y";
+    const xs = [];
+    // Ten hurdles in 100 and 110 m, five in the covered track's 60 m (Table 2.2.3.1; the Marking Plan for the Standard Short Track).
+    const count = race.distance <= 60 ? 5 : 10;
+    for (let k = 0; k < count; k += 1)
+        xs.push(finish - race.distance + first + between * k);
+    out.hurdles = [];
+    for (let n = 1; n <= lanes; n += 1) {
+        const y0 = R + (n - 1) * sl;
+        const y1 = R + n * sl - W;
+        for (const x of xs) {
+            // Two marks, 0.05 m by 0.10 m, one each side of the lane, on the line the hurdle's nearer face stands on (Rule 22.3).
+            parts.shapes.push(line("hurdle-mark", "hurdle-marks", x + 0.025, y0 + W, x + 0.025, y0 + W + 0.1, { w: W, cls }), line("hurdle-mark", "hurdle-marks", x + 0.025, y1 - 0.1, x + 0.025, y1, { w: W, cls }));
+        }
+        out.hurdles.push({ lane: n, at: xs });
+    }
+}
+/** The 400 m hurdles' marks on the oval: ten hurdles in each lane, the first 45 m from the start, then every 35 m (Table 2.2.3.1; Rule 22.2). */
+function oval400Hurdles(ctx, race, out) {
+    const o = ctx.oval;
+    out.hurdles = [];
+    for (const st of out.starts) {
+        const at = [];
+        for (let k = 0; k < 10; k += 1)
+            at.push(st.s + 45 + 35 * k);
+        out.hurdles.push({ lane: st.lane, at });
+        const [ra, rb] = laneSpan(o, st.lane);
+        for (const s of at)
+            out.parts.shapes.push(crossLine(o, "hurdle-mark", "hurdle-marks", st.lane, s + 0.025, ra + W, ra + W + 0.1, W, "ky-ath-g"), crossLine(o, "hurdle-mark", "hurdle-marks", st.lane, s + 0.025, rb - 0.1, rb, W, "ky-ath-g"));
+    }
+    void race;
+}
+/** The takeover zones of a relay: the 4 x 100 m's (30 m long, the scratch line 20 m from the zone's start) and the 4 x 400 m's (20 m long, the scratch line in the middle). Rule 24.3. */
+function relayZones(ctx, race, out) {
+    const { oval: o, lanes } = ctx;
+    const sprint = race.id === "4x100m";
+    const long = sprint ? 30 : 20;
+    const before = sprint ? 20 : 10;
+    const cls = sprint ? "ky-ath-y" : "ky-ath-b";
+    const len = sprint ? 1.1 : 0.8;
+    out.zones = [];
+    const shapes = out.parts.shapes;
+    for (const st of out.starts) {
+        const n = st.lane;
+        const legs = race.legs;
+        let scratch = st.s;
+        for (let change = 1; change <= 3; change += 1) {
+            scratch += legs[change - 1];
+            // A 4 x 400 m's second and third takeovers are not in lanes: they stand across the track either side of the finish line (Manual 2.2.1.6, Marking Plan) and are marked below.
+            if (!sprint && change >= 2)
+                continue;
+            const zs = scratch - before;
+            const ze = zs + long;
+            out.zones.push({ lane: n, change, start: zs, scratch, end: ze });
+            shapes.push(zoneLine(o, "zone-start", cls, n, zs, len, 1), zoneLine(o, "zone-end", cls, n, ze, len, -1));
+            shapes.push(middleLine(o, "scratch-line", "relay-zones", n, scratch, 0.4));
+        }
+    }
+    if (!sprint) {
+        // Across the track, 10 m before the finish line in lanes 2 to 8 and 10 m after it in lanes 2 to 5: a mark 0.80 m long in the middle of the lane, parallel to the finish line.
+        const S = o.straight;
+        for (let n = 2; n <= lanes; n += 1) {
+            const [lo, hi] = laneSpan(o, n);
+            const mid = (lo + hi) / 2;
+            const before10 = lap(o, n) - 10;
+            shapes.push(crossLine(o, "zone-start", "relay-zones", n, before10, mid - 0.4, mid + 0.4, W, cls));
+            if (n <= 5)
+                shapes.push(crossLine(o, "zone-end", "relay-zones", n, 10, mid - 0.4, mid + 0.4, W, cls));
+        }
+        void S;
+    }
+}
+/** Every point that makes the start of a race: the ends of each lane's start line, the curved lines, the breakline. For a close-up's window. */
+export function startPoints(o, marks, straight) {
+    const out = [];
+    if (marks.race.kind === "curved") {
+        if (marks.curve !== undefined)
+            out.push(...marks.curve);
+        if (marks.group !== undefined)
+            out.push(...marks.group);
+        return out;
+    }
+    const R = o.radius;
+    if (marks.race.kind === "straight") {
+        const sl = straight?.lane ?? o.lane;
+        const n = straight?.lanes ?? o.lanes;
+        for (const st of marks.starts)
+            out.push([st.x, R], [st.x, R + n * sl]);
+        return out;
+    }
+    for (const st of marks.starts) {
+        const [ra, rb] = laneSpan(o, st.lane);
+        out.push(...across(o, st.lane, st.s, ra, rb));
+    }
+    if (marks.curve !== undefined)
+        out.push(...marks.curve);
+    if (marks.group !== undefined)
+        out.push(...marks.group);
+    return out;
+}
+/** The pivot of a start's close-up: where the view is turned about, and the way the athletes face there. */
+export function startPivot(o, marks) {
+    if (marks.race.kind === "straight") {
+        const first = marks.starts[0];
+        const mid = marks.starts[Math.floor(marks.starts.length / 2)] ?? first;
+        return { x: mid.x, y: mid.y, heading: 0 };
+    }
+    if (marks.starts.length > 0) {
+        const mid = marks.starts[Math.floor((marks.starts.length - 1) / 2)];
+        return { x: mid.x, y: mid.y, heading: mid.heading };
+    }
+    const c = marks.curve;
+    const a = laneRadius(o, 1);
+    const origin = curveOrigin(o, a, marks.s1);
+    const p0 = pose(o, a, marks.s1);
+    void origin;
+    const mid = c[Math.floor(c.length / 2)];
+    return { x: mid[0], y: mid[1], heading: p0.heading };
+}

package/dist/athletics/steeplechase.d.ts

@@ -0,0 +1,72 @@
+import { type Parts } from "./oval.ts";
+import { type RaceContext } from "./races.ts";
+import { type Oval, type Pose } from "./track.ts";
+import type { RaceInfo, WaterJump } from "./types.ts";
+type Pt = [number, number];
+/** The figures of the diverted bend with the jump inside (Manual 2.2.4.1, comments on Figure 2.2.4.1a): the arcs of the oval's radius, the transitions and the straight between them. */
+export declare const INSIDE: {
+    /** The length of the lap, from A to A. */
+    readonly lap: 396.0849;
+    /** The angle of the arc on the oval's own circle before the transition: 42.5525 degrees, 27.3307 m on the 36.80 m running line. */
+    readonly b2: 27.3307;
+    /** The transition: 13.41545 m on a 16.20 m radius, 47.4475 degrees. */
+    readonly b1: 13.41545;
+    readonly radius: 16.2;
+    /** The straight between the transitions. */
+    readonly middle: 30.202;
+    /** The distance of the centres of the transition arcs from the second semicircle's centre, along the axis and across it. */
+    readonly centre: {
+        readonly out: 13.863;
+        readonly across: 15.101;
+    };
+    /** The distance of each of the five hurdles from the finish line along the lap. */
+    readonly hurdles: readonly [21.997, 101.214, 180.431, 259.648, 338.865];
+    readonly start3000: 172.594;
+    readonly start2000: 376.504;
+};
+/** The figures of the lap with the jump outside (Manual 2.2.4.1, Figure 2.2.4.1b and 2.2.4.1e). */
+export declare const OUTSIDE: {
+    readonly lap: 419.407;
+    readonly straight: 9.86;
+    readonly radius: 36.7;
+    readonly hurdles: readonly [17.866, 101.747, 185.628, 269.509, 353.39];
+    readonly start3000: 355.256;
+    readonly start2000: 97.035;
+};
+/** The steeplechase hurdle's figures (Rule 23.5 and 23.6; Figure 2.2.4.1c): at least 3.94 m wide and 0.127 m square at the top; the water jump's hurdle and pit are 3.66 m. */
+export declare const HURDLE: {
+    readonly width: 3.94;
+    readonly bar: 0.127;
+    readonly inside: 0.3;
+    readonly pit: 3.66;
+};
+/** The pose of the steeplechase's running line `s` metres from the finish line, with the diverted part of the lap and the oval's offset inside. */
+export interface ScPose extends Pose {
+    /** How far the track's inside edge is inside the running line: 0.30 m on the oval, 0.20 m where the lap is diverted from it. */
+    innerOffset: number;
+    /** True where the lap is off the oval's own line. */
+    diverted: boolean;
+}
+/** The oval's lane 1 distance that a distance along the steeplechase lap comes to where the two are the same line, and `undefined` where the lap is diverted. */
+export declare function standardDistance(o: Oval, variant: WaterJump, s: number): number | undefined;
+/** The length of the lap with the jump where it is. */
+export declare const scLap: (_o: Oval, variant: WaterJump) => number;
+/** A point of the steeplechase's running line. */
+export declare function scPose(o: Oval, variant: WaterJump, s: number): ScPose;
+/** The box round the water jump's pit, in metres. */
+export declare function waterPitBox(o: Oval, variant: WaterJump): {
+    x0: number;
+    y0: number;
+    x1: number;
+    y1: number;
+};
+/** The steeplechase's marks: the diverted border, the five hurdles, the water jump, and the start of the race (curved, with the outer group's line for the 3000 m). */
+export declare function steeplechaseParts(ctx: RaceContext, variant: WaterJump, race: RaceInfo | undefined, drawLap: boolean): {
+    parts: Parts;
+    start?: {
+        s: number;
+        curve: Pt[];
+        group?: Pt[];
+    };
+};
+export {};

package/dist/athletics/steeplechase.js

@@ -0,0 +1,196 @@
+// The steeplechase's lap and its water jump, inside the second bend of the 400 m Standard Track or outside it (Track and Field Facilities Manual 2019, 2.2.4 and Figures 2.2.4.1a, 2.2.4.1b, 2.2.4.1e,
+// with its comments on Figure 2.2.4.1a; Technical Rule 23 of Book C2.1). The lap with the jump inside is 396.0849 m (3.916 m shorter than the oval's), made of the first bend, the back straight, a
+// diverted bend (two arcs of the oval's own radius, two transitions of 16.20 m radius and a 30.2020 m straight) and the finish straight; the lap with the jump outside is 419.407 m (19.406 m longer): a
+// transitional straight of 9.86 m, a semicircle of 36.70 m and another straight of 9.86 m in place of the oval's bend. Five hurdles stand in a lap, the fourth the water jump. Metres.
+import { line, path, poly } from "../fields.kit.js";
+import { num } from "../format.js";
+import { emptyParts, outerRadius } from "./oval.js";
+import { curveAcross, curveOrigin, outward } from "./races.js";
+import { laneEdge, laneRadius, lap, pose, breaklineStagger } from "./track.js";
+/** The figures of the diverted bend with the jump inside (Manual 2.2.4.1, comments on Figure 2.2.4.1a): the arcs of the oval's radius, the transitions and the straight between them. */
+export const INSIDE = {
+    /** The length of the lap, from A to A. */
+    lap: 396.0849,
+    /** The angle of the arc on the oval's own circle before the transition: 42.5525 degrees, 27.3307 m on the 36.80 m running line. */
+    b2: 27.3307,
+    /** The transition: 13.41545 m on a 16.20 m radius, 47.4475 degrees. */
+    b1: 13.41545,
+    radius: 16.2,
+    /** The straight between the transitions. */
+    middle: 30.202,
+    /** The distance of the centres of the transition arcs from the second semicircle's centre, along the axis and across it. */
+    centre: { out: 13.863, across: 15.101 },
+    /** The distance of each of the five hurdles from the finish line along the lap. */
+    hurdles: [21.997, 101.214, 180.431, 259.648, 338.865],
+    start3000: 172.594,
+    start2000: 376.504,
+};
+/** The figures of the lap with the jump outside (Manual 2.2.4.1, Figure 2.2.4.1b and 2.2.4.1e). */
+export const OUTSIDE = {
+    lap: 419.407,
+    straight: 9.86,
+    radius: 36.7,
+    hurdles: [17.866, 101.747, 185.628, 269.509, 353.39],
+    start3000: 355.256,
+    start2000: 97.035,
+};
+/** The steeplechase hurdle's figures (Rule 23.5 and 23.6; Figure 2.2.4.1c): at least 3.94 m wide and 0.127 m square at the top; the water jump's hurdle and pit are 3.66 m. */
+export const HURDLE = { width: 3.94, bar: 0.127, inside: 0.3, pit: 3.66 };
+/** The oval's lane 1 distance that a distance along the steeplechase lap comes to where the two are the same line, and `undefined` where the lap is diverted. */
+export function standardDistance(o, variant, s) {
+    const a = laneRadius(o, 1);
+    const L = lap(o, 1);
+    const t = ((s % scLap(o, variant)) + scLap(o, variant)) % scLap(o, variant);
+    if (variant === "outside") {
+        const first = Math.PI * a + o.straight;
+        if (t <= first)
+            return t;
+        if (t >= first + 2 * OUTSIDE.straight + Math.PI * OUTSIDE.radius)
+            return t - (OUTSIDE.lap - L);
+        return undefined;
+    }
+    const first = Math.PI * a + o.straight + INSIDE.b2;
+    if (t <= first)
+        return t;
+    if (t >= first + 2 * INSIDE.b1 + INSIDE.middle)
+        return t + (L - INSIDE.lap);
+    return undefined;
+}
+/** The length of the lap with the jump where it is. */
+export const scLap = (_o, variant) => (variant === "outside" ? OUTSIDE.lap : INSIDE.lap);
+/** A point of the steeplechase's running line. */
+export function scPose(o, variant, s) {
+    const a = laneRadius(o, 1);
+    const L = scLap(o, variant);
+    const t = ((s % L) + L) % L;
+    const std = standardDistance(o, variant, t);
+    if (std !== undefined)
+        return { ...pose(o, a, std), innerOffset: 0.3, diverted: false };
+    const S = o.straight;
+    const cp1x = -S / 2;
+    if (variant === "outside") {
+        const first = Math.PI * a + S;
+        const x0 = cp1x - OUTSIDE.straight;
+        const r = OUTSIDE.radius;
+        const d = t - first;
+        if (d <= OUTSIDE.straight)
+            return { x: cp1x - d, y: -r, heading: Math.PI, innerOffset: 0.2, diverted: true };
+        if (d <= OUTSIDE.straight + Math.PI * r) {
+            const f = (d - OUTSIDE.straight) / r;
+            return { x: x0 - r * Math.sin(f), y: -r * Math.cos(f), heading: Math.PI - f, innerOffset: 0.2, diverted: true };
+        }
+        const e = d - OUTSIDE.straight - Math.PI * r;
+        return { x: x0 + e, y: r, heading: 0, innerOffset: 0.2, diverted: true };
+    }
+    // The jump inside: the upper transition about the centre above the axis, the straight, the lower transition.
+    const first = Math.PI * a + S + INSIDE.b2;
+    const R = INSIDE.radius;
+    const cu = [cp1x - INSIDE.centre.out, -INSIDE.centre.across];
+    const cl = [cp1x - INSIDE.centre.out, INSIDE.centre.across];
+    // The angle of the ray from the centre of a transition to the oval's circle: 227.55 degrees for the upper one.
+    const phi0 = Math.atan2(-INSIDE.centre.across, -INSIDE.centre.out);
+    const d = t - first;
+    if (d <= INSIDE.b1) {
+        const phi = phi0 - d / R;
+        return { x: cu[0] + R * Math.cos(phi), y: cu[1] + R * Math.sin(phi), heading: Math.atan2(-Math.cos(phi), Math.sin(phi)) + 0, innerOffset: 0.2, diverted: true };
+    }
+    if (d <= INSIDE.b1 + INSIDE.middle)
+        return { x: cu[0] - R, y: cu[1] + (d - INSIDE.b1), heading: Math.PI / 2, innerOffset: 0.2, diverted: true };
+    const e = d - INSIDE.b1 - INSIDE.middle;
+    // The lower transition: from the leftmost point (180 degrees) round to the ray towards the oval's circle at 132.45 degrees.
+    const lower = Math.PI - e / R;
+    return { x: cl[0] + R * Math.cos(lower), y: cl[1] + R * Math.sin(lower), heading: Math.atan2(-Math.cos(lower), Math.sin(lower)), innerOffset: 0.2, diverted: true };
+}
+/** The line of the diverted inner border and, for the jump outside, the band the diverted track lies on. */
+function divertedLines(o, variant) {
+    const S = o.straight;
+    const R = o.radius;
+    const cp1x = -S / 2;
+    if (variant === "outside") {
+        const c = cp1x - OUTSIDE.straight;
+        const inner = `M${num(cp1x)} ${num(-R)}H${num(c)}A${num(R)} ${num(R)} 0 0 0 ${num(c)} ${num(R)}H${num(cp1x)}`;
+        const wide = 5;
+        const band = `M${num(cp1x)} ${num(-R)}H${num(c)}A${num(R)} ${num(R)} 0 0 0 ${num(c)} ${num(R)}H${num(cp1x)}V${num(R + wide)}H${num(c)}A${num(R + wide)} ${num(R + wide)} 0 0 1 ${num(c)} ${num(-R - wide)}H${num(cp1x)}Z`;
+        return { shapes: [path("water-jump-border", "water-jump", inner, { w: 0.05 })], areas: [{ id: "water-jump-track", feature: "water-jump", cls: "ky-ath-track", d: band }] };
+    }
+    const k = Math.hypot(INSIDE.centre.out, INSIDE.centre.across);
+    const ux = -INSIDE.centre.out / k;
+    const uy = INSIDE.centre.across / k;
+    // The oval's circle is touched, from inside, by the transition's circle on the ray from the semicircle's centre through its centre: at 36.5 m from the centre.
+    const upper = [cp1x + R * ux, -R * uy];
+    const lower = [cp1x + R * ux, R * uy];
+    const x = cp1x - INSIDE.centre.out - INSIDE.radius;
+    const yc = INSIDE.centre.across;
+    const d = `M${num(upper[0])} ${num(upper[1])}A${num(INSIDE.radius)} ${num(INSIDE.radius)} 0 0 0 ${num(x)} ${num(-yc)}V${num(yc)}A${num(INSIDE.radius)} ${num(INSIDE.radius)} 0 0 0 ${num(lower[0])} ${num(lower[1])}`;
+    return { shapes: [path("water-jump-border", "water-jump", d, { w: 0.05 })], areas: [] };
+}
+/** One hurdle: a bar across the lane at distance `s` of the lap, from `inner - 0.30` outwards `width`. */
+function hurdle(o, variant, s, width, id, feature) {
+    const p = scPose(o, variant, s);
+    const [nx, ny] = outward(p.heading);
+    const a = -p.innerOffset - HURDLE.inside;
+    const b = a + width;
+    return line(id, feature, p.x + a * nx, p.y + a * ny, p.x + b * nx, p.y + b * ny, { w: HURDLE.bar, cls: "ky-ath-k", least: 0.2 });
+}
+/** The water jump's pit: 3.66 m along the run and 3.66 m across, from its hurdle forward, as a filled area with its border. */
+function waterPit(o, variant, s) {
+    const p = scPose(o, variant, s);
+    const [nx, ny] = outward(p.heading);
+    const fx = Math.cos(p.heading);
+    const fy = Math.sin(p.heading);
+    const a = -p.innerOffset - HURDLE.inside;
+    const b = a + HURDLE.pit;
+    const corner = (along, off) => [p.x + along * fx + off * nx, p.y + along * fy + off * ny];
+    const pts = [corner(0, a), corner(0, b), corner(HURDLE.pit, b), corner(HURDLE.pit, a)];
+    const d = `M${pts.map(([x, y]) => `${num(x)} ${num(y)}`).join("L")}Z`;
+    return { area: { id: "water-pit", feature: "water-jump", cls: "ky-ath-water", d }, edge: poly("water-pit-edge", "water-jump", pts, { closed: true, w: 0.05 }) };
+}
+/** The box round the water jump's pit, in metres. */
+export function waterPitBox(o, variant) {
+    const hurdleAt = variant === "outside" ? OUTSIDE.hurdles[3] : INSIDE.hurdles[3];
+    const p = scPose(o, variant, hurdleAt);
+    const [nx, ny] = outward(p.heading);
+    const fx = Math.cos(p.heading);
+    const fy = Math.sin(p.heading);
+    const a = -p.innerOffset - HURDLE.inside;
+    const b = a + HURDLE.pit;
+    const pts = [[0, a], [0, b], [HURDLE.pit, b], [HURDLE.pit, a]].map(([along, off]) => [p.x + along * fx + off * nx, p.y + along * fy + off * ny]);
+    return { x0: Math.min(...pts.map((q) => q[0])), y0: Math.min(...pts.map((q) => q[1])), x1: Math.max(...pts.map((q) => q[0])), y1: Math.max(...pts.map((q) => q[1])) };
+}
+/** The steeplechase's marks: the diverted border, the five hurdles, the water jump, and the start of the race (curved, with the outer group's line for the 3000 m). */
+export function steeplechaseParts(ctx, variant, race, drawLap) {
+    const o = ctx.oval;
+    const parts = emptyParts();
+    if (drawLap) {
+        const lines = divertedLines(o, variant);
+        parts.shapes.push(...lines.shapes);
+        parts.areas.push(...lines.areas);
+        const at = variant === "outside" ? OUTSIDE.hurdles : INSIDE.hurdles;
+        at.forEach((s, i) => {
+            if (i === 3) {
+                const pit = waterPit(o, variant, s);
+                parts.areas.push(pit.area);
+                parts.shapes.push(pit.edge, hurdle(o, variant, s, HURDLE.pit, "water-jump-hurdle", "water-jump"));
+            }
+            else
+                parts.shapes.push(hurdle(o, variant, s, HURDLE.width, `steeplechase-hurdle-${i + 1}`, "steeplechase-hurdles"));
+        });
+    }
+    if (race === undefined)
+        return { parts };
+    const sc = race.id === "2000m-steeplechase" ? (variant === "outside" ? OUTSIDE.start2000 : INSIDE.start2000) : variant === "outside" ? OUTSIDE.start3000 : INSIDE.start3000;
+    const std = standardDistance(o, variant, sc) ?? sc;
+    const a = laneRadius(o, 1);
+    const Rout = outerRadius(o);
+    const curve = curveAcross(o, curveOrigin(o, a, std), a, o.radius, Rout);
+    parts.shapes.push(poly("start-line", "start-lines", curve, { w: 0.05 }));
+    const out = { s: sc, curve };
+    if (race.group === true) {
+        const gl = ctx.lanes <= 6 ? 4 : 5;
+        const ag = laneRadius(o, gl);
+        const group = curveAcross(o, curveOrigin(o, ag, std + breaklineStagger(o, gl)), ag, laneEdge(o, gl - 1), Rout);
+        parts.shapes.push(poly("group-start-line", "start-lines", group, { w: 0.05 }));
+        out.group = group;
+    }
+    return { parts, start: out };
+}

package/dist/athletics/stencil.d.ts

@@ -0,0 +1,13 @@
+/** The width of a digit over its height, and the gap between two digits over the height. */
+export declare const DIGIT_WIDTH = 0.62;
+export declare const DIGIT_GAP = 0.14;
+/** The thickness of a stroke over the height. */
+export declare const STROKE = 0.18;
+/** The width of a string of digits at the height `h`. */
+export declare const digitsWidth: (text: string, h: number) => number;
+/**
+ * A string of digits as one path of strokes, centred on `(cx, cy)`, `h` tall, upright. `stroke-width` is `strokeWidth(h)`. Characters that are not digits are left out.
+ */
+export declare function digitsD(text: string, h: number, cx: number, cy: number): string;
+/** The thickness of a stroke at the height `h`. */
+export declare const strokeWidth: (h: number) => number;