@johnmorrisdotca/kyogijo-stadiums 0.4.0 → 0.5.0

package/dist/surfaces/field.js

@@ -4,7 +4,7 @@ import { mowTurf, oddCells } from "../mow.js";
 import { ft, quarterTurn } from "./surface.js";
 const RAD = Math.PI / 180;
 /** The path of one shape that is drawn as a line, or of one filled bar. */
-function pathOf(shape) {
+export function pathOf(shape) {
     switch (shape.kind) {
         case "line":
             return shape.y0 === shape.y1 ? `M${num(shape.x0)} ${num(shape.y0)}H${num(shape.x1)}` : shape.x0 === shape.x1 ? `M${num(shape.x0)} ${num(shape.y0)}V${num(shape.y1)}` : `M${num(shape.x0)} ${num(shape.y0)}L${num(shape.x1)} ${num(shape.y1)}`;
@@ -27,7 +27,7 @@ function pathOf(shape) {
             return "";
     }
 }
-const areaD = (a) => {
+export const areaD = (a) => {
     if (a.d !== undefined)
         return a.d;
     if (a.frame !== undefined) {
@@ -61,19 +61,21 @@ export function strokes(plan, o) {
     return out;
 }
 /** The filled marks of a plan: the bars in one path to a feature, the dots one each. */
-function marks(plan, o) {
+export function marks(plan, o) {
     const bars = new Map();
     let dots = "";
     const lift = o.exact ? 1 : 1.6;
     for (const shape of plan.shapes) {
         if (shape.kind === "bar")
-            bars.set(shape.feature, [...(bars.get(shape.feature) ?? []), pathOf(shape)]);
+            bars.set(`${shape.feature}|${shape.cls ?? ""}`, [...(bars.get(`${shape.feature}|${shape.cls ?? ""}`) ?? []), pathOf(shape)]);
         else if (shape.kind === "dot")
-            dots += el("circle", { class: ft(o, shape.feature, shape.paint === "post" ? "ky-post-end" : "ky-fill-line"), cx: shape.cx, cy: shape.cy, r: shape.r * lift });
+            dots += el("circle", { class: ft(o, shape.feature, shape.paint === "post" ? "ky-post-end" : shape.paint === "block" ? "ky-ska-block" : shape.paint === "cone" ? "ky-ska-cone" : "ky-fill-line"), cx: shape.cx, cy: shape.cy, r: shape.r * lift });
     }
     let out = "";
-    for (const [feature, d] of bars)
-        out += el("path", { class: ft(o, feature, "ky-fill-line"), d: d.join("") });
+    for (const [key, d] of bars) {
+        const [feature, cls] = key.split("|");
+        out += el("path", { class: ft(o, feature, cls === "" ? "ky-fill-line" : cls), d: d.join("") });
+    }
     return out + dots;
 }
 /** One goal as the options ask for it: the net behind the goal line as a box, a line across the mouth, a solid strip, or nothing. */
@@ -118,8 +120,8 @@ export function fieldSurface(o, plan, style = {}) {
         }
     }
     for (const area of plan.areas)
-        base += el("path", { class: ft(o, area.feature, area.cls), d: areaD(area), "fill-rule": area.frame === undefined ? undefined : "evenodd" });
-    const ends = o.score && plan.ends !== undefined ? plan.ends : undefined;
+        base += el("path", { class: ft(o, area.feature, area.cls), d: areaD(area), "fill-rule": area.frame === undefined && area.evenodd !== true ? undefined : "evenodd" });
+    const ends = o.score && o.pageant !== true && plan.ends !== undefined ? plan.ends : undefined;
     if (ends !== undefined) {
         for (const side of ["left", "right"]) {
             const b = ends[side];
@@ -152,6 +154,10 @@ export function fieldSurface(o, plan, style = {}) {
     surface.box = { x: 0, y: 0, w: L, h: W };
     surface.lineRef = { width: thick, feet: 1 };
     surface.ranges = plan.ranges;
+    // A pageant's pictures keep clear of a cricket pitch, which runs through the middle.
+    const pitch = plan.sport === "cricket" ? plan.ranges?.pitch : undefined;
+    if (pitch !== undefined && !("left" in pitch))
+        surface.pageant = { clear: pitch.w / 2 };
     if (o.landmarks === true)
         surface.marks = full ? [...plan.marks] : plan.marks.filter((mark) => !mark.id.startsWith("~"));
     if (o.portrait) {

package/dist/surfaces/hockey.js

@@ -128,6 +128,7 @@ export function hockey(o, era, rink = NHL_RINK) {
     };
     surface.lineRef = { width: thin, feet: 1 };
     surface.box = { x: 0, y: 0, w: L, h: W };
+    surface.centreRadius = rink.circleRadius;
     // The zones of the ice: from the end boards to a blue line, and between the blue lines.
     const zone = atEnds((end) => (end === "left" ? edges(0, 0, blueLine, W) : edges(L - blueLine, 0, L, W)));
     surface.ranges = {

package/dist/surfaces/net.d.ts

@@ -2,6 +2,7 @@ import { type CourtPlan } from "../court.ts";
 import { type BuildOptions, type Surface } from "./surface.ts";
 /**
  * A net sport's court lying wide: the ground, the free zone, the court, its painted areas, its lines, the net with its posts (and, in volleyball, its antennae)
- * and, on a score, the place for the board. Every length that is a rulebook's figure comes from the league (leagues/courts.ts) through `courtGeometry`.
+ * and, on a score, the place for the board. Every length that is a rulebook's figure comes from the league (leagues/courts.ts) through `courtGeometry`. The courts of
+ * the sports added after the first five may also have walls, rings (circles and arcs), a table or a set, and no net.
  */
 export declare function netCourt(o: BuildOptions, plan: CourtPlan): Surface;

package/dist/surfaces/net.js

@@ -1,4 +1,4 @@
-import { courtGeometry, courtSize, sideReach } from "../court.js";
+import { bandReach, courtGeometry, courtSize, sideReach } from "../court.js";
 import { el, num } from "../format.js";
 import { atEnds, edges, ft, quarterTurn } from "./surface.js";
 /** A rectangle as a closed sub-path. */
@@ -8,9 +8,35 @@ function mark(f, cls) {
     const half = f.size / 2;
     return f.shape === "round" ? el("circle", { class: cls, cx: f.x, cy: f.y, r: half }) : el("rect", { class: cls, x: f.x - half, y: f.y - half, width: f.size, height: f.size });
 }
+/**
+ * A ring or an arc as a stroked line: a circle element for a whole circle, else a path from `a0` to `a1` in pieces of at most a quarter turn (an arc of exactly half a circle,
+ * drawn in one piece with rounded numbers, can lose its centre). The line's outer edge is at the radius, so its middle is half a width inside it.
+ */
+function ringMarkup(o, ring) {
+    const { cx, cy, w } = ring;
+    const r = Math.max(0.001, ring.r - w / 2);
+    const cls = ft(o, "lines", "ky-line");
+    if (ring.a0 === undefined || ring.a1 === undefined)
+        return el("circle", { class: cls, cx, cy, r, "stroke-width": w });
+    const turns = Math.max(1, Math.ceil((ring.a1 - ring.a0) / (Math.PI / 2) - 1e-9));
+    const at = (a) => `${num(cx + r * Math.cos(a))} ${num(cy + r * Math.sin(a))}`;
+    let d = `M${at(ring.a0)}`;
+    for (let i = 1; i <= turns; i += 1)
+        d += `A${num(r)} ${num(r)} 0 0 1 ${at(ring.a0 + ((ring.a1 - ring.a0) * i) / turns)}`;
+    return el("path", { class: cls, d, "stroke-width": w });
+}
+/** What each kind of band is drawn with: the class and the feature it belongs to. */
+const BAND = { wall: ["walls", "ky-wall"], mesh: ["fence", "ky-mesh"], face: ["wall-face", "ky-face"], tin: ["tin", "ky-tin"] };
+/** A solid on the court: a table is a rectangle, a roundnet set a rim round a net. */
+function solid(o, s) {
+    if (s.kind === "table")
+        return el("path", { class: ft(o, "table", "ky-table"), d: box(s.rect) });
+    return el("circle", { class: ft(o, "net", "ky-nt-post"), cx: s.cx, cy: s.cy, r: s.r }) + el("circle", { class: ft(o, "net", "ky-set-net"), cx: s.cx, cy: s.cy, r: s.r * 0.84 });
+}
 /**
  * A net sport's court lying wide: the ground, the free zone, the court, its painted areas, its lines, the net with its posts (and, in volleyball, its antennae)
- * and, on a score, the place for the board. Every length that is a rulebook's figure comes from the league (leagues/courts.ts) through `courtGeometry`.
+ * and, on a score, the place for the board. Every length that is a rulebook's figure comes from the league (leagues/courts.ts) through `courtGeometry`. The courts of
+ * the sports added after the first five may also have walls, rings (circles and arcs), a table or a set, and no net.
  */
 export function netCourt(o, plan) {
     const geometry = courtGeometry(plan);
@@ -23,7 +49,10 @@ export function netCourt(o, plan) {
     const side = Math.max(zone?.side ?? 0, sideReach(geometry));
     const end = zone?.end ?? 0;
     const m = o.margin ?? L * 0.035;
-    const view0 = { x: -end - m, y: -side - m, w: L + 2 * (end + m), h: W + 2 * (side + m) };
+    // Walls and the like stand beyond the court's edges, and may make the ground wider on one side than on the other.
+    const beyond = bandReach(geometry);
+    const [left, right, top, bottom] = [Math.max(end, beyond.left), Math.max(end, beyond.right), Math.max(side, beyond.top), Math.max(side, beyond.bottom)];
+    const view0 = { x: -left - m, y: -top - m, w: L + left + right + 2 * m, h: W + top + bottom + 2 * m };
     // Lines are drawn a little thicker than painted, as the other surfaces' are, unless asked for the true widths: the thin dimension of a line is raised to a least.
     const least = o.exact ? 0 : L * 0.0026;
     const thick = (r) => {
@@ -39,12 +68,31 @@ export function netCourt(o, plan) {
     base += el("rect", { class: ft(o, "court", "ky-surface"), x: 0, y: 0, width: L, height: W });
     if (geometry.areas.length > 0)
         base += el("path", { class: ft(o, "areas", "ky-area"), d: geometry.areas.map(box).join("") });
+    for (const band of geometry.bands) {
+        const [feature, cls] = BAND[band.kind];
+        base += el("path", { class: ft(o, feature, cls), d: box(band.rect) });
+    }
     const lineRects = [...geometry.lines, ...(full ? geometry.small : [])].map(thick);
     let lines = el("path", { class: ft(o, "lines", "ky-fill-line"), d: lineRects.map(box).join("") });
-    // The net: a line across the court at its middle, from post to post; its posts and, in volleyball, the antennae at the side lines.
-    const nw = Math.max(L * 0.004, 0.02);
+    // Circles and arcs are lines too, drawn at least as thick as the others.
+    for (const ring of geometry.rings)
+        lines += ringMarkup(o, { ...ring, w: Math.max(ring.w, least) });
+    if (geometry.wallLines.length > 0)
+        lines += el("path", { class: ft(o, "wall-lines", "ky-wall-line"), d: geometry.wallLines.map(thick).map(box).join("") });
+    for (const s of geometry.solids)
+        lines += solid(o, s);
+    // The net: a line across the court at its middle, from post to post; its posts and, in volleyball, the antennae at the side lines. A court without a net has none.
     const net = geometry.net;
-    lines += el("rect", { class: ft(o, "net", "ky-nt-line"), x: net.x - nw / 2, y: net.y0, width: nw, height: net.y1 - net.y0 });
+    // Over a centre line (volleyball's, sepak takraw's) the net is drawn a little wider than the line, so that the line shows between its edges.
+    const under = geometry.underNet;
+    const nw = under === null ? Math.max(L * 0.004, 0.02) : Math.max(under, least) * 2.4;
+    if (net !== null)
+        lines += el("rect", { class: ft(o, "net", "ky-nt-line"), x: net.x - nw / 2, y: net.y0, width: nw, height: net.y1 - net.y0 });
+    // The centre line runs under the net (volleyball Rule 1.3.3): the net is drawn over it, so the line is drawn again over the net, in a narrower stroke, to show through.
+    if (net !== null && under !== null) {
+        const core = Math.max(under, least);
+        lines += el("rect", { class: ft(o, "lines", "ky-fill-line"), x: net.x - core / 2, y: 0, width: core, height: W });
+    }
     for (const post of geometry.posts)
         lines += mark(post, ft(o, "posts", "ky-nt-post"));
     if (full) {
@@ -54,22 +102,30 @@ export function netCourt(o, plan) {
             lines += mark(antenna, ft(o, "antennae", "ky-red-fill"));
     }
     // The teams' names are not painted on these courts: the board names the teams. The board lies over the net, between the lines it needs.
-    const turned = o.portrait;
-    const spot = turned ? { cx, cy, w: W * 0.88, h: L * 0.5 } : { cx, cy, w: L * 0.58, h: W * 0.66 };
+    // A roundnet court is square, with no sides: it lies the same wherever it is turned.
+    const turned = o.portrait && plan.sport !== "roundnet";
+    // The board lies over the net, between the lines it needs; on a roundnet court that is the set, so it lies on the ground below the circles.
+    const room = plan.sport === "roundnet" ? W / 2 - plan.figures.servingRadius : 0;
+    const clear = plan.sport === "roundnet" ? { cx, cy: cy + plan.figures.servingRadius + room / 2, w: L * 0.9, h: room * 0.9 } : undefined;
+    // Netball's board has no net to lie over: it lies in the centre third, and the teams' names are painted in the goal thirds.
+    const centred = plan.sport === "netball" ? (turned ? { cx, cy, w: W * 0.88, h: L * 0.36 } : { cx, cy, w: L * 0.4, h: W * 0.66 }) : undefined;
+    const spot = clear ?? centred ?? (turned ? { cx, cy, w: W * 0.88, h: L * 0.5 } : { cx, cy, w: L * 0.58, h: W * 0.66 });
+    const places = plan.sport === "netball" ? { left: { cx: L * 0.15, cy, w: L * 0.2, h: W * 0.4, rot: 0 }, right: { cx: L * 0.85, cy, w: L * 0.2, h: W * 0.4, rot: 0 } } : { left: { cx: L * 0.2, cy, w: L * 0.2, h: W * 0.4, rot: 0 }, right: { cx: L * 0.8, cy, w: L * 0.2, h: W * 0.4, rot: 0 } };
     const surface = {
         sport: plan.sport,
         view: view0,
         base,
         lines,
         defs: "",
-        left: { cx: L * 0.2, cy, w: L * 0.2, h: W * 0.4, rot: 0 },
-        right: { cx: L * 0.8, cy, w: L * 0.2, h: W * 0.4, rot: 0 },
+        left: places.left,
+        right: places.right,
         plate: spot,
         turned,
     };
     surface.box = { x: 0, y: 0, w: L, h: W };
     // One side of the net.
-    surface.ranges = { "half-court": atEnds((end) => (end === "left" ? edges(0, 0, net.x, W) : edges(net.x, 0, L, W))) };
+    const middle = net === null ? cx : net.x;
+    surface.ranges = { "half-court": atEnds((end) => (end === "left" ? edges(0, 0, middle, W) : edges(middle, 0, L, W))) };
     surface.lineRef = { width: plan.sport === "tabletennis" ? plan.figures.edgeLine : plan.figures.lineWidth, feet: 1 };
     if (o.landmarks === true)
         surface.marks = netMarks(plan, L, W);
@@ -116,11 +172,12 @@ function netMarks(plan, L, W) {
         case "badminton": {
             const f = plan.figures;
             return [
-                { id: "end-line", x: f.lineWidth / 2, y: W * 0.8, side: "bottom" },
+                // The back boundary line is the singles long service line too (Diagram A); the line inside it is the doubles long service line.
+                { id: "back-boundary-line", x: f.lineWidth / 2, y: W * 0.8, side: "bottom" },
                 { id: "sideline", x: L * 0.12, y: 0, side: "top" },
                 { id: "singles-sideline", x: L * 0.12, y: W - f.singlesInset, side: "bottom" },
-                { id: "long-service-line", x: f.doublesLongServiceInset + f.lineWidth / 2, y: W * 0.2, side: "top" },
-                { id: "short-service-line", x: cx - f.shortServiceLine - f.lineWidth / 2, y: W * 0.3, side: "top" },
+                { id: "doubles-long-service-line", x: f.doublesLongServiceInset + f.lineWidth / 2, y: W * 0.2, side: "top" },
+                { id: "short-service-line", x: cx - f.shortServiceLine - f.lineWidth / 2, y: W * 0.3, side: "bottom" },
                 { id: "centre-line", x: L * 0.2, y: cy, side: "bottom" },
                 net,
             ];
@@ -136,7 +193,7 @@ function netMarks(plan, L, W) {
                 net,
             ];
         }
-        default: {
+        case "tabletennis": {
             const f = plan.figures;
             return [
                 { id: "end-line", x: f.edgeLine / 2, y: W * 0.8, side: "bottom" },
@@ -147,5 +204,93 @@ function netMarks(plan, L, W) {
                 net,
             ];
         }
+        case "padel": {
+            const f = plan.figures;
+            return [
+                { id: "back-wall", x: 0, y: W * 0.8, side: "bottom" },
+                { id: "side-wall", x: f.enclosure.sideWall / 2, y: 0, side: "top" },
+                { id: "metal-fence", x: L * 0.3, y: W, side: "bottom" },
+                { id: "service-line", x: cx - f.serviceLine + f.lineWidth / 2, y: W * 0.25, side: "top" },
+                { id: "centre-service-line", x: cx - f.serviceLine / 2, y: cy, side: "bottom" },
+                net,
+            ];
+        }
+        case "squash": {
+            const f = plan.figures;
+            const near = L - f.shortLine;
+            return [
+                { id: "tin", x: -f.wall.tin / 2, y: W * 0.15, side: "top" },
+                { id: "wall-service-line", x: -f.wall.serviceLine - f.lineWidth / 2, y: W * 0.45, side: "bottom" },
+                { id: "front-wall-line", x: -f.wall.frontWallLine - f.lineWidth / 2, y: W * 0.15, side: "top" },
+                { id: "short-line", x: near - f.lineWidth / 2, y: W * 0.3, side: "top" },
+                { id: "squash-half-court-line", x: L - f.shortLine / 2, y: cy, side: "bottom" },
+                { id: "service-box", x: near + f.serviceBox / 2, y: f.serviceBox / 2, side: "top" },
+                { id: "back-wall", x: L, y: W * 0.7, side: "bottom" },
+            ];
+        }
+        case "racquetball": {
+            const f = plan.figures;
+            const back = L - f.shortLine;
+            const front = back - f.serviceLine;
+            return [
+                { id: "front-wall", x: 0, y: W * 0.3, side: "top" },
+                { id: "service-line", x: front + f.lineWidth / 2, y: W * 0.7, side: "bottom" },
+                { id: "service-zone", x: (front + back) / 2, y: cy, side: "top" },
+                { id: "service-box", x: (front + back) / 2, y: W - f.serviceBox / 2, side: "bottom" },
+                { id: "drive-serve-line", x: (front + back) / 2, y: f.driveServe - f.lineWidth / 2, side: "top" },
+                { id: "short-line", x: back - f.lineWidth / 2, y: W * 0.15, side: "top" },
+                { id: "safety-zone", x: back + f.receiving.behind / 2, y: cy, side: "bottom" },
+                { id: "receiving-line", x: back + f.receiving.behind - f.lineWidth / 2, y: W * 0.8, side: "bottom" },
+                { id: "back-wall", x: L, y: cy, side: "bottom" },
+            ];
+        }
+        case "sepaktakraw": {
+            const f = plan.figures;
+            const k = Math.SQRT1_2 * f.quarterCircle;
+            return [
+                { id: "back-line", x: f.lineWidth / 2, y: W * 0.8, side: "bottom" },
+                { id: "sideline", x: L * 0.12, y: 0, side: "top" },
+                { id: "centre-line", x: cx + f.centreLine, y: W * 0.8, side: "bottom" },
+                { id: "quarter-circle", x: cx - k, y: k, side: "top" },
+                { id: "service-circle", x: f.serviceCircle.fromBack, y: cy - f.serviceCircle.radius, side: "top" },
+                net,
+            ];
+        }
+        case "teqball": {
+            const f = plan.figures;
+            return [
+                { id: "court-surround", x: 0, y: W * 0.8, side: "bottom" },
+                { id: "halfway-line", x: cx, y: W * 0.15, side: "top" },
+                { id: "service-line", x: cx - f.serviceLine, y: W * 0.7, side: "bottom" },
+                { id: "service-line", x: cx + f.serviceLine, y: W * 0.3, side: "top" },
+                { id: "table", x: cx + f.table.length * 0.3, y: cy + f.table.width * 0.3, side: "bottom" },
+                { id: "court-net", x: cx, y: cy - f.net.width / 2, side: "top" },
+            ];
+        }
+        case "roundnet": {
+            const f = plan.figures;
+            const k = Math.SQRT1_2;
+            return [
+                { id: "roundnet-set", x: cx - f.set.diameter * 0.25, y: cy + f.set.diameter * 0.1, side: "bottom" },
+                { id: "no-hit-zone", x: cx + f.noHitRadius * k, y: cy - f.noHitRadius * k, side: "top" },
+                { id: "service-circle", x: cx - f.servingRadius * k, y: cy - f.servingRadius * k, side: "top" },
+                { id: "service-position", x: cx + f.servingRadius, y: cy, side: "bottom" },
+                { id: "service-position", x: cx - f.servingRadius, y: cy, side: "bottom" },
+                { id: "service-position", x: cx, y: cy - f.servingRadius, side: "top" },
+            ];
+        }
+        default: {
+            const f = plan.figures;
+            const k = Math.SQRT1_2 * f.goalCircle;
+            return [
+                { id: "goal-line", x: f.lineWidth / 2, y: W * 0.8, side: "bottom" },
+                { id: "sideline", x: L * 0.12, y: 0, side: "top" },
+                { id: "transverse-line", x: L / 3, y: 0, side: "top" },
+                { id: "centre-circle", x: cx + f.centreCircle / 2, y: cy, side: "bottom" },
+                { id: "goal-circle", x: k, y: cy - k, side: "top" },
+                { id: "goalpost", x: f.post.poleDiameter / 2, y: cy, side: "bottom" },
+                { id: "goal-ring", x: L - f.post.poleDiameter - f.post.ring.bar - f.post.ring.inside / 2, y: cy, side: "top" },
+            ];
+        }
     }
 }

package/dist/surfaces/polo.d.ts

@@ -0,0 +1,12 @@
+import type { PoloPlan } from "../pool.ts";
+import { type PoolCtx } from "../pool.kit.ts";
+import { type BuildOptions, type Surface } from "./surface.ts";
+/** The space behind each goal line where the goal's net hangs, in metres (CR 18.3.5): the pool is the field of play, 25 m between the goal lines (CR 18.1.2), and this behind each of them. */
+export declare const POLO_BEHIND: 0.3;
+/**
+ * A water polo field of play lying wide, from World Aquatics' rules: 25 by 20 m between the goal lines; lane ropes along both sides whose floats are white at the goal line and the half distance line, red to
+ * the 2 m mark, yellow from 2 to 6 m and green from 6 m to the half distance line, with a red mark at 5 m (CR 18.3.1 and Appendix 4, 20.4.1.5); the 2 m lines from the goal posts that make the goal areas
+ * (20.4.1.2); the goals, 3 m between the posts (18.3.3); the re-entry area 2.0 by 1.08 m in each corner on the side away from the official table (18.3.4); the referees' platforms 1 m wide along both sides, coloured
+ * as the ropes are (18.3.2); the official table and the area for flying substitutions on the side of the benches (18.1.8).
+ */
+export declare function waterPolo(o: BuildOptions, plan: PoloPlan, ctx?: PoolCtx): Surface;

package/dist/surfaces/polo.js

@@ -0,0 +1,159 @@
+import { el, num } from "../format.js";
+import { feet } from "../pool.js";
+import { box, deckMarkup, leastWidth, paintDefs, poolIds, ropeMarkup, waterMarkup } from "../pool.kit.js";
+import { WATER_POLO } from "../pool.figures.js";
+import { GUTTER } from "./pool.js";
+import { atEnds, edges, ft, quarterTurn } from "./surface.js";
+/** The space behind each goal line where the goal's net hangs, in metres (CR 18.3.5): the pool is the field of play, 25 m between the goal lines (CR 18.1.2), and this behind each of them. */
+export const POLO_BEHIND = WATER_POLO.goal.netClear;
+/**
+ * A water polo field of play lying wide, from World Aquatics' rules: 25 by 20 m between the goal lines; lane ropes along both sides whose floats are white at the goal line and the half distance line, red to
+ * the 2 m mark, yellow from 2 to 6 m and green from 6 m to the half distance line, with a red mark at 5 m (CR 18.3.1 and Appendix 4, 20.4.1.5); the 2 m lines from the goal posts that make the goal areas
+ * (20.4.1.2); the goals, 3 m between the posts (18.3.3); the re-entry area 2.0 by 1.08 m in each corner on the side away from the official table (18.3.4); the referees' platforms 1 m wide along both sides, coloured
+ * as the ropes are (18.3.2); the official table and the area for flying substitutions on the side of the benches (18.1.8).
+ */
+export function waterPolo(o, plan, ctx = {}) {
+    const Lp = plan.length;
+    const W = plan.width;
+    const b = POLO_BEHIND;
+    const ids = ctx.ids ?? poolIds(o.id);
+    const full = o.detail === "full";
+    const m = ctx.bare === true ? 0 : (o.margin ?? feet(WATER_POLO.deck));
+    const platform = WATER_POLO.platform.width;
+    const down = plan.table === "bottom";
+    // The goal lines stand 0.30 m in from the walls; the marks are measured from them.
+    const g0 = b;
+    const g1 = Lp - b;
+    const at = (d, from) => (from === "left" ? g0 + d : g1 - d);
+    const deckTop = GUTTER + platform;
+    const deckBottom = GUTTER + platform + (down ? WATER_POLO.table.depth + 0.6 : 0);
+    let base = box(o, "gutter", "ky-boards", -GUTTER, -GUTTER, Lp + GUTTER, W + GUTTER);
+    base += waterMarkup(o, ids, plan.look, 0, 0, Lp, W);
+    // The referees' platforms along both sides, in the colours of the ropes by distance from the goal line.
+    const bands = [
+        ["red", 0, WATER_POLO.twoMetre],
+        ["yellow", WATER_POLO.twoMetre, WATER_POLO.sixMetre],
+        ["green", WATER_POLO.sixMetre, WATER_POLO.half],
+    ];
+    let walk = "";
+    for (const [y0, y1] of [[-GUTTER - platform, -GUTTER], [W + GUTTER, W + GUTTER + platform]]) {
+        for (const [colour, a, z] of bands) {
+            for (const from of ["left", "right"]) {
+                const x0 = from === "left" ? at(a, "left") : at(z, "right");
+                const x1 = from === "left" ? at(z, "left") : at(a, "right");
+                walk += el("rect", { class: ft(o, "referee-platforms", `ky-pl-rp ky-pl-rp-${colour}`), x: feet(x0), y: feet(y0), width: feet(x1 - x0), height: feet(y1 - y0) });
+            }
+        }
+    }
+    base += walk;
+    let lines = "";
+    const thin = leastWidth(o, 0.06, 0.12);
+    // The lines across the field: the goal lines and the half distance line white, the 2 m line red, the 5 m line a dashed red one (a red mark at 5 m), the 6 m line yellow.
+    const across = (cls, colour, x, dash, w = thin) => el("path", { class: ft(o, cls, `ky-pl-wl ky-pl-wl-${colour}`), d: `M${num(feet(x))} 0V${num(feet(W))}`, "stroke-width": w, "stroke-dasharray": dash, fill: "none" });
+    lines += across("goal-lines", "white", g0, undefined, thin * 1.4) + across("goal-lines", "white", g1, undefined, thin * 1.4) + across("half-distance-line", "white", Lp / 2, undefined, thin * 1.4);
+    for (const from of ["left", "right"]) {
+        lines += across("two-metre-lines", "red", at(WATER_POLO.twoMetre, from));
+        lines += across("six-metre-lines", "yellow", at(WATER_POLO.sixMetre, from));
+        lines += across("five-metre-marks", "red", at(WATER_POLO.fiveMetre, from), `${num(feet(0.5))} ${num(feet(0.5))}`);
+    }
+    // The goal areas: red lines 2 m long from the outer faces of the goal posts (Appendix 4, 20.4.1.2).
+    const post = WATER_POLO.goal.post;
+    const half = WATER_POLO.goal.width / 2;
+    for (const from of ["left", "right"]) {
+        const x0 = at(0, from);
+        const x1 = at(WATER_POLO.goalAreaLine, from);
+        for (const side of [-1, 1]) {
+            const y = W / 2 + side * (half + post);
+            lines += el("path", { class: ft(o, "goal-area-lines", "ky-pl-wl ky-pl-wl-red"), d: `M${num(feet(x0))} ${num(feet(y))}H${num(feet(x1))}`, "stroke-width": thin, fill: "none" });
+        }
+    }
+    // The re-entry areas, 2.0 m along the goal line and 1.08 m into the field, in each corner on the side away from the table.
+    const away = down ? 0 : W;
+    const dirY = down ? 1 : -1;
+    for (const from of ["left", "right"]) {
+        const x0 = at(0, from);
+        const x1 = at(WATER_POLO.reEntry.depth, from);
+        const xa = Math.min(x0, x1);
+        const ya = Math.min(away, away + dirY * WATER_POLO.reEntry.length);
+        lines += el("rect", { class: ft(o, "re-entry-areas", "ky-pl-ra"), x: feet(xa), y: feet(ya), width: feet(Math.abs(x1 - x0)), height: feet(WATER_POLO.reEntry.length) });
+    }
+    // The lane ropes along the sides: white to the goal line, then red, yellow and green, with the red mark at 5 m, and white at the half distance line.
+    const runs = [];
+    const inset = 0.1;
+    for (const y of [inset, W - inset]) {
+        runs.push(["white", 0, g0, y], ["white", g1, Lp, y]);
+        for (const [colour, a, z] of bands) {
+            runs.push([colour, at(a, "left"), at(z, "left"), y]);
+            runs.push([colour, at(z, "right"), at(a, "right"), y]);
+        }
+        runs.push(["white", Lp / 2 - 0.45, Lp / 2 + 0.45, y]);
+        for (const from of ["left", "right"]) {
+            runs.push(["white", at(0, from) - 0.3, at(0, from) + 0.3, y]);
+            runs.push(["red", at(WATER_POLO.fiveMetre, from) - 0.3, at(WATER_POLO.fiveMetre, from) + 0.3, y]);
+        }
+    }
+    lines += ropeMarkup(o, runs, WATER_POLO.rope, 0.42);
+    // The goals: two posts and the crossbar between them on each goal line, white, with the net behind the line. The posts and the bar are drawn thicker than they stand, as the lines are.
+    const drawn = o.exact ? post : Math.max(post, 0.32);
+    for (const from of ["left", "right"]) {
+        const x = at(0, from);
+        const inward = from === "left" ? 1 : -1;
+        lines += el("path", { class: ft(o, "goals", "ky-pl-gn"), d: `M${num(feet(x))} ${num(feet(W / 2 - half))}h${num(feet(-inward * b))}v${num(feet(2 * half))}h${num(feet(inward * b))}`, "stroke-width": feet(0.09), fill: "none" });
+        lines += el("path", { class: ft(o, "goals", "ky-pl-gb"), d: `M${num(feet(x))} ${num(feet(W / 2 - half))}V${num(feet(W / 2 + half))}`, "stroke-width": feet(drawn) * 0.8, fill: "none" });
+        for (const side of [-1, 1]) {
+            const y = W / 2 + side * (half + post / 2);
+            lines += el("rect", { class: ft(o, "goal-posts", "ky-pl-gp"), x: feet(x - drawn / 2 - (inward * drawn) / 2 + (inward * drawn) / 2), y: feet(y - drawn / 2), width: feet(drawn), height: feet(drawn), rx: feet(drawn) * 0.12 });
+        }
+    }
+    // The official table and the flying substitution areas on the side of the benches.
+    if (down) {
+        const t = WATER_POLO.table;
+        base += el("rect", { class: ft(o, "official-table", "ky-pl-tb"), x: feet(Lp / 2 - t.length / 2), y: feet(W + GUTTER + platform + 0.5), width: feet(t.length), height: feet(t.depth), rx: feet(0.12) });
+    }
+    const sub = WATER_POLO.substitution;
+    if (full) {
+        const y0 = down ? W + GUTTER + platform : -GUTTER - platform - sub;
+        base += el("rect", { class: ft(o, "substitution-areas", "ky-pl-sa-l"), x: feet(g0), y: feet(y0), width: feet(Lp / 2 - g0), height: feet(sub) });
+        base += el("rect", { class: ft(o, "substitution-areas", "ky-pl-sa-r"), x: feet(Lp / 2), y: feet(y0), width: feet(g1 - Lp / 2), height: feet(sub) });
+    }
+    // The names of the parts, for a drawing that labels them.
+    const marks = [];
+    if (o.landmarks === true) {
+        marks.push({ id: "goal-line", x: feet(g0), y: 0, side: "top" }, { id: "two-metre-line", x: feet(at(WATER_POLO.twoMetre, "left")), y: feet(W), side: "bottom" }, { id: "five-metre-mark", x: feet(at(WATER_POLO.fiveMetre, "left")), y: 0, side: "top" }, { id: "six-metre-line", x: feet(at(WATER_POLO.sixMetre, "left")), y: feet(W), side: "bottom" }, { id: "half-distance-line", x: feet(Lp / 2), y: 0, side: "top" }, { id: "goal", x: feet(g1), y: feet(W / 2), side: "bottom" }, { id: "re-entry-area", x: feet(at(0.5, "right")), y: feet(down ? 0.5 : W - 0.5), side: down ? "top" : "bottom" }, { id: "referee-platform", x: feet(Lp * 0.3), y: feet(down ? W + GUTTER + platform / 2 : -GUTTER - platform / 2), side: down ? "bottom" : "top" });
+        if (down)
+            marks.push({ id: "official-table", x: feet(Lp / 2), y: feet(W + GUTTER + platform + 0.5 + WATER_POLO.table.depth), side: "bottom" });
+    }
+    const view0 = { x: -m, y: -feet(deckTop) - m, w: feet(Lp) + 2 * m, h: feet(W) + feet(deckTop + deckBottom) + 2 * m };
+    // The deck is under everything.
+    if (ctx.bare !== true)
+        base = deckMarkup(o, ids, plan.deck, view0.x, view0.y, view0.w, view0.h) + base;
+    const L = feet(Lp);
+    const Wf = feet(W);
+    const cy = Wf / 2;
+    const turned = o.portrait;
+    const surface = {
+        sport: "waterpolo",
+        view: view0,
+        base,
+        lines,
+        defs: ctx.bare === true ? "" : paintDefs(ids, plan.look, plan.deck, plan.seed),
+        left: { cx: -m / 2, cy, w: Wf, h: m, rot: -90 },
+        right: { cx: L + m / 2, cy, w: Wf, h: m, rot: 90 },
+        plate: turned ? { cx: L / 2, cy, w: Wf * 0.9, h: L * 0.3 } : { cx: L / 2, cy, w: L * 0.3, h: Wf * 0.5 },
+        turned,
+    };
+    surface.box = { x: 0, y: 0, w: L, h: Wf };
+    surface.lineRef = { width: thin, feet: 1 };
+    surface.ranges = {
+        half: atEnds((end) => (end === "left" ? edges(0, 0, L / 2, Wf) : edges(L / 2, 0, L, Wf))),
+        "goal-area": atEnds((end) => (end === "left" ? edges(0, 0, feet(g0 + WATER_POLO.twoMetre + 0.5), Wf) : edges(L - feet(Lp - g1 + WATER_POLO.twoMetre + 0.5), 0, L, Wf))),
+    };
+    if (o.landmarks === true)
+        surface.marks = marks;
+    if (turned) {
+        const t = quarterTurn(view0);
+        surface.view = t.view;
+        surface.turn = t.turn;
+    }
+    return surface;
+}

package/dist/surfaces/pool.d.ts

@@ -0,0 +1,27 @@
+import type { SwimPlan } from "../pool.ts";
+import { type PoolCtx, type PoolIds } from "../pool.kit.ts";
+import { type BuildOptions, type Mark, type Surface } from "./surface.ts";
+/** The swimming pool lying wide, before its deck and view: the water and the gutter, and the lines, ropes and fixtures over them, in feet from the pool's top left corner. */
+export interface SwimBody {
+    /** The gutter and the water. */
+    base: string;
+    /** The markings on the floor, the ropes and the fixtures. */
+    lines: string;
+    /** The labels of the parts to name, in feet. */
+    marks: Mark[];
+    /** Where the lane markings end: kept for the lineRef. */
+    line: number;
+}
+/** The gutter round the water, in metres: the width of the coping the pool is drawn with. */
+export declare const GUTTER = 0.4;
+/**
+ * The body of a swimming pool: every figure is the rules' (`SWIMMING`, pool.figures.ts). The lane markings on the floor are 46 m (21 m in a 25 m pool) long and end 2 m from the walls in a cross line 1 m long (CR 16.2.15); a
+ * cross line 0.5 m long at 15 m from each end; the touch panels 2.4 m wide at the walls with the target lines; the ropes in the rules' colours with red floats within 5 m of the walls and a mark at 15 m and 25 m;
+ * the starting blocks with their lane numbers; the backstroke flags 5 m from each end, and the false start rope 15 m from the starting end.
+ */
+export declare function swimBody(o: BuildOptions, plan: SwimPlan, ids: PoolIds): SwimBody;
+/**
+ * A swimming pool lying wide with its deck: the body, the deck round it in the colour or the tiles asked for, the data of a race at the walls and over the water, and a side section under the plan if
+ * it is asked for. The pool's water is the surface's `box`; the deck is the margin.
+ */
+export declare function swimming(o: BuildOptions, plan: SwimPlan, ctx?: PoolCtx): Surface;