@johnmorrisdotca/kyogijo-stadiums 0.4.0 → 0.6.0

package/dist/court.d.ts

@@ -1,4 +1,5 @@
-import { type BadmintonFigures, type BadmintonLeague, type FreeZone, type NetSport, type PickleballFigures, type PickleballLeague, type TableTennisFigures, type TableTennisLeague, type TennisFigures, type TennisLeague, type VolleyballFigures, type VolleyballLeague } from "./leagues/courts.ts";
+import { type League } from "./leagues.ts";
+import { type BadmintonFigures, type BadmintonLeague, type FreeZone, type NetLeague, type NetSport, type NetballFigures, type NetballLeague, type PadelFigures, type PadelLeague, type PickleballFigures, type PickleballLeague, type RacquetballFigures, type RacquetballLeague, type RoundnetFigures, type RoundnetLeague, type SepakTakrawFigures, type SepakTakrawLeague, type SquashFigures, type SquashLeague, type TableTennisFigures, type TableTennisLeague, type TennisFigures, type TennisLeague, type TeqballFigures, type TeqballLeague, type VolleyballFigures, type VolleyballLeague } from "./leagues/courts.ts";
 import type { SurfaceOptions } from "./types.ts";
 /** A rectangle as `[x0, y0, x1, y1]`, in feet. */
 export type Rect = readonly [x0: number, y0: number, x1: number, y1: number];
@@ -16,10 +17,46 @@ export interface NetLine {
     y0: number;
     y1: number;
 }
+/**
+ * A line drawn as a circle or an arc of one: `r` is the outer radius (the rulebooks measure to the outside of a line), `w` the line's width and `a0` to `a1` the arc,
+ * in radians from the +x axis towards +y (down the page), the whole circle when they are missing.
+ */
+export interface Ring {
+    cx: number;
+    cy: number;
+    r: number;
+    w: number;
+    a0?: number;
+    a1?: number;
+}
+/**
+ * Something that stands round or beside the court, as a rectangle: a wall (solid), the metal fence between a padel court's walls (`mesh`), the front wall of a squash court
+ * laid out flat beside it (`face`) with its tin (`tin`).
+ */
+export interface Band {
+    rect: Rect;
+    kind: "wall" | "mesh" | "face" | "tin";
+}
+/** A solid object on the court: a teqball table (a rectangle) or a roundnet set (a disc). */
+export type Solid = {
+    kind: "table";
+    rect: Rect;
+} | {
+    kind: "set";
+    cx: number;
+    cy: number;
+    r: number;
+};
 /** The looks each sport has, the sport's default first. */
 export declare const LOOKS: Readonly<Record<NetSport, readonly string[]>>;
+/** How each sport's board counts: in sets, in games, or (netball) as one total, as any other score is drawn. */
+export declare const BOARD: Readonly<Record<NetSport, "sets" | "games" | "total">>;
 /** True for a sport whose court is one of these. */
 export declare const isNetSport: (sport: string) => sport is NetSport;
+/** True for a league of one of these courts. */
+export declare const isNetLeague: (league: League) => league is NetLeague;
+/** True for a sport whose score is a board of sets or games (all of these courts but netball's). */
+export declare const hasSetsBoard: (sport: string) => sport is NetSport;
 interface Common {
     /** The look: a name from `LOOKS`. */
     look: string;
@@ -51,6 +88,34 @@ export type CourtPlan = (Common & {
     sport: "tabletennis";
     league: TableTennisLeague;
     figures: TableTennisFigures;
+}) | (Common & {
+    sport: "padel";
+    league: PadelLeague;
+    figures: PadelFigures;
+}) | (Common & {
+    sport: "squash";
+    league: SquashLeague;
+    figures: SquashFigures;
+}) | (Common & {
+    sport: "racquetball";
+    league: RacquetballLeague;
+    figures: RacquetballFigures;
+}) | (Common & {
+    sport: "sepaktakraw";
+    league: SepakTakrawLeague;
+    figures: SepakTakrawFigures;
+}) | (Common & {
+    sport: "teqball";
+    league: TeqballLeague;
+    figures: TeqballFigures;
+}) | (Common & {
+    sport: "roundnet";
+    league: RoundnetLeague;
+    figures: RoundnetFigures;
+}) | (Common & {
+    sport: "netball";
+    league: NetballLeague;
+    figures: NetballFigures;
 });
 /**
  * The court the options ask for. A `league` picks the rulebook (the sport's own by default; `fivb-beach` for beach volleyball); `net.look` a named look, `net.free`
@@ -73,10 +138,21 @@ export interface CourtGeometry {
     areas: Rect[];
     /** Short lines outside the court (the attack line's extension, the service zone's limits), a part of `lines` that is drawn only in the full detail. */
     small: Rect[];
-    net: NetLine;
+    /** The net across the middle, or `null` for a court without one (squash, racquetball, roundnet's circle, netball). */
+    net: NetLine | null;
     posts: Fixture[];
     antennae: Fixture[];
     sticks: Fixture[];
+    /** Lines drawn as circles and arcs (sepak takraw, netball, roundnet). */
+    rings: Ring[];
+    /** Walls, fences and the like round or beside the court, outside its rectangle. */
+    bands: Band[];
+    /** A table or a set standing on the court. */
+    solids: Solid[];
+    /** Lines painted on a wall, laid flat beside the court (squash's front wall): they may be another colour than the floor's. */
+    wallLines: Rect[];
+    /** The width of a line that runs beneath the net from side to side (volleyball's and sepak takraw's centre line): it shows between the net's edges. */
+    underNet: number | null;
 }
 /**
  * Where everything stands, from the figures of the league in feet. A line's rectangle covers the line's width: the court's dimensions are to the outside edge of the
@@ -86,4 +162,11 @@ export interface CourtGeometry {
 export declare function courtGeometry(plan: CourtPlan): CourtGeometry;
 /** How far the court's fixtures reach beyond its side lines: the net's posts and the antennae's marks. */
 export declare function sideReach(geometry: CourtGeometry): number;
