@johnmorrisdotca/kyogijo-stadiums 0.4.0 → 0.6.0

package/dist/pool.js

@@ -0,0 +1,304 @@
+// What a pool is for a set of options: the sport's figures from the rules (pool.figures.ts) with the lanes, the ropes, the boards and the look the options ask for, in metres, in the frame of a drawing
+// lying wide (x along the pool from the starting wall on the left, y across it from the top side wall). Kept apart from the drawing so that the outline, the description, the replay and the charts agree.
+import { ARTISTIC, DIVING, SWIMMING, SWIMMING_WIDTHS, WATER_POLO } from "./pool.figures.js";
+import { racePlan } from "./pool.race.js";
+import { FEET_PER_METRE } from "./geometry.js";
+/** The sports of the pool, in the order a menu lists them. */
+export const POOL_SPORTS = Object.freeze(["swimming", "waterpolo", "diving", "artisticswimming"]);
+/** True for a sport whose surface is a pool. */
+export const isPoolSport = (sport) => typeof sport === "string" && POOL_SPORTS.includes(sport);
+/** Metres as feet, the unit a drawing is made in. */
+export const feet = (metres) => metres * FEET_PER_METRE;
+const LOOKS = ["flat", "water", "tiled"];
+const DECKS = ["plain", "tiled"];
+const PLATFORMS = [1, 3, 5, 7.5, 10];
+/** The size of the water of a pool in metres: `length` along the drawing and `width` across it. */
+export const poolSize = (plan) => ({ length: plan.length, width: plan.width });
+const num = (value, what, least, most) => {
+    if (typeof value !== "number" || !Number.isFinite(value) || value < least || value > most)
+        throw new RangeError(`${what} must be a number from ${least} to ${most}: ${String(value)} is not`);
+    return value;
+};
+/** The look the options ask for. @throws Error for a look or a deck the pool does not have. */
+export function commonOf(style) {
+    const look = style.look ?? "flat";
+    if (!LOOKS.includes(look))
+        throw new Error(`Unknown pool look "${String(style.look)}": use one of ${LOOKS.join(", ")}`);
+    const deck = style.deck ?? "plain";
+    if (!DECKS.includes(deck))
+        throw new Error(`Unknown deck "${String(style.deck)}": use one of ${DECKS.join(", ")}`);
+    const seed = style.seed === undefined ? 1 : Math.trunc(num(style.seed, "The pool's seed", -1e9, 1e9));
+    return { look, deck, seed };
+}
+/** The colour of rope `i` of `n + 1`: green outside, yellow round the middle, blue between (Part Two 15.7.6.1 and 15.7.6.3 for eight lanes; 15.7.6.2 for ten). */
+export function ropeColour(i, lanes) {
+    if (i === 0 || i === lanes)
+        return "green";
+    return Math.abs(i - lanes / 2) <= 1 ? "yellow" : "blue";
+}
+/** The width of a swimming pool of this length and this many lanes, the space outside the first and the last lane, and the width of those two lanes. */
+export function laneWidths(course, lanes, temporary) {
+    const lane = SWIMMING.lane;
+    if (lanes === 10)
+        return temporary ? { width: SWIMMING_WIDTHS.temporary, space: SWIMMING.spaceTemporaryWorld, edge: lane } : { width: SWIMMING_WIDTHS.permanent, space: SWIMMING.spacePermanentWorld, edge: SWIMMING.edgeLane };
+    if (lanes === 8 && course === "long")
+        return { width: SWIMMING_WIDTHS.permanent, space: SWIMMING.spaceOlympic, edge: lane };
+    const space = SWIMMING.spaceMinimum;
+    return { width: lanes * lane + 2 * space, space, edge: lane };
+}
+/** The lanes and the ropes of a pool of this width, from the top. */
+export function lanesOf(width, lanes, space) {
+    const lane = SWIMMING.lane;
+    // From the bottom wall: the ropes at the edges of the lanes. Ten lanes in the permanent pool: the end ropes 0.1 m from the walls, the others 2.5 m apart from 2.5 m, so that the markings stay 2.5 m apart (Part Two 15.13.2).
+    const fromBottom = [];
+    for (let k = 0; k <= lanes; k += 1)
+        fromBottom.push(lanes === 10 && width === SWIMMING_WIDTHS.permanent ? (k === 0 ? space : k === 10 ? width - space : k * lane) : space + k * lane);
+    const first = lanes === 10 ? 0 : 1;
+    const list = [];
+    for (let k = 0; k < lanes; k += 1) {
+        const mid = lanes === 10 && width === SWIMMING_WIDTHS.permanent ? lane / 2 + k * lane : space + lane / 2 + k * lane;
+        list.push({ number: first + k, y: width - mid, top: width - fromBottom[k + 1], bottom: width - fromBottom[k] });
+    }
+    const ropes = fromBottom.map((v, i) => ({ y: width - v, colour: ropeColour(i, lanes) }));
+    return { lanes: list.reverse(), ropes: ropes.reverse() };
+}
+/**
+ * The swimming pool the options ask for: `pool.course` (`long`, 50 m, or `short`, 25 m) and `pool.lanes` (8 by default). The width is the rules' for that many lanes: 25 m for eight in a 50 m
+ * pool (Part Two 15.6.1), 25 m for ten with lanes 0 and 9 of 2.4 m (Part Two 15.6.2.1), or 26 m for a temporary pool (Part Two 15.6.2.2), and lanes of 2.5 m with spaces of 0.5 m for the other pools.
+ * @throws RangeError for a lane count that is not 1 to 10, @throws Error for an unknown look.
+ */
+export function swimPlan(o, defaults = {}) {
+    const style = o.pool ?? {};
+    const kind = (style.kind ?? defaults.kind) === "warm-up" ? "warm-up" : "competition";
+    const course = (style.course ?? defaults.course) === "short" ? "short" : "long";
+    const count = style.lanes === undefined && defaults.lanes === undefined ? 8 : Math.trunc(num(style.lanes ?? defaults.lanes, "The number of lanes", 1, 10));
+    const { width, space } = laneWidths(course, count, style.temporary === true && count === 10);
+    const { lanes, ropes } = lanesOf(width, count, space);
+    const length = course === "long" ? SWIMMING.longCourse : SWIMMING.shortCourse;
+    const competition = kind === "competition";
+    const on = (value) => (value === undefined ? competition : value);
+    const depth = style.section !== undefined && typeof style.section === "object" && style.section.depth !== undefined ? num(style.section.depth, "The section's depth", 0.5, 10) : course === "long" ? SWIMMING.depth.olympic : SWIMMING.depth.shortWorld;
+    const section = style.section === undefined || style.section === false ? undefined : { exaggerate: typeof style.section === "object" && style.section.exaggerate !== undefined ? num(style.section.exaggerate, "The section's exaggeration", 1, 8) : 2.5 };
+    const plan = {
+        sport: "swimming",
+        ...commonOf(style),
+        kind,
+        course,
+        length,
+        width,
+        lanes,
+        space,
+        ropes,
+        blocks: on(style.blocks),
+        pads: on(style.pads),
+        flags: on(style.flags),
+        falseStart: on(style.falseStart),
+        depth,
+        section,
+        race: undefined,
+    };
+    if (style.race !== undefined)
+        plan.race = racePlan(style.race, lanes.map((l) => l.number), { splitEvery: course === "long" ? 50 : 25, length });
+    return plan;
+}
+/** The water polo field the options ask for: 25 by 20 m (Part Six 20.2.2). */
+export function poloPlan(o) {
+    const style = o.pool ?? {};
+    const table = style.table === "top" ? "top" : "bottom";
+    return { sport: "waterpolo", ...commonOf(style), length: WATER_POLO.length + 2 * WATER_POLO.goal.netClear, width: WATER_POLO.width, table };
+}
+/** The measure of a diving table row: the preferred figure. */
+const pref = (pair) => pair[1];
+const BOARDS = {
+    "1": { b: DIVING.B.platform1, c: DIVING.C.platform1, a: DIVING.A.platform1 },
+    "3": { b: DIVING.B.platform3, c: DIVING.C.platform3, a: DIVING.A.platform3 },
+    "5": { b: DIVING.B.platform5, c: DIVING.C.platform5, a: DIVING.A.platform5 },
+    "7.5": { b: DIVING.B.platform75, c: DIVING.C.platform75, a: DIVING.A.platform75 },
+    "10": { b: DIVING.B.platform10, c: DIVING.C.platform10, a: DIVING.A.platform10 },
+};
+/**
+ * The diving well the options ask for. The springboards (1 m and 3 m, `pool.boards` of each, 2 by default so that a synchronised pair stands side by side) stand along the left wall, 3 m boards outside, each the preferred
+ * distance (Part Four, Appendix 2, B and C) from the wall and from the next; the platforms (5, 7.5 and 10 m by default) stand towards the right wall, the tallest the distance B from it and each lower one the distance C of the
+ * platform above it from that one. The well is 25 m across, wider if the boards need more room than that.
+ * @throws RangeError for a platform the rules do not have or a count of boards that is not 1 to 4.
+ */
+export function divePlan(o) {
+    const style = o.pool ?? {};
+    const asked = style.platforms === undefined ? [5, 7.5, 10] : [...style.platforms];
+    for (const h of asked)
+        if (!PLATFORMS.includes(h))
+            throw new RangeError(`The rules have no ${String(h)} m platform: use ${PLATFORMS.join(", ")}`);
+    const heights = [...new Set(asked)].sort((a, b) => a - b);
+    const count = style.boards === undefined ? 2 : Math.trunc(num(style.boards, "The number of boards of each height", 1, 4));
+    const boards = [];
+    let left = 0;
+    if (style.springboards !== false) {
+        const sb = DIVING.springboard;
+        let y = pref(DIVING.B.springboard3);
+        for (let i = 0; i < count; i += 1) {
+            boards.push({ kind: "springboard", height: 3, x: pref(DIVING.A.springboard3), y, length: sb.length, width: sb.width });
+            left = y;
+            y += i < count - 1 ? pref(DIVING.C.springboard3) : pref(DIVING.C.springboard3);
+        }
+        for (let i = 0; i < count; i += 1) {
+            boards.push({ kind: "springboard", height: 1, x: pref(DIVING.A.springboard1), y, length: sb.length, width: sb.width });
+            left = y;
+            y += pref(DIVING.C.springboard1);
+        }
+    }
+    // The platforms from the tallest, the distance B from the right wall.
+    const tops = [];
+    let width = DIVING.well.width;
+    const place = (width0) => {
+        const out = [];
+        let y;
+        let above = 0;
+        for (const h of [...heights].reverse()) {
+            const spec = DIVING.platforms[String(h)];
+            const info = BOARDS[String(h)];
+            // From the plummet of the platform above, the distance C of that platform.
+            y = y === undefined ? width0 - pref(info.b) : y - above;
+            above = pref(info.c);
+            out.push({ kind: "platform", height: h, x: pref(info.a), y, length: spec.length, width: pref(spec.width) });
+        }
+        return out;
+    };
+    let platforms = place(width);
+    // Room between the last springboard and the first platform, so that their stands do not touch: widen the well if they would crowd.
+    const clear = 2;
+    if (platforms.length > 0 && boards.length > 0) {
+        const first = platforms[platforms.length - 1];
+        const need = left + DIVING.springboard.width / 2 + clear + first.width / 2 - first.y;
+        if (need > 0) {
+            width += need;
+            platforms = place(width);
+        }
+    }
+    tops.push(...platforms);
+    const all = [...boards, ...tops];
+    const behind = Math.max(0, ...all.map((b) => b.length - b.x));
+    return { sport: "diving", ...commonOf(style), length: DIVING.well.length, width, boards: all, behind };
+}
+/** The artistic swimming area the options ask for: 30 by 20 m for the Olympic Games and the World Championships, or the least, 25 by 15 m with a 12 by 12 m deep part (Part Seven 12.2.2, 12.1.1). */
+export function artisticPlan(o) {
+    const style = o.pool ?? {};
+    const area = style.area === "minimum" ? "minimum" : "olympic";
+    if (area === "olympic")
+        return { sport: "artisticswimming", ...commonOf(style), area, length: ARTISTIC.olympic.length, width: ARTISTIC.olympic.width, deep: undefined };
+    const m = ARTISTIC.minimum;
+    return { sport: "artisticswimming", ...commonOf(style), area, length: m.length, width: m.width, deep: { x: (m.length - m.deepLength) / 2, y: (m.width - m.deepWidth) / 2, length: m.deepLength, width: m.deepWidth } };
+}
+/** The pool the options ask for, of the sport's kind. */
+export function poolPlan(o) {
+    switch (o.sport) {
+        case "swimming":
+            return swimPlan(o);
+        case "waterpolo":
+            return poloPlan(o);
+        case "diving":
+            return divePlan(o);
+        case "artisticswimming":
+            return artisticPlan(o);
+        default:
+            throw new Error(`"${String(o.sport)}" is not a pool sport`);
+    }
+}
+/** The hall of a natatorium asked for, with `natatorium` standing for the usual three pools. */
+export function venueOf(style) {
+    if (style.venue === undefined)
+        return undefined;
+    if (style.venue === "natatorium") {
+        return {
+            pools: [
+                { sport: "swimming", name: "Competition pool", course: "long" },
+                { sport: "diving", name: "Diving well" },
+                { sport: "swimming", name: "Warm-up pool", course: "short", kind: "warm-up" },
+            ],
+        };
+    }
+    if (typeof style.venue !== "object" || style.venue === null || !Array.isArray(style.venue.pools) || style.venue.pools.length === 0)
+        throw new TypeError(`venue is "natatorium" or { pools: [...] } with at least one pool`);
+    return style.venue;
+}
+/** What each plan reaches beyond its water, in metres on each side: the blocks and flag standards, the platforms and table, the stands behind the diving boards, the judges' platform. */
+export function reachOf(plan) {
+    switch (plan.sport) {
+        case "swimming":
+            return { left: 1.3, right: 1.3, top: 1.2, bottom: 1.2 };
+        case "waterpolo":
+            return { left: 0.6, right: 0.6, top: 1.8, bottom: 4.2 };
+        case "diving":
+            return { left: plan.behind + 4, right: 0.5, top: 0.5, bottom: 0.5 };
+        default:
+            return { left: 0.5, right: 0.5, top: 2.8, bottom: 2.2 };
+    }
+}
+/** The most a row of pools is laid out to, in metres, when the pools have no places of their own. */
+const ROW = 125;
+/**
+ * The pools of a hall (`pool.venue`) laid out to scale. A pool with an `x` and a `y` stands there; the others are set in rows, left to right, each `apart` metres (10, the distance the rules prefer between
+ * a swimming pool and a diving well, Part Two 15.15.1; never less than the 8 they require) from the one before, and a new row when a row would be longer than 125 m.
+ * @throws RangeError when two pools are nearer each other than `apart`, for the pools given places.
+ */
+export function venueLayout(style) {
+    const venue = venueOf(style);
+    if (venue === undefined)
+        return undefined;
+    const apart = venue.apart === undefined ? SWIMMING.poolsApartPreferred : num(venue.apart, "The distance between pools", SWIMMING.poolsApart, 100);
+    const common = { look: style.look, deck: style.deck, seed: style.seed };
+    const items = [];
+    let x = 0;
+    let y = 0;
+    let rowHeight = 0;
+    for (const pool of venue.pools) {
+        if (typeof pool !== "object" || pool === null || !isPoolSport(pool.sport))
+            throw new TypeError(`A pool of a venue is { sport: ${POOL_SPORTS.map((s) => `"${s}"`).join(" | ")}, ... }`);
+        const pooled = { ...common, ...(pool.sport === "swimming" ? { course: pool.course, lanes: pool.lanes, kind: pool.kind } : {}) };
+        const plan = poolPlan({ sport: pool.sport, pool: pooled });
+        const placed = pool.x !== undefined && pool.y !== undefined;
+        if (!placed) {
+            if (items.length > 0 && x + plan.length > ROW) {
+                x = 0;
+                y += rowHeight + apart;
+                rowHeight = 0;
+            }
+            items.push({ pool, plan, x, y });
+            x += plan.length + apart;
+            rowHeight = Math.max(rowHeight, plan.width);
+        }
+        else
+            items.push({ pool, plan, x: num(pool.x, "A pool's x", -1000, 1000), y: num(pool.y, "A pool's y", -1000, 1000) });
+    }
+    // The box round all the water, moved to the origin.
+    const x0 = Math.min(...items.map((i) => i.x));
+    const y0 = Math.min(...items.map((i) => i.y));
+    for (const item of items) {
+        item.x -= x0;
+        item.y -= y0;
+    }
+    for (const [i, a] of items.entries()) {
+        for (const b of items.slice(i + 1)) {
+            const gapX = Math.max(a.x - (b.x + b.plan.length), b.x - (a.x + a.plan.length));
+            const gapY = Math.max(a.y - (b.y + b.plan.width), b.y - (a.y + a.plan.width));
+            if (Math.max(gapX, gapY) < apart - 1e-9)
+                throw new RangeError(`Two pools of the venue are nearer than ${apart} m: the rules keep a swimming pool and a diving well at least ${SWIMMING.poolsApart} m apart`);
+        }
+    }
+    const width = Math.max(...items.map((i) => i.x + i.plan.length));
+    const height = Math.max(...items.map((i) => i.y + i.plan.width));
+    const reach = {
+        left: Math.max(...items.map((i) => reachOf(i.plan).left - i.x), 0),
+        right: Math.max(...items.map((i) => reachOf(i.plan).right + i.x + i.plan.length - width), 0),
+        top: Math.max(...items.map((i) => reachOf(i.plan).top - i.y), 0),
+        bottom: Math.max(...items.map((i) => reachOf(i.plan).bottom + i.y + i.plan.width - height), 0),
+    };
+    return { items, width, height, apart, labels: venue.labels !== false, seating: venue.seating !== false, reach };
+}
+/** The box round the water the options draw, in feet: the pool's, or the whole hall's. */
+export function poolBox(o) {
+    const hall = o.sport === "swimming" && o.pool?.venue !== undefined ? venueLayout(o.pool) : undefined;
+    if (hall !== undefined)
+        return { w: feet(hall.width), h: feet(hall.height) };
+    const plan = poolPlan(o);
+    return { w: feet(plan.length), h: feet(plan.width) };
+}

