@johnmorrisdotca/kyogijo-stadiums 0.4.0 → 0.6.0

package/dist/surfaces/dive.js

@@ -0,0 +1,128 @@
+import { el, num } from "../format.js";
+import { feet } from "../pool.js";
+import { box, deckMarkup, leastWidth, paintDefs, poolIds, waterMarkup } from "../pool.kit.js";
+import { DIVING, DIVING_LINES } from "../pool.figures.js";
+import { textWidth } from "../text.js";
+import { GUTTER } from "./pool.js";
+import { edges, ft, quarterTurn, textOn } from "./surface.js";
+/** The name a board goes by in the words of the landmarks. */
+const markId = (b) => (b.kind === "springboard" ? `springboard-${b.height}m` : `platform-${String(b.height).replace(".", "-")}m`);
+/**
+ * A diving well seen from above, from World Aquatics' rules (Part Four, Article 15 and Appendix 2): the pool wall the boards stand at on the left, the diving direction towards the right. Every springboard is 4.88 m
+ * long and 0.50 m wide with its front edge, the plummet, 2.22 m beyond the wall; each platform has the length and width of the table, its front edge 0.75 to 1.50 m beyond the wall (15.4.9); the boards stand the preferred
+ * distance (Appendix 2, B and C) from the side wall and from each other. The three lines across the well (15.6.3.1) are 21 m long, 2.5 m apart, the first under the plummet of the 3 m springboard.
+ */
+export function diving(o, plan, ctx = {}) {
+    const L = plan.length;
+    const W = plan.width;
+    const ids = ctx.ids ?? poolIds(o.id);
+    const full = o.detail === "full";
+    const m = ctx.bare === true ? 0 : (o.margin ?? feet(2.5));
+    // The stands, and the names of the springboards on the deck behind them, stand in the room behind the wall.
+    const behind = plan.behind + 4;
+    let base = box(o, "gutter", "ky-boards", -GUTTER, -GUTTER, L + GUTTER, W + GUTTER);
+    base += waterMarkup(o, ids, plan.look, 0, 0, L, W);
+    // The three lines across the well, under the plummet of the 3 m springboard and 2.5 m apart.
+    const three = plan.boards.find((b) => b.kind === "springboard" && b.height === 3);
+    const first = three?.x ?? DIVING.A.springboard3[1];
+    const lw = leastWidth(o, DIVING.lines.width, 0.32);
+    let lines = "";
+    let floor = "";
+    const y0 = (W - DIVING.lines.length) / 2;
+    for (let k = 0; k < DIVING_LINES; k += 1)
+        floor += `M${num(feet(first + k * DIVING.lines.apart))} ${num(feet(y0))}V${num(feet(y0 + DIVING.lines.length))}`;
+    lines += el("path", { class: ft(o, "lane-lines", "ky-line"), d: floor, "stroke-width": lw, fill: "none" });
+    // The stands behind the wall: one block under the platforms, a pedestal under each springboard.
+    const platforms = plan.boards.filter((b) => b.kind === "platform");
+    let stands = "";
+    if (platforms.length > 0) {
+        const ya = Math.min(...platforms.map((b) => b.y - b.width / 2)) - 0.5;
+        const yb = Math.max(...platforms.map((b) => b.y + b.width / 2)) + 0.5;
+        const xa = -Math.max(...platforms.map((b) => b.length - b.x)) - 0.4;
+        stands += el("rect", { class: ft(o, "stands", "ky-pl-sd"), x: feet(xa), y: feet(ya), width: feet(-xa), height: feet(yb - ya), rx: feet(0.2) });
+    }
+    const springboards = plan.boards.filter((one) => one.kind === "springboard");
+    const springStand = springboards.length === 0 ? 0 : Math.min(...springboards.map((b) => b.x - b.length)) - 0.4;
+    if (springboards.length > 0) {
+        const ya = Math.min(...springboards.map((b) => b.y)) - 1.1;
+        const yb = Math.max(...springboards.map((b) => b.y)) + 1.1;
+        stands += el("rect", { class: ft(o, "stands", "ky-pl-sd"), x: feet(springStand), y: feet(ya), width: feet(-springStand), height: feet(yb - ya), rx: feet(0.2) });
+    }
+    base += stands;
+    // The boards: a platform is a rectangle with its front edge over the water; a springboard is a bar reaching out from its stand. Tall ones over the low.
+    let boards = "";
+    let labels = "";
+    const size = feet(0.95);
+    const ordered = [...plan.boards].sort((a, b) => (a.kind === b.kind ? a.height - b.height : a.kind === "platform" ? -1 : 1));
+    for (const b of ordered) {
+        const x0 = b.x - b.length;
+        if (b.kind === "platform") {
+            boards += el("rect", { class: ft(o, "platforms", "ky-pl-pf"), x: feet(x0), y: feet(b.y - b.width / 2), width: feet(b.length), height: feet(b.width), rx: feet(0.1) });
+            if (full)
+                boards += el("path", { class: "ky-line ky-pl-fe", d: `M${num(feet(b.x))} ${num(feet(b.y - b.width / 2))}V${num(feet(b.y + b.width / 2))}`, "stroke-width": feet(0.12), fill: "none" });
+            // Turned back upright on a tall drawing, the word lies across the platform's width: it is made to fit.
+            const text = `${String(b.height)} m`;
+            const fit = o.portrait ? Math.min(size, (feet(b.width) * 0.9) / textWidth(text)) : size;
+            labels += textOn(o.portrait, feet(b.x - Math.min(2.2, b.length * 0.4)), feet(b.y) + fit * 0.36, text, { size: fit, anchor: "middle", cls: "ky-pl-bt", weight: 800 });
+        }
+        else {
+            boards += el("rect", { class: ft(o, "springboards", "ky-pl-spb"), x: feet(x0), y: feet(b.y - b.width / 2), width: feet(b.length), height: feet(b.width), rx: feet(0.12) });
+            // The name stands on the deck behind the springboards' stand, level with the board; turned upright on a tall drawing it is made to fit between two boards.
+            const word = `${b.height} m`;
+            const fit = o.portrait ? Math.min(size * 0.9, (feet(DIVING.C.springboard1[0]) * 0.92) / textWidth(word)) : size * 0.9;
+            labels += textOn(o.portrait, feet(springStand - 0.4), feet(b.y) + fit * 0.36, word, { size: fit, anchor: o.portrait ? "middle" : "end", cls: "ky-pl-bu", weight: 800 });
+        }
+        // The plummet: the vertical line through the middle of the front edge.
+        if (full)
+            boards += el("circle", { class: "ky-pl-pm", cx: feet(b.x), cy: feet(b.y), r: feet(0.14) });
+    }
+    lines += boards + labels;
+    const marks = [];
+    if (o.landmarks === true) {
+        const seen = new Set();
+        for (const b of plan.boards) {
+            const id = markId(b);
+            if (seen.has(id))
+                continue;
+            seen.add(id);
+            marks.push({ id, x: feet(b.x), y: feet(b.y - (b.kind === "platform" ? b.width / 2 : b.width)), side: "top" });
+        }
+        marks.push({ id: "diving-line", x: feet(first + DIVING.lines.apart), y: feet(y0 + DIVING.lines.length), side: "bottom" });
+    }
+    const view0 = { x: -feet(behind) - m, y: -m - feet(GUTTER), w: feet(L + behind) + 2 * m, h: feet(W) + 2 * m + 2 * feet(GUTTER) };
+    if (ctx.bare !== true)
+        base = deckMarkup(o, ids, plan.deck, view0.x, view0.y, view0.w, view0.h) + base;
+    const Lf = feet(L);
+    const Wf = feet(W);
+    const cy = Wf / 2;
+    const turned = o.portrait;
+    const surface = {
+        sport: "diving",
+        view: view0,
+        base,
+        lines,
+        defs: ctx.bare === true ? "" : paintDefs(ids, plan.look, plan.deck, plan.seed),
+        left: { cx: -feet(behind) - m / 2, cy, w: Wf, h: m, rot: -90 },
+        right: { cx: Lf + m / 2, cy, w: Wf, h: m, rot: 90 },
+        plate: turned ? { cx: Lf * 0.62, cy, w: Wf * 0.9, h: Lf * 0.3 } : { cx: Lf * 0.62, cy, w: Lf * 0.34, h: Wf * 0.5 },
+        turned,
+    };
+    surface.box = { x: 0, y: 0, w: Lf, h: Wf };
+    surface.lineRef = { width: lw, feet: 1 };
+    // Where the springboards stand and where the platforms: split between the last springboard and the first platform.
+    const sb = plan.boards.filter((b) => b.kind === "springboard");
+    const pf = plan.boards.filter((b) => b.kind === "platform");
+    const split = sb.length > 0 && pf.length > 0 ? (Math.max(...sb.map((b) => b.y)) + Math.min(...pf.map((b) => b.y - b.width / 2))) / 2 : W / 2;
+    surface.ranges = {
+        springboards: edges(0, 0, Lf * 0.55, feet(split)),
+        platforms: edges(0, feet(split), Lf * 0.55, 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/field.d.ts

@@ -1,8 +1,13 @@
-import type { FieldPlan } from "../fields.types.ts";
+import type { Area, FieldPlan, Shape } from "../fields.types.ts";
 import type { GoalStyle } from "../types.ts";
 import { type BuildOptions, type Surface } from "./surface.ts";
+/** The path of one shape that is drawn as a line, or of one filled bar. */
+export declare function pathOf(shape: Shape): string;
+export declare const areaD: (a: Area) => string;
 /** The painted lines of a plan: the shapes drawn with the line's paint, those alike in feature, width and dash put in one path. */
-export declare function strokes(plan: FieldPlan, o: Pick<BuildOptions, "exact" | "features">): string;
+export declare function strokes(plan: Pick<FieldPlan, "shapes" | "lineWidth" | "drawnLine">, o: Pick<BuildOptions, "exact" | "features">): string;
+/** The filled marks of a plan: the bars in one path to a feature, the dots one each. */
+export declare function marks(plan: Pick<FieldPlan, "shapes">, o: Pick<BuildOptions, "exact" | "features">): string;
 /**
  * A field sport's surface lying wide, from the sport's plan: the ground, the mown turf, the painted areas, the lines, the goals, and, on a score, the
  * ends painted in the teams' colours and the place for the board. The markings are the plan's, which are the rulebook's (leagues/*.ts).

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/football.js

@@ -93,6 +93,8 @@ export function football(spec, o, marks = { hashMarks: true, postShape: "slingsh
     if (numbered && spec.id === "cfl" && (yardsLong / 2) % 10 !== 0)
         positions.push({ x: e + (yardsLong / 2) * 3, label: spec.centre, pos: yardsLong / 2 });
     let numbers = "";
+    const arrows = [];
+    const numerals = [];
     for (const side of ["near", "far"]) {
         const y = side === "near" ? W - centreY : centreY;
         for (const p of positions) {
@@ -100,6 +102,9 @@ export function football(spec, o, marks = { hashMarks: true, postShape: "slingsh
             const centre = p.label === spec.centre || p.pos === yardsLong / 2;
             const digits = [...p.label];
             const flip = side === "far";
+            // The numeral's box in the wide frame: the digits stand along the field, or across it when the field is turned.
+            const spread = digits.length === 1 ? 3 : 5.9;
+            numerals.push([p.x, y, turned ? DIGIT_HEIGHT / 2 : spread, turned ? spread : DIGIT_HEIGHT / 2]);
             if (digits.length === 1)
                 numbers += textOn(turned, p.x, y + DIGIT_HEIGHT / 2, p.label, { size, anchor: "middle", cls: numCls, flip, weight: 700 });
             else {
@@ -118,6 +123,7 @@ export function football(spec, o, marks = { hashMarks: true, postShape: "slingsh
             if (full && !centre && Number(p.label) < 50) {
                 const ax = nearGoalLeft ? p.x - 8.4 : p.x + 8.4;
                 const dir = nearGoalLeft ? -1 : 1;
+                arrows.push([ax, y, 1.5, 1.6]);
                 numbers += el("path", { class: ft(o, "numbers", "ky-fill-line"), d: `M${num(ax + dir * 1.5)} ${num(y)}L${num(ax - dir * 1.5)} ${num(y - 1.6)}V${num(y + 1.6)}Z` });
             }
         }
@@ -169,6 +175,7 @@ export function football(spec, o, marks = { hashMarks: true, postShape: "slingsh
     };
     surface.lineRef = { width: lw, feet: 1 };
     surface.box = { x: 0, y: 0, w: L, h: W };
+    surface.anchors = { kind: "football", length: spec.length, endZone: e, width: W, arrows, numerals };
     // The red zone is the 20 yards before a goal line and the end zone behind it; the half is from an end line to midfield.
     const twenty = 60;
     const half = atEnds((end) => (end === "left" ? edges(0, 0, L / 2, W) : edges(L / 2, 0, L, W)));

package/dist/surfaces/hockey.js

@@ -15,8 +15,8 @@ export function boardsY(x, radius = NHL.cornerRadius) {
  * season (today's by default) marked it; with a `rink` (leagues.ts), that league's, in feet.
  */
 export function hockey(o, era, rink = NHL_RINK) {
-    // The NHL's rink has a history of its own (eras.ts); a league's, if it has one, is already in its `rink`.
-    const nhl = rink === NHL_RINK ? (era ?? rulesFor("nhl").rules) : undefined;
+    // The NHL's rink has a history of its own (eras.ts), and so has an arena's rink of another size (an `era` given with it); a league's, if it has one, is already in its `rink`.
+    const nhl = rink === NHL_RINK || era !== undefined ? (era ?? rulesFor("nhl").rules) : undefined;
     const { length: L, width: W, cornerRadius: r } = rink;
     const g = nhl?.goalLine ?? rink.goalLine;
     const blueLine = nhl?.blueLine ?? rink.blueLine;
@@ -128,6 +128,8 @@ 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;
+    surface.anchors = { kind: "hockey", length: L, width: W, blueLine, goalLine: g, cornerRadius: r, net: net_ };
     // 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 (Part Six 21.6.5 and 21.7.2.1: the goal at least 0.3 m deep, the lane rope 0.3 m behind the goal line): the pool is the field of play, 25 m between the goal lines (Part Six 20.2.2.1), 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 (Part Six 21.7.1 and 21.7.2); the 2 m lines from the goal posts that make the goal areas
+ * (Part Six 20.4 and 21.7.2.1.2); the goals, 3 m between the posts (21.6.3.2); the re-entry area 2.0 by 1.08 m in each corner on the side away from the official table (20.7); the referees' platforms 1 m wide along both sides, coloured
+ * as the ropes are (21.9.3); the official table (21.10) and the area for flying substitutions on the side of the benches (20.6).
+ */
+export declare function waterPolo(o: BuildOptions, plan: PoloPlan, ctx?: PoolCtx): Surface;