+/** How far the walls, fences and the like stand beyond each edge of the court's rectangle: nothing for a court without any. */
+export declare function bandReach(geometry: CourtGeometry): {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+};
 export {};

package/dist/court.js

@@ -1,9 +1,11 @@
 // What a net sport's court is for a set of options: the league's figures in feet, the look, the free zone, and the lines, areas and fixtures that follow from
-// them, as plain rectangles in the frame of a drawing lying wide (x along the court from the left end line, y across it from the top side line, both in feet).
+// them, as plain rectangles (and, for the circles of a few sports, rings) in the frame of a drawing lying wide (x along the court from the left end line, y across it from
+// the top side line, both in feet).
 // Kept apart from the drawing so that the outline, the description, the tests and the drawing agree. Every length that is a rulebook's figure is cited in
 // docs/sources.md; the sizes of the symbols (a post, an antenna, the net's line) are ours and are said to be.
 import { chooseLeague, netOf } from "./leagues.js";
-import { BADMINTON_LEAGUES, PICKLEBALL_LEAGUES, TABLE_TENNIS_LEAGUES, TENNIS_LEAGUES, VOLLEYBALL_LEAGUES } from "./leagues/courts.js";
+import { BADMINTON_LEAGUES, NETBALL_LEAGUES, PADEL_LEAGUES, PICKLEBALL_LEAGUES, RACQUETBALL_LEAGUES, ROUNDNET_LEAGUES, SEPAK_TAKRAW_LEAGUES, SQUASH_LEAGUES, TABLE_TENNIS_LEAGUES, TENNIS_LEAGUES, TEQBALL_LEAGUES, VOLLEYBALL_LEAGUES } from "./leagues/courts.js";
+import { netballGeometry, none, padelGeometry, racquetballGeometry, roundnetGeometry, sepakTakrawGeometry, squashGeometry, teqballGeometry } from "./court.more.js";
 import { convertLength } from "./units.js";
 /** The looks each sport has, the sport's default first. */
 export const LOOKS = Object.freeze({
@@ -12,9 +14,35 @@ export const LOOKS = Object.freeze({
     badminton: ["green", "blue", "wood"],
     pickleball: ["blue-green", "green", "red"],
     tabletennis: ["blue", "green"],
+    padel: ["blue", "green", "terracotta"],
+    squash: ["wood", "blue"],
+    racquetball: ["wood", "convertible"],
+    sepaktakraw: ["blue", "green", "wood"],
+    teqball: ["grey", "blue", "green"],
+    roundnet: ["grass", "sand", "indoor"],
+    netball: ["wood", "blue", "green"],
+});
+/** How each sport's board counts: in sets, in games, or (netball) as one total, as any other score is drawn. */
+export const BOARD = Object.freeze({
+    tennis: "sets",
+    volleyball: "sets",
+    badminton: "games",
+    pickleball: "games",
+    tabletennis: "games",
+    padel: "sets",
+    squash: "games",
+    racquetball: "games",
+    sepaktakraw: "sets",
+    teqball: "sets",
+    roundnet: "games",
+    netball: "total",
 });
 /** True for a sport whose court is one of these. */
-export const isNetSport = (sport) => sport === "tennis" || sport === "volleyball" || sport === "badminton" || sport === "pickleball" || sport === "tabletennis";
+export const isNetSport = (sport) => Object.prototype.hasOwnProperty.call(BOARD, sport);
+/** True for a league of one of these courts. */
+export const isNetLeague = (league) => isNetSport(league.family);
+/** True for a sport whose score is a board of sets or games (all of these courts but netball's). */
+export const hasSetsBoard = (sport) => isNetSport(sport) && BOARD[sport] !== "total";
 const FREE = ["official", "least", "none"];
 /**
  * The court the options ask for. A `league` picks the rulebook (the sport's own by default; `fivb-beach` for beach volleyball); `net.look` a named look, `net.free`
@@ -31,7 +59,8 @@ export function courtFor(o) {
     if (free === undefined)
         throw new Error(`Unknown free zone "${String(asked.free)}": use one of ${FREE.join(", ")}`);
     const beach = picked?.family === "volleyball" && picked.id === "fivb-beach";
-    const names = LOOKS[sport];
+    // World ParaVolley asks for a light indoor floor and white lines (Rule 1.2.2): of the volleyball looks only the wooden floor, and not the beach's sand.
+    const names = picked?.id === "wpv-sitting" ? LOOKS.volleyball.slice(0, 1) : LOOKS[sport];
     const look = asked.look === undefined ? (beach ? "sand" : names[0]) : asked.look;
     if (!names.includes(look))
         throw new Error(`Unknown look "${String(look)}" for ${sport}: use one of ${names.join(", ")}`);
@@ -58,10 +87,45 @@ export function courtFor(o) {
             const figures = netOf(league);
             return { ...common, sport, league, figures, zone: zoneOf(figures.free) };
         }
-        default: {
+        case "tabletennis": {
             const league = picked?.family === "tabletennis" ? picked : TABLE_TENNIS_LEAGUES[0];
             const figures = netOf(league);
-            return { ...common, sport: "tabletennis", league, figures, zone: zoneOf(figures.free) };
+            return { ...common, sport, league, figures, zone: zoneOf(figures.free) };
+        }
+        case "padel": {
+            const league = picked?.family === "padel" ? picked : PADEL_LEAGUES[0];
+            const figures = netOf(league);
+            return { ...common, sport, league, figures, zone: zoneOf(figures.free) };
+        }
+        case "squash": {
+            const league = picked?.family === "squash" ? picked : SQUASH_LEAGUES[0];
+            const figures = netOf(league);
+            return { ...common, sport, league, figures, zone: zoneOf(figures.free) };
+        }
+        case "racquetball": {
+            const league = picked?.family === "racquetball" ? picked : RACQUETBALL_LEAGUES[0];
+            const figures = netOf(league);
+            return { ...common, sport, league, figures, zone: zoneOf(figures.free) };
+        }
+        case "sepaktakraw": {
+            const league = picked?.family === "sepaktakraw" ? picked : SEPAK_TAKRAW_LEAGUES[0];
+            const figures = netOf(league);
+            return { ...common, sport, league, figures, zone: zoneOf(figures.free) };
+        }
+        case "teqball": {
+            const league = picked?.family === "teqball" ? picked : TEQBALL_LEAGUES[0];
+            const figures = netOf(league);
+            return { ...common, sport, league, figures, zone: zoneOf(figures.free) };
+        }
+        case "roundnet": {
+            const league = picked?.family === "roundnet" ? picked : ROUNDNET_LEAGUES[0];
+            const figures = netOf(league);
+            return { ...common, sport, league, figures, zone: zoneOf(figures.free) };
+        }
+        default: {
+            const league = picked?.family === "netball" ? picked : NETBALL_LEAGUES[0];
+            const figures = netOf(league);
+            return { ...common, sport: "netball", league, figures, zone: zoneOf(figures.free) };
         }
     }
 }
@@ -86,8 +150,22 @@ export function courtGeometry(plan) {
             return badmintonGeometry(plan.figures);
         case "pickleball":
             return pickleballGeometry(plan.figures);
-        default:
+        case "tabletennis":
             return tableGeometry(plan.figures);
+        case "padel":
+            return padelGeometry(plan.figures);
+        case "squash":
+            return squashGeometry(plan.figures);
+        case "racquetball":
+            return racquetballGeometry(plan.figures);
+        case "sepaktakraw":
+            return sepakTakrawGeometry(plan.figures);
+        case "teqball":
+            return teqballGeometry(plan.figures);
+        case "roundnet":
+            return roundnetGeometry(plan.figures);
+        default:
+            return netballGeometry(plan.figures);
     }
 }
 function tennisGeometry(f, sticks) {
@@ -120,6 +198,7 @@ function tennisGeometry(f, sticks) {
         posts: [{ x: cx, y: -out, size: f.net.postSize, shape: "square" }, { x: cx, y: W + out, size: f.net.postSize, shape: "square" }],
         antennae: [],
         sticks: sticks ? [{ x: cx, y: inset - f.net.sticksOutside, size: f.net.stickSize, shape: "square" }, { x: cx, y: W - inset + f.net.sticksOutside, size: f.net.stickSize, shape: "square" }] : [],
+        ...none(),
     };
 }
 function volleyballGeometry(f, free) {
@@ -165,6 +244,8 @@ function volleyballGeometry(f, free) {
         // An antenna is fixed at the outer edge of a side band, which stands directly over the side line: at the outer edge of the side line.
         antennae: [{ x: cx, y: 0, size: antenna, shape: "round" }, { x: cx, y: W, size: antenna, shape: "round" }],
         sticks: [],
+        ...none(),
+        underNet: f.attackLine === null ? null : w,
     };
 }
 function badmintonGeometry(f) {
@@ -194,6 +275,7 @@ function badmintonGeometry(f) {
         posts: [{ x: cx, y: w - post / 2, size: post, shape: "round" }, { x: cx, y: W - w + post / 2, size: post, shape: "round" }],
         antennae: [],
         sticks: [],
+        ...none(),
     };
 }
 function pickleballGeometry(f) {
@@ -219,6 +301,7 @@ function pickleballGeometry(f) {
         posts: [{ x: cx, y: -gap - d / 2, size: d, shape: "round" }, { x: cx, y: W + gap + d / 2, size: d, shape: "round" }],
         antennae: [],
         sticks: [],
+        ...none(),
     };
 }
 function tableGeometry(f) {
@@ -237,6 +320,7 @@ function tableGeometry(f) {
         posts: [{ x: cx, y: -out + post / 2, size: post, shape: "square" }, { x: cx, y: W + out - post / 2, size: post, shape: "square" }],
         antennae: [],
         sticks: [],
+        ...none(),
     };
 }
 /** How far the court's fixtures reach beyond its side lines: the net's posts and the antennae's marks. */
@@ -246,3 +330,14 @@ export function sideReach(geometry) {
         reach = Math.max(reach, -(post.y - post.size / 2), post.y + post.size / 2 - geometry.width);
     return reach;
 }
+/** How far the walls, fences and the like stand beyond each edge of the court's rectangle: nothing for a court without any. */
+export function bandReach(geometry) {
+    const reach = { left: 0, right: 0, top: 0, bottom: 0 };
+    for (const { rect } of geometry.bands) {
+        reach.left = Math.max(reach.left, -rect[0]);
+        reach.right = Math.max(reach.right, rect[2] - geometry.length);
+        reach.top = Math.max(reach.top, -rect[1]);
+        reach.bottom = Math.max(reach.bottom, rect[3] - geometry.width);
+    }
+    return reach;
+}

package/dist/court.more.d.ts

@@ -0,0 +1,46 @@
+import type { CourtGeometry } from "./court.ts";
+import type { NetballFigures, PadelFigures, RacquetballFigures, RoundnetFigures, SepakTakrawFigures, SquashFigures, TeqballFigures } from "./leagues/courts.ts";
+/** The empty parts of a geometry, which each court fills in as it needs. */
+export declare const none: () => Pick<CourtGeometry, "rings" | "bands" | "solids" | "wallLines" | "underNet">;
+/**
+ * A padel court: no lines round it (its walls are its limits), a service line each side of the net, 6.95 m from it to the outside edge (the Rules give no edge: ours, as the
+ * other rulebooks measure to the outside of a line), and the central service line from one service line to the other under the net, extending beyond each by the Rules' 20 cm. The
+ * enclosure is drawn outside the court: the end walls and, at each end of each side, a wall 4 m long, with metal fence between (Ends and Sides).
+ */
+export declare function padelGeometry(f: PadelFigures): CourtGeometry;
+/**
+ * A squash court, the front wall at the left. Floor: the short line (its nearest edge 4.26 m from the back wall, across the whole width), the half court line from the back wall to
+ * it, and in each back corner a service box, a square of 1.60 m inside its lines (5.05.03). The front wall is laid out flat beside the court, as if hinged on its foot: its tin (the
+ * upper 50 mm of it a line), the service line (the lower edge 1.78 m up) and the front wall line (4.57 m up), each across its width. The other walls stand round the court.
+ */
+export declare function squashGeometry(f: SquashFigures): CourtGeometry;
+/**
+ * A racquetball court, the front wall at the left. The short line's back edge is 20 ft from the back wall, the service line's front edge 5 ft in front of it, a service box's line
+ * and a drive serve line at 18 in and 3 ft from each side wall (to the edge nearest the centre) across the service zone, and the receiving line, broken, with its back edge 5 ft
+ * behind the short line's: an end segment of 21 in at each wall and sixteen 6 in segments with 6 in spaces between. The walls stand round the court.
+ */
+export declare function racquetballGeometry(f: RacquetballFigures): CourtGeometry;
+/**
+ * A sepak takraw court: the boundary lines drawn inwards, the centre line across the middle under the net, a quarter circle of 0.9 m radius at each end of the centre line (four, each
+ * inside the court on its side of the net), and a service circle of 0.3 m radius on each side of the net, its centre 2.45 m from the back line on the middle of the width. The radius
+ * is taken to the outside of the circle's line (the Law gives none: ours). The posts stand 0.3 m outside the sidelines, in line with the centre line.
+ */
+export declare function sepakTakrawGeometry(f: SepakTakrawFigures): CourtGeometry;
+/**
+ * A teqball court: the table (3 m by 1.5 m) in the exact middle, its net across the middle of its length and parallel to the shorter sides, the halfway line under it across the whole
+ * width, and a service line each side 3.5 m from the middle of the table. The line widths are the greatest of the 20 to 50 mm; the Rules give no edge for the service line, so its
+ * axis is taken to be 3.5 m from the middle (ours). The court's surrounds stand round it, outside.
+ */
+export declare function teqballGeometry(f: TeqballFigures): CourtGeometry;
+/**
+ * A roundnet court: the recommended 10 by 10 m of ground (there are no out of bounds), the set (91.4 cm across) at its centre, the no hit zone line (a circle of 0.9 m) and the serving
+ * line (a circle of 2.6 m) round it, and a mark across the serving line at each of the four service positions, 90 degrees apart, along the court's axes. The rules give no widths for
+ * the lines or the marks: ours.
+ */
+export declare function roundnetGeometry(f: RoundnetFigures): CourtGeometry;
+/**
+ * A netball court: the boundary lines drawn inwards, the two transverse lines that divide it into thirds (each line common to the two areas it bounds, so its axis is on the third),
+ * the centre circle (0.9 m across), the goal circles (semicircles of 4.9 m radius centred on the middle of the outside of each goal line) and the goalposts. The radii are taken to the
+ * outside of the lines; the pole is drawn at its greatest, 100 mm, with its back at the outer edge of the goal line, and the ring of each goal is seen from above.
+ */
+export declare function netballGeometry(f: NetballFigures): CourtGeometry;

package/dist/court.more.js

@@ -0,0 +1,219 @@
+import { convertLength } from "./units.js";
+const feet = (metres) => convertLength(metres, "m", "ft");
+/** The empty parts of a geometry, which each court fills in as it needs. */
+export const none = () => ({ rings: [], bands: [], solids: [], wallLines: [], underNet: null });
+/** The four edges of a court's boundary lines, drawn inside its dimensions: each line's width inwards. */
+const boundary = (L, W, w) => [[0, 0, w, W], [L - w, 0, L, W], [0, 0, L, w], [0, W - w, L, W]];
+/** Walls (or surrounds) of a thickness all round the outside of a court, but for the sides named in `omit`, in one piece each, corners included. */
+function walls(L, W, t, omit = []) {
+    const out = [{ rect: [0, -t, L, 0], kind: "wall" }, { rect: [0, W, L, W + t], kind: "wall" }];
+    if (!omit.includes("left"))
+        out.push({ rect: [-t, -t, 0, W + t], kind: "wall" });
+    if (!omit.includes("right"))
+        out.push({ rect: [L, -t, L + t, W + t], kind: "wall" });
+    return out;
+}
+/**
+ * A padel court: no lines round it (its walls are its limits), a service line each side of the net, 6.95 m from it to the outside edge (the Rules give no edge: ours, as the
+ * other rulebooks measure to the outside of a line), and the central service line from one service line to the other under the net, extending beyond each by the Rules' 20 cm. The
+ * enclosure is drawn outside the court: the end walls and, at each end of each side, a wall 4 m long, with metal fence between (Ends and Sides).
+ */
+export function padelGeometry(f) {
+    const { length: L, width: W, lineWidth: w, serviceLine: S, centreOverrun: ov } = f;
+    const cx = L / 2;
+    const cy = W / 2;
+    const t = feet(0.15);
+    const side = f.enclosure.sideWall;
+    const bands = [{ rect: [-t, -t, 0, W + t], kind: "wall" }, { rect: [L, -t, L + t, W + t], kind: "wall" }];
+    for (const [y0, y1] of [[-t, 0], [W, W + t]]) {
+        bands.push({ rect: [0, y0, side, y1], kind: "wall" }, { rect: [side, y0, L - side, y1], kind: "mesh" }, { rect: [L - side, y0, L, y1], kind: "wall" });
+    }
+    const post = feet(0.1);
+    return {
+        length: L,
+        width: W,
+        lines: [[cx - S, 0, cx - S + w, W], [cx + S - w, 0, cx + S, W], [cx - S - ov, cy - w / 2, cx + S + ov, cy + w / 2]],
+        areas: [],
+        small: [],
+        // The net runs from side to side, 10 m: the outer side of each post is the court's lateral limit.
+        net: { x: cx, y0: 0, y1: W },
+        posts: [{ x: cx, y: post / 2, size: post, shape: "square" }, { x: cx, y: W - post / 2, size: post, shape: "square" }],
+        antennae: [],
+        sticks: [],
+        ...none(),
+        bands,
+    };
+}
+/**
+ * A squash court, the front wall at the left. Floor: the short line (its nearest edge 4.26 m from the back wall, across the whole width), the half court line from the back wall to
+ * it, and in each back corner a service box, a square of 1.60 m inside its lines (5.05.03). The front wall is laid out flat beside the court, as if hinged on its foot: its tin (the
+ * upper 50 mm of it a line), the service line (the lower edge 1.78 m up) and the front wall line (4.57 m up), each across its width. The other walls stand round the court.
+ */
+export function squashGeometry(f) {
+    const { length: L, width: W, lineWidth: w, shortLine: sl, serviceBox: sb, wall } = f;
+    const cy = W / 2;
+    const t = feet(0.15);
+    const near = L - sl;
+    const lines = [
+        // The short line: its nearest edge to the back wall is `sl` from it, so it lies in front of that edge.
+        [near - w, 0, near, W],
+        // The half court line, from the back wall to the short line.
+        [near - w, cy - w / 2, L, cy + w / 2],
+    ];
+    for (const top of [true, false]) {
+        // A service box: inside 1.60 m by 1.60 m behind the short line, bounded by the short line, the side wall, and a line across the back and one along the side.
+        lines.push(top ? [near + sb, 0, near + sb + w, sb + w] : [near + sb, W - sb - w, near + sb + w, W]);
+        lines.push(top ? [near, sb, near + sb + w, sb + w] : [near, W - sb - w, near + sb + w, W - sb]);
+    }
+    // The front wall laid flat beside the court: distances to the left of the wall are heights up it. Each line's lower edge is at its height, and it is 50 mm tall.
+    const high = wall.frontWallLine + w;
+    const wallLines = [[-(wall.serviceLine + w), 0, -wall.serviceLine, W], [-(wall.frontWallLine + w), 0, -wall.frontWallLine, W], [-wall.tin, 0, -(wall.tin - w), W]];
+    const bands = [{ rect: [-high, 0, 0, W], kind: "face" }, { rect: [-wall.tin, 0, 0, W], kind: "tin" }, ...walls(L, W, t, ["left"])];
+    return { length: L, width: W, lines, areas: [], small: [], net: null, posts: [], antennae: [], sticks: [], ...none(), bands, wallLines };
+}
+/**
+ * A racquetball court, the front wall at the left. The short line's back edge is 20 ft from the back wall, the service line's front edge 5 ft in front of it, a service box's line
+ * and a drive serve line at 18 in and 3 ft from each side wall (to the edge nearest the centre) across the service zone, and the receiving line, broken, with its back edge 5 ft
+ * behind the short line's: an end segment of 21 in at each wall and sixteen 6 in segments with 6 in spaces between. The walls stand round the court.
+ */
+export function racquetballGeometry(f) {
+    const { length: L, width: W, lineWidth: w, serviceBox: sb, driveServe: ds } = f;
+    const t = 0.5;
+    const back = L - f.shortLine;
+    const front = back - f.serviceLine;
+    const lines = [
+        [back - w, 0, back, W],
+        [front, 0, front + w, W],
+        // The service boxes' lines, from one line of the zone to the other, and the drive serve lines.
+        [front, sb - w, back, sb], [front, W - sb, back, W - sb + w],
+        [front, ds - w, back, ds], [front, W - ds, back, W - ds + w],
+    ];
+    // The receiving line: its back edge `behind` behind the short line's back edge.
+    const rear = back + f.receiving.behind;
+    const { end, dash, gap } = f.receiving;
+    lines.push([rear - w, 0, rear, end], [rear - w, W - end, rear, W]);
+    for (let y = end + gap; y + dash <= W - end - gap + 1e-9; y += dash + gap)
+        lines.push([rear - w, y, rear, y + dash]);
+    return { length: L, width: W, lines, areas: [], small: [], net: null, posts: [], antennae: [], sticks: [], ...none(), bands: walls(L, W, t) };
+}
+/**
+ * A sepak takraw court: the boundary lines drawn inwards, the centre line across the middle under the net, a quarter circle of 0.9 m radius at each end of the centre line (four, each
+ * inside the court on its side of the net), and a service circle of 0.3 m radius on each side of the net, its centre 2.45 m from the back line on the middle of the width. The radius
+ * is taken to the outside of the circle's line (the Law gives none: ours). The posts stand 0.3 m outside the sidelines, in line with the centre line.
+ */
+export function sepakTakrawGeometry(f) {
+    const { length: L, width: W, lineWidth: w, centreLine: c, quarterCircle: q, serviceCircle: s } = f;
+    const cx = L / 2;
+    const cy = W / 2;
+    const half = Math.PI / 2;
+    const rings = [
+        { cx, cy: 0, r: q, w, a0: half, a1: 2 * half },
+        { cx, cy: 0, r: q, w, a0: 0, a1: half },
+        { cx, cy: W, r: q, w, a0: 2 * half, a1: 3 * half },
+        { cx, cy: W, r: q, w, a0: 3 * half, a1: 4 * half },
+        { cx: s.fromBack, cy, r: s.radius, w },
+        { cx: L - s.fromBack, cy, r: s.radius, w },
+    ];
+    const out = f.net.postsOutside;
+    const post = Math.max(2 * f.net.postRadius, L * 0.006);
+    return {
+        length: L,
+        width: W,
+        lines: [...boundary(L, W, w), [cx - c / 2, 0, cx + c / 2, W]],
+        areas: [],
+        small: [],
+        net: { x: cx, y0: -out, y1: W + out },
+        posts: [{ x: cx, y: -out, size: post, shape: "round" }, { x: cx, y: W + out, size: post, shape: "round" }],
+        antennae: [],
+        sticks: [],
+        ...none(),
+        rings,
+        underNet: c,
+    };
+}
+/**
+ * A teqball court: the table (3 m by 1.5 m) in the exact middle, its net across the middle of its length and parallel to the shorter sides, the halfway line under it across the whole
+ * width, and a service line each side 3.5 m from the middle of the table. The line widths are the greatest of the 20 to 50 mm; the Rules give no edge for the service line, so its
+ * axis is taken to be 3.5 m from the middle (ours). The court's surrounds stand round it, outside.
+ */
+export function teqballGeometry(f) {
+    const { length: L, width: W, lineWidth: w, serviceLine: S } = f;
+    const cx = L / 2;
+    const cy = W / 2;
+    const { table, net } = f;
+    return {
+        length: L,
+        width: W,
+        lines: [[cx - w / 2, 0, cx + w / 2, W], [cx - S - w / 2, 0, cx - S + w / 2, W], [cx + S - w / 2, 0, cx + S + w / 2, W]],
+        areas: [],
+        small: [],
+        net: { x: cx, y0: cy - net.width / 2, y1: cy + net.width / 2 },
+        posts: [],
+        antennae: [],
+        sticks: [],
+        ...none(),
+        bands: walls(L, W, feet(0.1)),
+        solids: [{ kind: "table", rect: [cx - table.length / 2, cy - table.width / 2, cx + table.length / 2, cy + table.width / 2] }],
+    };
+}
+/**
+ * A roundnet court: the recommended 10 by 10 m of ground (there are no out of bounds), the set (91.4 cm across) at its centre, the no hit zone line (a circle of 0.9 m) and the serving
+ * line (a circle of 2.6 m) round it, and a mark across the serving line at each of the four service positions, 90 degrees apart, along the court's axes. The rules give no widths for
+ * the lines or the marks: ours.
+ */
+export function roundnetGeometry(f) {
+    const { length: L, width: W, lineWidth: w, servingRadius: R, noHitRadius: n } = f;
+    const cx = L / 2;
+    const cy = W / 2;
+    const tick = feet(0.4);
+    return {
+        length: L,
+        width: W,
+        lines: [
+            [cx + R - tick / 2, cy - w / 2, cx + R + tick / 2, cy + w / 2], [cx - R - tick / 2, cy - w / 2, cx - R + tick / 2, cy + w / 2],
+            [cx - w / 2, cy + R - tick / 2, cx + w / 2, cy + R + tick / 2], [cx - w / 2, cy - R - tick / 2, cx + w / 2, cy - R + tick / 2],
+        ],
+        areas: [],
+        small: [],
+        net: null,
+        posts: [],
+        antennae: [],
+        sticks: [],
+        ...none(),
+        rings: [{ cx, cy, r: n, w }, { cx, cy, r: R, w }],
+        solids: [{ kind: "set", cx, cy, r: f.set.diameter / 2 }],
+    };
+}
+/**
+ * A netball court: the boundary lines drawn inwards, the two transverse lines that divide it into thirds (each line common to the two areas it bounds, so its axis is on the third),
+ * the centre circle (0.9 m across), the goal circles (semicircles of 4.9 m radius centred on the middle of the outside of each goal line) and the goalposts. The radii are taken to the
+ * outside of the lines; the pole is drawn at its greatest, 100 mm, with its back at the outer edge of the goal line, and the ring of each goal is seen from above.
+ */
+export function netballGeometry(f) {
+    const { length: L, width: W, lineWidth: w } = f;
+    const cy = W / 2;
+    const half = Math.PI / 2;
+    const d = f.post.poleDiameter;
+    // The goal ring hangs on a bar that projects from the front of the pole: its nearest edge is a bar's length from the pole, and it is drawn at its rod's width.
+    const { inside, rod, bar } = f.post.ring;
+    const hoop = (x) => ({ cx: x, cy, r: inside / 2 + rod, w: rod });
+    return {
+        length: L,
+        width: W,
+        lines: [...boundary(L, W, w), [L / 3 - w / 2, 0, L / 3 + w / 2, W], [(2 * L) / 3 - w / 2, 0, (2 * L) / 3 + w / 2, W]],
+        areas: [],
+        small: [],
+        net: null,
+        posts: [{ x: d / 2, y: cy, size: d, shape: "round" }, { x: L - d / 2, y: cy, size: d, shape: "round" }],
+        antennae: [],
+        sticks: [],
+        ...none(),
+        rings: [
+            { cx: L / 2, cy, r: f.centreCircle / 2, w },
+            { cx: 0, cy, r: f.goalCircle, w, a0: -half, a1: half },
+            { cx: L, cy, r: f.goalCircle, w, a0: half, a1: 3 * half },
+            hoop(d + bar + inside / 2 + rod),
+            hoop(L - d - bar - inside / 2 - rod),
+        ],
+    };
+}

package/dist/courts.style.d.ts

@@ -1,11 +1,23 @@
 import type { NetSport } from "./leagues/courts.ts";
-/** The colours of a look: the court, the free zone round it, the ground round that, a painted area on the court, and the lines. A look may leave the area and the lines to the theme. */
+/**
+ * The colours of a look: the court, the free zone round it, the ground round that, a painted area on the court, and the lines. A look may leave the area and the lines to the
+ * theme. The walls of a padel, squash or racquetball court and the surrounds of a teqball court, a padel court's fence (`mesh`), a squash court's front wall laid flat
+ * (`face`, with its `tin`), a teqball table and a roundnet set's net are for the sports that have them.
+ */
 interface Look {
     surface: string;
     free: string;
     apron: string;
     area?: string;
     line?: string;
+    /** The lines on a squash court's front wall, which the specification lets differ from the floor's (clause 10.13). */
+    wallLine?: string;
+    wall?: string;
+    mesh?: string;
+    face?: string;
+    tin?: string;
+    table?: string;
+    setnet?: string;
 }
 interface Pair {
     light: Look;
@@ -13,7 +25,7 @@ interface Pair {
 }
 /** The looks of every sport, each in light and dark. */
 export declare const COURT_LOOKS: Readonly<Record<NetSport, Readonly<Record<string, Pair>>>>;
-/** The rules of a drawing of this sport in this look: the shared rules and the look's colours. */
+/** The rules of a drawing of this sport in this look: the shared rules, the rules of the fixtures its sport has, and the look's colours. */
 export declare function courtStyle(sport: NetSport, look: string): string;
 /** Every net sport's rules and every look, for a page that draws with `style: "none"` and supplies the stylesheet itself. */
 export declare const KYOGIJO_COURTS_STYLE: string;