package/dist/pool.kit.d.ts

@@ -0,0 +1,48 @@
+import type { DeckLook, PoolLook } from "./pool.types.ts";
+import { type BuildOptions } from "./surfaces/surface.ts";
+/** A small generator of numbers from 0 up to 1 that starts from a seed (mulberry32): the same seed gives the same list. */
+export declare function seeded(seed: number): () => number;
+/** The side of the tile of light, in feet (about 5 m). */
+export declare const CAUSTIC_TILE = 16;
+/**
+ * The light on the water: a tile of closed, softly bent cells like the net of light at the bottom of a pool, from the seed. The cells at the tile's edge are drawn again on the far side, so that the
+ * tile repeats without a seam. Returns the path of all of them.
+ */
+export declare function causticPath(seed: number, size?: number): string;
+/** The ids of what a pool defines for its paint. */
+export interface PoolIds {
+    caustic: string;
+    floor: string;
+    deck: string;
+    water: string;
+}
+/** What a pool is drawn with when it is one of several in a hall: the ids of the paint the hall defines once, and no deck, no defs, no plates and no section of its own. */
+export interface PoolCtx {
+    ids?: PoolIds;
+    bare?: boolean;
+}
+/** The ids a drawing's pools share: they follow the drawing's own prefix. */
+export declare const poolIds: (id: string) => PoolIds;
+/** The metres of a tile of the floor (drawn; real tiles are finer) and of the deck. */
+export declare const FLOOR_TILE = 0.5;
+export declare const DECK_TILE = 0.6;
+/**
+ * The patterns and the gradient a pool's paint needs, for a look and a deck. Each is defined once, however many pools use it. A flat pool with a plain deck needs none.
+ */
+export declare function paintDefs(ids: PoolIds, look: PoolLook, deck: DeckLook, seed: number): string;
+/** A rectangle in metres from its corners, as feet. */
+export declare function box(o: Pick<BuildOptions, "features">, names: string | readonly string[], cls: string, x0: number, y0: number, x1: number, y1: number, more?: Record<string, string | number | undefined>): string;
+/**
+ * The water of a pool, in metres from the corner `(x, y)`: the colour, then, for a look that has it, the gradient across the lanes, the floor's tiles and the light on the water. Tiles and light are
+ * laid at the pool's own place, so that two pools side by side show one floor.
+ */
+export declare function waterMarkup(o: Pick<BuildOptions, "features">, ids: PoolIds, look: PoolLook, x: number, y: number, length: number, width: number, clip?: string): string;
+/** The deck as a rectangle in feet: the colour, then its tiles. */
+export declare function deckMarkup(o: Pick<BuildOptions, "features">, ids: PoolIds, deck: DeckLook, x: number, y: number, w: number, h: number): string;
+/** The widths a pool draws at: a rope is at least this wide on the page unless the true widths are asked for. */
+export declare function leastWidth(o: Pick<BuildOptions, "exact">, trueMetres: number, drawnMetres: number): number;
+/**
+ * A row of lane ropes as one path per colour: each rope's runs of floats as round dots at the pitch of the floats. `runs` are `[colour, x0, x1, y]` in metres. Round caps on a dash of no length make a dot,
+ * so a rope of 330 floats is one subpath. A float is `metres` across, drawn at least `drawn` metres across.
+ */
+export declare function ropeMarkup(o: Pick<BuildOptions, "features" | "exact">, runs: readonly (readonly [string, number, number, number])[], metres: number, drawn: number): string;

package/dist/pool.kit.js

@@ -0,0 +1,141 @@
+// What every pool is painted with: the light on the water (a few seeded curves in a tile, defined once and repeated by a pattern), the tiles of the floor and of the deck, the lane ropes as rows
+// of floats, and the small helpers of a drawing made in feet from figures in metres. No random number: the curves come from a small generator that starts from the pool's `seed`, so the same options
+// draw the same light. The rules say nothing of how water or a deck looks; these colours and patterns are ours.
+import { el, num } from "./format.js";
+import { feet } from "./pool.js";
+import { ft } from "./surfaces/surface.js";
+/** A small generator of numbers from 0 up to 1 that starts from a seed (mulberry32): the same seed gives the same list. */
+export function seeded(seed) {
+    let a = (Math.trunc(seed) ^ 0x9e3779b9) >>> 0;
+    return () => {
+        a = (a + 0x6d2b79f5) >>> 0;
+        let t = a;
+        t = Math.imul(t ^ (t >>> 15), t | 1);
+        t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}
+/** The side of the tile of light, in feet (about 5 m). */
+export const CAUSTIC_TILE = 16;
+/** A smooth closed curve through points (Catmull-Rom as cubic curves), as a path. */
+function loop(points) {
+    const n = points.length;
+    let d = `M${num(points[0][0])} ${num(points[0][1])}`;
+    for (let i = 0; i < n; i += 1) {
+        const p0 = points[(i - 1 + n) % n];
+        const p1 = points[i];
+        const p2 = points[(i + 1) % n];
+        const p3 = points[(i + 2) % n];
+        const c1 = [p1[0] + (p2[0] - p0[0]) / 6, p1[1] + (p2[1] - p0[1]) / 6];
+        const c2 = [p2[0] - (p3[0] - p1[0]) / 6, p2[1] - (p3[1] - p1[1]) / 6];
+        d += `C${num(c1[0])} ${num(c1[1])} ${num(c2[0])} ${num(c2[1])} ${num(p2[0])} ${num(p2[1])}`;
+    }
+    return `${d}Z`;
+}
+/**
+ * The light on the water: a tile of closed, softly bent cells like the net of light at the bottom of a pool, from the seed. The cells at the tile's edge are drawn again on the far side, so that the
+ * tile repeats without a seam. Returns the path of all of them.
+ */
+export function causticPath(seed, size = CAUSTIC_TILE) {
+    const rand = seeded(seed);
+    const cells = 4;
+    const step = size / cells;
+    const parts = [];
+    for (let i = 0; i < cells; i += 1) {
+        for (let j = 0; j < cells; j += 1) {
+            const cx = (i + 0.5 + (rand() - 0.5) * 0.45) * step;
+            const cy = (j + 0.5 + (rand() - 0.5) * 0.45) * step;
+            const sides = 6;
+            const turn = rand() * Math.PI;
+            const points = [];
+            for (let k = 0; k < sides; k += 1) {
+                const angle = turn + (k / sides) * 2 * Math.PI + (rand() - 0.5) * 0.5;
+                const r = step * (0.42 + rand() * 0.16);
+                points.push([cx + Math.cos(angle) * r, cy + Math.sin(angle) * r * 0.9]);
+            }
+            const reach = step * 0.7;
+            for (const dx of [-size, 0, size]) {
+                for (const dy of [-size, 0, size]) {
+                    if (cx + dx + reach < 0 || cx + dx - reach > size || cy + dy + reach < 0 || cy + dy - reach > size)
+                        continue;
+                    parts.push(loop(points.map(([x, y]) => [x + dx, y + dy])));
+                }
+            }
+        }
+    }
+    return parts.join("");
+}
+/** The ids a drawing's pools share: they follow the drawing's own prefix. */
+export const poolIds = (id) => ({ caustic: `${id}-lt`, floor: `${id}-ft`, deck: `${id}-dt`, water: `${id}-wg` });
+/** The metres of a tile of the floor (drawn; real tiles are finer) and of the deck. */
+export const FLOOR_TILE = 0.5;
+export const DECK_TILE = 0.6;
+/**
+ * The patterns and the gradient a pool's paint needs, for a look and a deck. Each is defined once, however many pools use it. A flat pool with a plain deck needs none.
+ */
+export function paintDefs(ids, look, deck, seed) {
+    let defs = "";
+    if (look !== "flat") {
+        defs += el("linearGradient", { id: ids.water, x1: 0, y1: 0, x2: 0, y2: 1 }, el("stop", { offset: 0, class: "ky-pl-sa" }) + el("stop", { offset: 0.5, class: "ky-pl-sb" }) + el("stop", { offset: 1, class: "ky-pl-sa" }));
+        defs += el("pattern", { id: ids.caustic, width: CAUSTIC_TILE, height: CAUSTIC_TILE, patternUnits: "userSpaceOnUse" }, el("path", { class: "ky-pl-lt", d: causticPath(seed) }));
+    }
+    if (look === "tiled") {
+        const t = feet(FLOOR_TILE);
+        defs += el("pattern", { id: ids.floor, width: t, height: t, patternUnits: "userSpaceOnUse" }, el("path", { class: "ky-pl-ft", d: `M0 0H${num(t)}M0 0V${num(t)}` }));
+    }
+    if (deck === "tiled") {
+        const t = feet(DECK_TILE);
+        defs += el("pattern", { id: ids.deck, width: t * 2, height: t * 2, patternUnits: "userSpaceOnUse" }, el("rect", { class: "ky-pl-da", x: 0, y: 0, width: t, height: t }) + el("rect", { class: "ky-pl-da", x: t, y: t, width: t, height: t }) + el("path", { class: "ky-pl-dt", d: `M0 0H${num(t * 2)}M0 ${num(t)}H${num(t * 2)}M0 0V${num(t * 2)}M${num(t)} 0V${num(t * 2)}` }));
+    }
+    return defs;
+}
+/** A rectangle in metres from its corners, as feet. */
+export function box(o, names, cls, x0, y0, x1, y1, more = {}) {
+    return el("rect", { class: ft(o, names, cls), x: feet(x0), y: feet(y0), width: feet(x1 - x0), height: feet(y1 - y0), ...more });
+}
+/**
+ * The water of a pool, in metres from the corner `(x, y)`: the colour, then, for a look that has it, the gradient across the lanes, the floor's tiles and the light on the water. Tiles and light are
+ * laid at the pool's own place, so that two pools side by side show one floor.
+ */
+export function waterMarkup(o, ids, look, x, y, length, width, clip) {
+    const at = { x: feet(x), y: feet(y), width: feet(length), height: feet(width), "clip-path": clip };
+    let out = el("rect", { class: ft(o, "water", "ky-surface"), x: at.x, y: at.y, width: at.width, height: at.height });
+    if (look !== "flat")
+        out += el("rect", { class: "ky-pl-wg", ...at, fill: `url(#${ids.water})` });
+    if (look === "tiled")
+        out += el("rect", { class: "ky-pl-tl", ...at, fill: `url(#${ids.floor})` });
+    if (look !== "flat")
+        out += el("rect", { class: "ky-pl-ls", ...at, fill: `url(#${ids.caustic})` });
+    return out;
+}
+/** The deck as a rectangle in feet: the colour, then its tiles. */
+export function deckMarkup(o, ids, deck, x, y, w, h) {
+    let out = el("rect", { class: ft(o, "apron", "ky-apron"), x, y, width: w, height: h });
+    if (deck === "tiled")
+        out += el("rect", { class: "ky-pl-dk", x, y, width: w, height: h, fill: `url(#${ids.deck})` });
+    return out;
+}
+/** The widths a pool draws at: a rope is at least this wide on the page unless the true widths are asked for. */
+export function leastWidth(o, trueMetres, drawnMetres) {
+    return feet(o.exact ? trueMetres : Math.max(trueMetres, drawnMetres));
+}
+/** The order ropes' colours are drawn in: the lane's own colour, then the red ends and the distinct marks over it. */
+const ROPE_ORDER = ["green", "blue", "yellow", "red", "white"];
+/**
+ * A row of lane ropes as one path per colour: each rope's runs of floats as round dots at the pitch of the floats. `runs` are `[colour, x0, x1, y]` in metres. Round caps on a dash of no length make a dot,
+ * so a rope of 330 floats is one subpath. A float is `metres` across, drawn at least `drawn` metres across.
+ */
+export function ropeMarkup(o, runs, metres, drawn) {
+    const by = new Map();
+    for (const [colour, x0, x1, y] of runs)
+        by.set(colour, [...(by.get(colour) ?? []), `M${num(feet(x0))} ${num(feet(y))}H${num(feet(x1))}`]);
+    const width = leastWidth(o, metres, drawn);
+    let out = "";
+    for (const colour of ROPE_ORDER) {
+        const d = by.get(colour);
+        if (d === undefined)
+            continue;
+        out += el("path", { class: ft(o, [`rope-${colour}`, "lane-ropes"], `ky-pl-r ky-pl-r-${colour}`), d: d.join(""), "stroke-width": width, "stroke-dasharray": `0 ${num(width * 0.86)}`, fill: "none" });
+    }
+    return out;
+}

package/dist/pool.labels.d.ts

@@ -0,0 +1,20 @@
+import { type SwimPlan } from "./pool.ts";
+import { type BuildOptions } from "./surfaces/surface.ts";
+/** What the data of a race draws: the plates at each end, the title above, the pace bars on the water, and how far each reaches beyond the pool, in feet. */
+export interface RaceArt {
+    /** The plates at the starting end (the names), at the turning end (the results), and the event and the distances above the pool. */
+    left: string;
+    right: string;
+    top: string;
+    /** The pace bars, over the water and under the ropes' labels. */
+    pace: string;
+    reachLeft: number;
+    reachRight: number;
+    reachTop: number;
+}
+/** The medal each of the first three places wins: gold, silver and bronze, in these colours whatever the look. */
+export declare const MEDALS: Readonly<Record<number, string>>;
+/** The colour of a pace between the field's slowest (0) and fastest (1). */
+export declare function paceColour(t: number): string;
+/** Everything the data of the race draws. */
+export declare function raceArt(plan: SwimPlan, o: Pick<BuildOptions, "portrait" | "features" | "exact">): RaceArt;