@johnmorrisdotca/kyogijo-stadiums 0.4.0 → 0.6.0

package/dist/crowd.js

@@ -0,0 +1,480 @@
+// The stands round a surface and the crowd in them (`crowd`): where the seating bowls stand, as data (rings with their outlines, heights and rake, the places that are left
+// open for tunnels and benches, the blocks of visitors and of a card display), before any of it is drawn (crowd.draw.ts). Written for this package: each sport has a plain
+// profile of the distances a venue of its kind keeps between the surface and its first row and how deep its tiers are; they are conventions for a drawing, not a rulebook's
+// figures (no rulebook gives them), except the footprint of the gridiron a soccer pitch can stand inside, which is the field's own.
+import { FOOTBALL } from "./geometry.js";
+const finite = (v) => typeof v === "number" && Number.isFinite(v);
+const clamp = (v, lo, hi) => Math.min(hi, Math.max(lo, v));
+/** The crowd the options ask for, or `undefined` for none. */
+export function resolveCrowd(value) {
+    if (value === undefined || value === false)
+        return undefined;
+    const o = value === true ? {} : value;
+    const shapes = ["bowl", "sides", "horseshoe", "grandstand"];
+    const awayEnds = ["auto", "left", "right", "corner", "none"];
+    return {
+        shape: shapes.includes(o.shape) ? o.shape : undefined,
+        open: o.open === "left" ? "left" : "right",
+        stadium: o.stadium === "purpose" || o.stadium === "nfl" || o.stadium === "cfl" ? o.stadium : "auto",
+        density: finite(o.density) ? clamp(o.density, 0, 1) : undefined,
+        attendance: finite(o.attendance) && o.attendance >= 0 ? o.attendance : undefined,
+        capacity: finite(o.capacity) && o.capacity > 0 ? o.capacity : undefined,
+        seed: finite(o.seed) ? Math.trunc(o.seed) : 1,
+        home: typeof o.home === "string" ? o.home : undefined,
+        away: typeof o.away === "string" ? o.away : undefined,
+        awayEnd: awayEnds.includes(o.awayEnd) ? o.awayEnd : "auto",
+        tifo: o.tifo === true ? "home" : o.tifo === "home" || o.tifo === "away" || o.tifo === "both" ? o.tifo : undefined,
+        tifoDesign: o.tifoDesign === "checks" ? "checks" : "stripes",
+        gaps: o.gaps !== false,
+        roof: o.roof !== false,
+        wallSeats: typeof o.wallSeats === "boolean" ? o.wallSeats : undefined,
+        detail: o.detail === "fine" || o.detail === "plain" ? o.detail : "auto",
+    };
+}
+/** How full the stands are: a density, else attendance over capacity (the ground's, else the model's seats), else 0.85. */
+export function densityOf(crowd, seats, groundCapacity) {
+    if (crowd.density !== undefined)
+        return crowd.density;
+    if (crowd.attendance !== undefined)
+        return clamp(crowd.attendance / (crowd.capacity ?? groundCapacity ?? seats), 0, 1);
+    return 0.85;
+}
+/** A small, fast generator (mulberry32): the same seed gives the same numbers on every machine. */
+export function generator(seed) {
+    let a = seed >>> 0;
+    return () => {
+        a = (a + 0x6d2b79f5) >>> 0;
+        let t = a;
+        t = Math.imul(t ^ (t >>> 15), t | 1);
+        t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}
+const lower = (to, h0 = 5, h1 = 45) => ({ id: "lower", from: 0, to, height: [h0, h1], fill: 1 });
+const upper = (from, to, h0 = 62, h1 = 118) => ({ id: "upper", from, to, height: [h0, h1], fill: 0.88 });
+const courtside = (to = 7) => ({ id: "courtside", from: 0, to, height: [1, 4], fill: 1 });
+/** The venues, by sport, in feet. */
+const PROFILES = {
+    nfl: { shape: "bowl", side: 40, end: 26, bench: 0, corner: 60, tiers: [lower(85), upper(92, 165)], away: "end" },
+    cfl: { shape: "bowl", side: 42, end: 28, bench: 0, corner: 60, tiers: [lower(85), upper(92, 165)], away: "end" },
+    ifaf: { shape: "bowl", side: 40, end: 26, bench: 0, corner: 55, tiers: [lower(75), upper(82, 144)], away: "end" },
+    soccer: { shape: "bowl", side: 19.7, end: 27.9, bench: 8, corner: 40, tiers: [lower(75), upper(82, 144)], away: "end" },
+    nhl: { shape: "bowl", side: 8, end: 8, bench: 6, corner: 40, tiers: [lower(58, 3, 28), upper(65, 121, 38, 74)], away: "corner" },
+    nba: { shape: "bowl", side: 5, end: 10, bench: 9, corner: 30, tiers: [courtside(7), { id: "lower", from: 13, to: 70, height: [3, 32], fill: 1 }, upper(77, 131, 42, 80)], away: "corner" },
+    mlb: { shape: "horseshoe", side: 0, end: 0, bench: 0, corner: 0, tiers: [], away: "corner" },
+    curling: { shape: "sides", side: 14, end: 10, bench: 0, corner: 6, tiers: [lower(30, 2, 12)], away: "corner" },
+    tennis: { shape: "bowl", side: 22, end: 32, bench: 4, corner: 24, tiers: [lower(44, 3, 24), upper(51, 95, 32, 62)], away: "corner" },
+    volleyball: { shape: "bowl", side: 20, end: 24, bench: 4, corner: 22, tiers: [lower(40, 3, 22), upper(47, 87, 30, 58)], away: "corner" },
+    badminton: { shape: "bowl", side: 16, end: 22, bench: 4, corner: 20, tiers: [lower(40, 3, 22), upper(47, 87, 30, 58)], away: "corner" },
+    pickleball: { shape: "sides", side: 18, end: 16, bench: 0, corner: 8, tiers: [lower(32, 2, 12)], away: "corner" },
+    tabletennis: { shape: "bowl", side: 16, end: 16, bench: 2, corner: 14, tiers: [lower(34, 2, 16), upper(41, 73, 22, 40)], away: "corner" },
+    // The court sports after those: indoor halls and show courts, ours (no rulebook gives the stands), the size of the stands following the size of the court.
+    padel: { shape: "bowl", side: 20, end: 22, bench: 4, corner: 20, tiers: [lower(40, 3, 22), upper(47, 87, 30, 58)], away: "corner" },
+    squash: { shape: "sides", side: 12, end: 10, bench: 0, corner: 8, tiers: [lower(26, 2, 12), upper(32, 56, 18, 32)], away: "corner" },
+    racquetball: { shape: "sides", side: 12, end: 10, bench: 0, corner: 8, tiers: [lower(26, 2, 12), upper(32, 56, 18, 32)], away: "corner" },
+    sepaktakraw: { shape: "bowl", side: 18, end: 22, bench: 4, corner: 20, tiers: [lower(40, 3, 22), upper(47, 87, 30, 58)], away: "corner" },
+    teqball: { shape: "bowl", side: 18, end: 20, bench: 3, corner: 18, tiers: [lower(38, 3, 20), upper(45, 79, 28, 52)], away: "corner" },
+    roundnet: { shape: "sides", side: 16, end: 12, bench: 0, corner: 8, tiers: [lower(26, 2, 12), upper(32, 56, 18, 32)], away: "corner" },
+    netball: { shape: "bowl", side: 20, end: 22, bench: 4, corner: 20, tiers: [lower(44, 3, 24), upper(51, 95, 32, 62)], away: "corner" },
+    // The pools: a natatorium has its stands along the long sides, a deck's width back from the water (ours: no rulebook gives the stands).
+    swimming: { shape: "sides", side: 26, end: 20, bench: 0, corner: 10, tiers: [lower(40, 3, 20), upper(47, 87, 28, 52)], away: "corner" },
+    waterpolo: { shape: "sides", side: 22, end: 18, bench: 0, corner: 10, tiers: [lower(36, 3, 18), upper(43, 79, 26, 48)], away: "corner" },
+    diving: { shape: "sides", side: 26, end: 20, bench: 0, corner: 10, tiers: [lower(40, 3, 20), upper(47, 87, 28, 52)], away: "corner" },
+    artisticswimming: { shape: "sides", side: 26, end: 20, bench: 0, corner: 10, tiers: [lower(40, 3, 20), upper(47, 87, 28, 52)], away: "corner" },
+    // Athletics: an oval bowl round the track, a stadium's two tiers (ours); skating: an arena's, close to the ice as a hockey rink is, rounded at the corners.
+    athletics: { shape: "bowl", side: 30, end: 30, bench: 0, corner: 0, tiers: [lower(70), upper(77, 135)], oval: true, away: "end" },
+    skating: { shape: "bowl", side: 12, end: 14, bench: 0, corner: 60, tiers: [lower(58, 3, 28), upper(65, 121, 38, 74)], away: "corner" },
+    lacrosse: { shape: "bowl", side: 24, end: 30, bench: 6, corner: 40, tiers: [lower(70), upper(77, 125, 58, 100)], away: "end" },
+    rugby: { shape: "bowl", side: 26, end: 36, bench: 6, corner: 48, tiers: [lower(78), upper(85, 145)], away: "end" },
+    afl: { shape: "bowl", side: 30, end: 30, bench: 0, corner: 0, tiers: [lower(70), upper(77, 135)], oval: true, away: "end" },
+    gaelic: { shape: "bowl", side: 34, end: 40, bench: 6, corner: 50, tiers: [lower(80), upper(87, 151)], away: "end" },
+    cricket: { shape: "bowl", side: 30, end: 30, bench: 0, corner: 0, tiers: [lower(66), upper(73, 125)], oval: true, away: "end" },
+    fieldhockey: { shape: "bowl", side: 20, end: 26, bench: 5, corner: 30, tiers: [lower(46, 3, 24), upper(53, 87, 32, 54)], away: "end" },
+    handball: { shape: "bowl", side: 14, end: 18, bench: 4, corner: 16, tiers: [courtside(6), { id: "lower", from: 10, to: 46, height: [3, 22], fill: 1 }, upper(53, 97, 30, 56)], away: "corner" },
+    // The budō (ours: no rule gives the stands). The competition areas of judo, karate and kendo stand in an arena's bowl, as the Nippon Budokan's does round its octagonal floor (the Budokan's leaflet: 2,946 temporary
+    // seats on the arena, 2,959 to 3,199 on the first floor, 7,876 on the second and third); sumo's dohyō stands in the middle of a hall of box seats and a gallery (the Ryōgoku Kokugikan's); a kyūdōjō's
+    // spectators stand along the yamichi; a dojo's gallery looks down on the mats from above, as the Kodokan's does from the eighth floor.
+    judo: { shape: "bowl", side: 36, end: 36, bench: 6, corner: 50, tiers: [lower(60, 3, 24), upper(67, 120, 32, 60)], away: "corner", arena: { side: 8, end: 8, bench: 0, corner: 56, tiers: [lower(34, 3, 24), upper(40, 74, 32, 62)] } },
+    karate: { shape: "bowl", side: 36, end: 36, bench: 6, corner: 50, tiers: [lower(60, 3, 24), upper(67, 120, 32, 60)], away: "corner", arena: { side: 8, end: 8, bench: 0, corner: 56, tiers: [lower(34, 3, 24), upper(40, 74, 32, 62)] } },
+    kendo: { shape: "bowl", side: 36, end: 36, bench: 6, corner: 50, tiers: [lower(60, 3, 24), upper(67, 120, 32, 60)], away: "corner", arena: { side: 8, end: 8, bench: 0, corner: 56, tiers: [lower(34, 3, 24), upper(40, 74, 32, 62)] } },
+    sumo: { shape: "bowl", side: 58, end: 58, bench: 0, corner: 56, tiers: [{ id: "lower", from: 0, to: 54, height: [1, 8], fill: 1 }, upper(62, 128, 26, 62)], away: "corner" },
+    kyudo: { shape: "sides", side: 10, end: 8, bench: 0, corner: 6, tiers: [lower(24, 2, 8), upper(30, 52, 12, 22)], away: "corner" },
+    dojo: { shape: "bowl", side: 5, end: 5, bench: 0, corner: 8, tiers: [lower(26, 2, 14), upper(32, 58, 20, 36)], away: "corner" },
+};
+/** The grounds of the package that are the home of an NFL or a CFL club, where a soccer pitch stands inside a gridiron's stands. From each ground's article. */
+export const GRIDIRON_GROUNDS = Object.freeze({
+    "metlife-stadium": "nfl",
+    "att-stadium": "nfl",
+    "arrowhead-stadium": "nfl",
+    "nrg-stadium": "nfl",
+    "mercedes-benz-stadium": "nfl",
+    "hard-rock-stadium": "nfl",
+    "sofi-stadium": "nfl",
+    "levis-stadium": "nfl",
+    "lumen-field": "nfl",
+    "gillette-stadium": "nfl",
+    "lincoln-financial-field": "nfl",
+    "rose-bowl": "nfl",
+    "bc-place": "cfl",
+});
+/** A gridiron's field, with its end zones, in feet, from the rulebook figures of the package: the NFL's 360 by 160, the CFL's 450 by 195. */
+function gridiron(kind) {
+    const f = FOOTBALL[kind];
+    return { length: f.length + 2 * f.endZone, width: f.width, endZone: f.endZone };
+}
+/** The walls the package knows have seats on top of them, by park and the wall's label: Fenway Park's Green Monster (the Monster seats, 2003). */
+export const WALL_SEATS = Object.freeze({ "fenway-park": "Green Monster" });
+// ---- Outlines. ----
+const sq = (v) => v * v;
+/** The point of an outline hit by a ray from `(cx, cy)` at angle `a` (screen angle, y down). */
+export function rayAt(o, cx, cy, a) {
+    const dx = Math.cos(a);
+    const dy = Math.sin(a);
+    if (o.kind === "ellipse") {
+        const t = 1 / Math.sqrt(sq(dx / o.rx) + sq(dy / o.ry));
+        return [cx + dx * t, cy + dy * t];
+    }
+    if (o.kind === "poly")
+        return o.points[0];
+    const w = (o.x1 - o.x0) / 2;
+    const h = (o.y1 - o.y0) / 2;
+    const mx = (o.x0 + o.x1) / 2;
+    const my = (o.y0 + o.y1) / 2;
+    // The ray from the middle of the rectangle, to the sides, and the corner circle where it lands in one.
+    const t = Math.min(Math.abs(dx) < 1e-9 ? Infinity : w / Math.abs(dx), Math.abs(dy) < 1e-9 ? Infinity : h / Math.abs(dy));
+    let px = cx + dx * t;
+    let py = cy + dy * t;
+    const r = Math.min(o.r, w, h);
+    const kx = Math.abs(px - mx) - (w - r);
+    const ky = Math.abs(py - my) - (h - r);
+    if (r > 0 && kx > 0 && ky > 0) {
+        // Solve |(c + d t) - corner centre| = r for the larger t.
+        const ccx = mx + Math.sign(px - mx) * (w - r);
+        const ccy = my + Math.sign(py - my) * (h - r);
+        const fx = cx - ccx;
+        const fy = cy - ccy;
+        const b = fx * dx + fy * dy;
+        const c = fx * fx + fy * fy - r * r;
+        const t2 = -b + Math.sqrt(Math.max(0, b * b - c));
+        px = cx + dx * t2;
+        py = cy + dy * t2;
+    }
+    return [px, py];
+}
+const n1 = (v) => {
+    const t = (Math.round(v * 10) / 10).toString();
+    return t === "-0" ? "0" : t;
+};
+/** An outline as a path, drawn clockwise, or counter-clockwise when `reverse` (a hole in a band that is filled with the non-zero rule). */
+export function outlinePath(o, reverse = false) {
+    if (o.kind === "poly") {
+        const pts = reverse ? [...o.points].reverse() : o.points;
+        return `M${pts.map(([x, y]) => `${Math.round(x)} ${Math.round(y)}`).join("L")}Z`;
+    }
+    if (o.kind === "ellipse") {
+        const sweep = reverse ? 0 : 1;
+        return `M${n1(o.cx + o.rx)} ${n1(o.cy)}A${n1(o.rx)} ${n1(o.ry)} 0 1 ${sweep} ${n1(o.cx - o.rx)} ${n1(o.cy)}A${n1(o.rx)} ${n1(o.ry)} 0 1 ${sweep} ${n1(o.cx + o.rx)} ${n1(o.cy)}Z`;
+    }
+    const r = Math.min(o.r, (o.x1 - o.x0) / 2, (o.y1 - o.y0) / 2);
+    const { x0, y0, x1, y1 } = o;
+    const a = (x, y, s) => (r > 0 ? `A${n1(r)} ${n1(r)} 0 0 ${s} ${n1(x)} ${n1(y)}` : "");
+    if (!reverse)
+        return `M${n1(x0 + r)} ${n1(y0)}H${n1(x1 - r)}${a(x1, y0 + r, 1)}V${n1(y1 - r)}${a(x1 - r, y1, 1)}H${n1(x0 + r)}${a(x0, y1 - r, 1)}V${n1(y0 + r)}${a(x0 + r, y0, 1)}Z`;
+    return `M${n1(x0 + r)} ${n1(y0)}${a(x0, y0 + r, 0)}V${n1(y1 - r)}${a(x0 + r, y1, 0)}H${n1(x1 - r)}${a(x1, y1 - r, 0)}V${n1(y0 + r)}${a(x1 - r, y0, 0)}Z`;
+}
+/** An outline as points, for a view that raises the stands: arcs are cut into steps of about 7.5 degrees. */
+export function outlinePoints(o) {
+    if (o.kind === "poly")
+        return o.points.map(([x, y]) => [x, y]);
+    const out = [];
+    if (o.kind === "ellipse") {
+        for (let i = 0; i < 48; i += 1)
+            out.push([o.cx + o.rx * Math.cos((i * Math.PI) / 24), o.cy + o.ry * Math.sin((i * Math.PI) / 24)]);
+        return out;
+    }
+    const r = Math.min(o.r, (o.x1 - o.x0) / 2, (o.y1 - o.y0) / 2);
+    const corners = [
+        [o.x1 - r, o.y0 + r, -90],
+        [o.x1 - r, o.y1 - r, 0],
+        [o.x0 + r, o.y1 - r, 90],
+        [o.x0 + r, o.y0 + r, 180],
+    ];
+    for (const [cx, cy, a0] of corners) {
+        const steps = r > 0 ? 12 : 1;
+        for (let i = 0; i <= steps; i += 1) {
+            const a = ((a0 + (i * 90) / steps) * Math.PI) / 180;
+            out.push([cx + r * Math.cos(a), cy + r * Math.sin(a)]);
+        }
+    }
+    return out;
+}
+const area = (o) => {
+    if (o.kind === "ellipse")
+        return Math.PI * o.rx * o.ry;
+    if (o.kind === "rrect") {
+        const r = Math.min(o.r, (o.x1 - o.x0) / 2, (o.y1 - o.y0) / 2);
+        return (o.x1 - o.x0) * (o.y1 - o.y0) - (4 - Math.PI) * r * r;
+    }
+    let s = 0;
+    o.points.forEach(([x, y], i) => {
+        const [x2, y2] = o.points[(i + 1) % o.points.length];
+        s += x * y2 - x2 * y;
+    });
+    return Math.abs(s) / 2;
+};
+/** The seats of a band of the stands: its area at a seat's 2 by 2.3 feet. */
+export const seatsIn = (region, hole) => Math.round((area(region) - (hole === null ? 0 : area(hole))) / 4.6);
+/** A point of a rounded rectangle and the outward normal there, by its parameter `u` (any real number, taken modulo 8): the four straight sides are the even whole numbers (the top from left to right, the right from top to bottom and so on round) and the four corners the odd ones. Concentric outlines (the same corners' centres) have the same parameter at the points an aisle joins. */
+export function rrectAt(o, u) {
+    const m = ((u % 8) + 8) % 8;
+    const k = Math.floor(m);
+    const f = m - k;
+    const w = o.x1 - o.x0;
+    const h = o.y1 - o.y0;
+    const r = Math.min(o.r, w / 2, h / 2);
+    const lh = w - 2 * r;
+    const lv = h - 2 * r;
+    const arc = (cx, cy, a0) => {
+        const a = ((a0 + 90 * f) * Math.PI) / 180;
+        return { p: [cx + r * Math.cos(a), cy + r * Math.sin(a)], n: [Math.cos(a), Math.sin(a)] };
+    };
+    switch (k) {
+        case 0:
+            return { p: [o.x0 + r + f * lh, o.y0], n: [0, -1] };
+        case 1:
+            return arc(o.x1 - r, o.y0 + r, -90);
+        case 2:
+            return { p: [o.x1, o.y0 + r + f * lv], n: [1, 0] };
+        case 3:
+            return arc(o.x1 - r, o.y1 - r, 0);
+        case 4:
+            return { p: [o.x1 - r - f * lh, o.y1], n: [0, 1] };
+        case 5:
+            return arc(o.x0 + r, o.y1 - r, 90);
+        case 6:
+            return { p: [o.x0, o.y1 - r - f * lv], n: [-1, 0] };
+        default:
+            return arc(o.x0 + r, o.y0 + r, 180);
+    }
+}
+/** The aisles a band has, as parameters of its inner outline: one at each end of every straight side (about every 30 feet along it) and one in the middle of every corner. */
+function aisleParameters(hole) {
+    const r = Math.min(hole.r, (hole.x1 - hole.x0) / 2, (hole.y1 - hole.y0) / 2);
+    const nh = Math.max(2, Math.round((hole.x1 - hole.x0 - 2 * r) / 30));
+    const nv = Math.max(2, Math.round((hole.y1 - hole.y0 - 2 * r) / 30));
+    const us = [];
+    for (let k = 0; k < 8; k += 1) {
+        if (k % 2 === 1)
+            us.push(k + 0.5);
+        else
+            for (let i = 0; i < (k % 4 === 0 ? nh : nv); i += 1)
+                us.push(k + i / (k % 4 === 0 ? nh : nv));
+    }
+    return { us, nh, nv };
+}
+/** The aisles of a band as lines from its inner edge to its outer. */
+function aislesOf(region, hole) {
+    if (region.kind === "rrect" && hole !== null && hole.kind === "rrect")
+        return aisleParameters(hole).us.map((u) => [rrectAt(hole, u).p, rrectAt(region, u).p]);
+    if (region.kind === "ellipse" && hole !== null && hole.kind === "ellipse") {
+        return Array.from({ length: 48 }, (_, i) => {
+            const t = (i * Math.PI) / 24;
+            return [[hole.cx + hole.rx * Math.cos(t), hole.cy + hole.ry * Math.sin(t)], [region.cx + region.rx * Math.cos(t), region.cy + region.ry * Math.sin(t)]];
+        });
+    }
+    return [];
+}
+/** The polygon of a band between two aisle parameters: along the outer edge, then back along the inner. */
+function sectionBetween(region, hole, u0, u1) {
+    const us = [u0];
+    for (let u = Math.floor(u0 * 4) / 4 + 0.25; u < u1 - 1e-9; u += 0.25)
+        if (u > u0 + 1e-9)
+            us.push(u);
+    us.push(u1);
+    return [...us.map((u) => rrectAt(region, u).p), ...us.map((u) => rrectAt(hole, u).p).reverse()];
+}
+/** The offsets of the first row from the surface's edge at each side, for the venue the sport has (and a gridiron's footprint for a soccer pitch in one). */
+function offsets(p, box, stadium) {
+    if (stadium === "purpose")
+        return { left: p.end, right: p.end, top: p.side, bottom: p.side + p.bench };
+    // A gridiron stadium keeps a football field's footprint, with the stands where a football field's stands are: the pitch stands inside it, in the middle.
+    const g = PROFILES[stadium];
+    const f = gridiron(stadium);
+    const end = g.end + (f.length - box.w) / 2;
+    const side = g.side + (f.width - box.h) / 2;
+    return { left: end, right: end, top: side, bottom: side + g.bench };
+}
+/** The layout of a sport's stands round its surface: rings, covers, sectors and gaps. For a ballpark see `parkLayout`. */
+export function layoutOf(input) {
+    const { sport, box } = input;
+    const gal = input.gallery;
+    // A gallery has no home and no visitors, no card display and no tunnel, camera or benches.
+    const crowd = gal === undefined ? input.crowd : { ...input.crowd, awayEnd: "none", tifo: undefined, gaps: false, shape: input.crowd.shape === "sides" ? "sides" : "bowl" };
+    const base0 = gal === undefined ? PROFILES[sport] : { shape: "bowl", side: gal.offset, end: gal.offset, bench: 0, corner: 0, tiers: [{ id: "gallery", from: 0, to: gal.depth, height: gal.height, fill: 1 }], away: "corner" };
+    const base = input.arena === true && base0.arena !== undefined ? { ...base0, ...base0.arena, tiers: base0.arena.tiers ?? base0.tiers } : base0;
+    const host = sport === "soccer" ? (crowd.stadium === "nfl" || crowd.stadium === "cfl" ? crowd.stadium : crowd.stadium === "auto" && input.ground !== undefined ? GRIDIRON_GROUNDS[input.ground] : undefined) : undefined;
+    const stadium = sport === "soccer" ? host ?? "purpose" : undefined;
+    const p = stadium === "nfl" || stadium === "cfl" ? { ...PROFILES[stadium], shape: base.shape, away: base.away } : base;
+    const shape = crowd.shape ?? p.shape;
+    const off = offsets(base, box, stadium ?? "purpose");
+    const cx = box.x + box.w / 2;
+    const cy = box.y + box.h / 2;
+    const rings = [];
+    const reachOf = { left: 0, right: 0, top: 0, bottom: 0 };
+    for (const t of p.tiers) {
+        const at = (k) => {
+            if (base.oval === true)
+                return { kind: "ellipse", cx, cy, rx: box.w / 2 + (off.left + off.right) / 2 + k, ry: box.h / 2 + (off.top + off.bottom) / 2 + k };
+            return { kind: "rrect", x0: box.x - off.left - k, y0: box.y - off.top - k, x1: box.x + box.w + off.right + k, y1: box.y + box.h + off.bottom + k, r: p.corner + k };
+        };
+        const region = at(t.to);
+        const hole = at(t.from);
+        const rise = t.height[1] - t.height[0];
+        rings.push({
+            id: t.id,
+            tier: t.id,
+            region,
+            hole,
+            from: t.from,
+            to: t.to,
+            height: [t.height[0], t.height[1]],
+            rake: Math.round((Math.atan2(rise, Math.max(1, t.to - t.from)) * 180) / Math.PI * 10) / 10,
+            fill: t.fill,
+            seats: seatsIn(region, hole),
+            aisles: aislesOf(region, hole),
+        });
+        reachOf.left = Math.max(reachOf.left, off.left + t.to);
+        reachOf.right = Math.max(reachOf.right, off.right + t.to);
+        reachOf.top = Math.max(reachOf.top, off.top + t.to);
+        reachOf.bottom = Math.max(reachOf.bottom, off.bottom + t.to);
+    }
+    const last = rings[rings.length - 1];
+    const covers = [];
+    const x0 = box.x - off.left;
+    const x1 = box.x + box.w + off.right;
+    const yTop = last === undefined ? box.y : box.y - reachOf.top - 4;
+    const yBot = last === undefined ? box.y + box.h : box.y + box.h + reachOf.bottom + 4;
+    if (shape === "horseshoe") {
+        // The open end: everything beyond the surface's end line and the gap that is kept clear.
+        if (crowd.open === "left")
+            covers.push([box.x - reachOf.left - 4, yTop, x0 + p.corner * 0.5, yBot]);
+        else
+            covers.push([x1 - p.corner * 0.5, yTop, box.x + box.w + reachOf.right + 4, yBot]);
+    }
+    else if (shape === "sides") {
+        covers.push([box.x - reachOf.left - 4, yTop, x0 + p.corner * 0.5, yBot], [x1 - p.corner * 0.5, yTop, box.x + box.w + reachOf.right + 4, yBot]);
+    }
+    const concourses = [];
+    rings.forEach((ring, i) => {
+        const before = rings[i - 1];
+        if (before !== undefined && ring.hole !== null && ring.from > before.to)
+            concourses.push({ region: ring.hole, hole: before.region });
+    });
+    const stands = { sport, shape, box, rings, covers, concourses, sectors: [], gaps: [], reach: reachOf, seats: rings.reduce((n, r) => n + r.seats, 0) };
+    if (stadium !== undefined)
+        stands.stadium = stadium;
+    if (gal !== undefined)
+        stands.gallery = true;
+    if (stadium === "nfl" || stadium === "cfl") {
+        const f = gridiron(stadium);
+        const field = { x: cx - f.length / 2, y: cy - f.width / 2, w: f.length, h: f.width };
+        stands.footprint = { field, endZones: [{ x: field.x, y: field.y, w: f.endZone, h: f.width }, { x: field.x + f.length - f.endZone, y: field.y, w: f.endZone, h: f.width }] };
+    }
+    if (shape === "sides" && last !== undefined) {
+        // Two sides: nothing beyond the ends.
+        reachOf.left = Math.min(reachOf.left, off.left + 4);
+        reachOf.right = Math.min(reachOf.right, off.right + 4);
+    }
+    // The visitors, a card display, and the places left open.
+    const lowerRing = rings.find((r) => r.tier === "lower") ?? rings[0];
+    if (lowerRing !== undefined) {
+        const side = crowd.awayEnd === "left" || crowd.awayEnd === "right" ? crowd.awayEnd : input.awaySide;
+        const sign = side === "right" ? 1 : -1;
+        const mode = crowd.awayEnd === "auto" ? (p.away === "end" ? "end" : "corner") : crowd.awayEnd === "corner" ? "corner" : "end";
+        const tiers = rings.filter((r) => r.tier === "lower" || r.tier === "upper");
+        const hole = lowerRing.hole;
+        if (lowerRing.region.kind === "rrect" && hole !== null && hole.kind === "rrect") {
+            // Round a rectangle a block is whole sections: it starts and ends on aisles, so that it is a section of the stands and not a wedge.
+            const { nh, nv } = aisleParameters(hole);
+            const clear = (u) => {
+                const [px, py] = rrectAt(lowerRing.region, u).p;
+                return !covers.some(([bx0, by0, bx1, by1]) => px >= bx0 && px <= bx1 && py >= by0 && py <= by1);
+            };
+            const section = (kind, u0, u1, only) => {
+                if (!clear((u0 + u1) / 2) || !clear(u0) || !clear(u1))
+                    return;
+                for (const ring of only === undefined ? tiers : [only])
+                    if (ring.region.kind === "rrect" && ring.hole?.kind === "rrect")
+                        stands.sectors.push({ ring: ring.id, kind, points: sectionBetween(ring.region, ring.hole, u0, u1) });
+            };
+            // An end's side is the right (segment 2) or the left (segment 6); a block on it is from one aisle to another near its middle.
+            const along = (seg, from, to) => [seg + Math.max(0, Math.min(nv - 1, Math.round(nv * from))) / nv, seg + Math.max(1, Math.min(nv, Math.round(nv * to))) / nv];
+            if (crowd.awayEnd !== "none") {
+                if (mode === "end")
+                    section("away", ...along(sign > 0 ? 2 : 6, 0.28, 0.72));
+                else if (sign > 0)
+                    section("away", (nh - 2) / nh, 1.5);
+                else
+                    section("away", 7.5, 8 + 2 / nh);
+            }
+            if (crowd.tifo !== undefined) {
+                const homeSideIsLeft = input.awaySide === "right";
+                const mk = (team) => {
+                    const left = (team === "home") === homeSideIsLeft;
+                    section(team === "home" ? "tifo-home" : "tifo-away", ...along(left ? 6 : 2, 0.32, 0.68), lowerRing);
+                };
+                if (crowd.tifo === "home" || crowd.tifo === "both")
+                    mk("home");
+                if (crowd.tifo === "away" || crowd.tifo === "both")
+                    mk("away");
+            }
+        }
+        else {
+            // Round an oval a block is a wedge of the ring, between two rays.
+            const corner = Math.atan2(box.h / 2 + off.top + lowerRing.to / 2, box.w / 2 + off.left + lowerRing.to / 2);
+            const wedge = (ring, from, to) => {
+                const outer = [];
+                const inner = [];
+                for (let i = 0; i <= 8; i += 1) {
+                    const a = from + ((to - from) * i) / 8;
+                    outer.push(rayAt(ring.region, cx, cy, a));
+                    inner.push(rayAt(ring.hole ?? ring.region, cx, cy, a));
+                }
+                return [...outer, ...inner.reverse()];
+            };
+            const place = (kind, a0, a1, only) => {
+                for (const ring of only === undefined ? tiers : [only])
+                    stands.sectors.push({ ring: ring.id, kind, points: wedge(ring, a0, a1) });
+            };
+            const centre = side === "right" ? 0 : Math.PI;
+            if (crowd.awayEnd !== "none")
+                place("away", centre - corner * 0.5, centre + corner * 0.5);
+            if (crowd.tifo !== undefined) {
+                const homeSideIsLeft = input.awaySide === "right";
+                const mk = (team) => place(team === "home" ? "tifo-home" : "tifo-away", ((team === "home") === homeSideIsLeft ? Math.PI : 0) - corner * 0.42, ((team === "home") === homeSideIsLeft ? Math.PI : 0) + corner * 0.42, lowerRing);
+                if (crowd.tifo === "home" || crowd.tifo === "both")
+                    mk("home");
+                if (crowd.tifo === "away" || crowd.tifo === "both")
+                    mk("away");
+            }
+        }
+        if (crowd.gaps && shape !== "grandstand") {
+            const bottom = box.y + box.h;
+            const mid = box.x + box.w / 2;
+            // A tunnel through the lower stands at the middle of the bench side, the camera platform above them, and the benches in the gap.
+            stands.gaps.push({ kind: "tunnel", box: [mid - 6, bottom + off.bottom - 1, mid + 6, bottom + off.bottom + lowerRing.to + 1] });
+            const media = rings[rings.length - 1];
+            if (media !== undefined && media.tier === "upper")
+                stands.gaps.push({ kind: "camera", box: [mid - 22, bottom + off.bottom + media.from + 3, mid + 22, bottom + off.bottom + media.from + 13] });
+            if (off.bottom - off.top >= 4 || sport === "soccer" || sport === "nfl" || sport === "cfl" || sport === "ifaf" || sport === "rugby" || sport === "gaelic") {
+                const benchLen = Math.min(34, box.w * 0.12);
+                for (const s of [-1, 1]) {
+                    const bx = mid + s * (box.w * 0.1 + benchLen / 2 + 4);
+                    stands.gaps.push({ kind: "bench", box: [bx - benchLen / 2, bottom + 2.5, bx + benchLen / 2, bottom + 2.5 + Math.min(5, off.bottom * 0.3)] });
+                }
+            }
+            stands.gaps.push({ kind: "media", box: [mid - 55, bottom + off.bottom + 2, mid + 55, bottom + off.bottom + 6] });
+        }
+    }
+    return stands;
+}

package/dist/crowd.park.d.ts

@@ -0,0 +1,19 @@
+import type { Crowd, CrowdStands, Pt } from "./crowd.ts";
+/** A stretch of wall with seats on top of it: its bearings from dead centre (the left field line is -45) and its height in feet. */
+export interface WallSeats {
+    from: number;
+    to: number;
+    height: number;
+}
+/** What a ballpark's stands are laid from. */
+export interface ParkInput {
+    /** The fence as points on the field: u across (negative to the left), v out from the back of home plate. */
+    fence: readonly Pt[];
+    /** How far behind home plate the backstop stands, in feet. */
+    backstop: number;
+    crowd: Crowd;
+    /** The walls that have seats on top of them. */
+    seatsOnWalls?: readonly WallSeats[];
+}
+/** The stands of a ballpark, as data. */
+export declare function parkLayout(input: ParkInput): CrowdStands;

package/dist/crowd.park.js

@@ -0,0 +1,153 @@
+import { seatsIn } from "./crowd.js";
+const dist = ([x, y]) => Math.hypot(x, y);
+/** The unit normals of a polyline pointing away from home, averaged at each vertex, with the length the offset grows by at a corner (limited to 1.6). */
+function normals(points) {
+    const segments = points.slice(1).map(([x, y], i) => {
+        const [px, py] = points[i];
+        const dx = x - px;
+        const dy = y - py;
+        const len = Math.hypot(dx, dy) || 1;
+        let nx = dy / len;
+        let ny = -dx / len;
+        if (nx * (x + px) + ny * (y + py) < 0) {
+            nx = -nx;
+            ny = -ny;
+        }
+        return [nx, ny];
+    });
+    return points.map((_, i) => {
+        const a = segments[Math.max(0, i - 1)];
+        const b = segments[Math.min(segments.length - 1, i)];
+        const sx = a[0] + b[0];
+        const sy = a[1] + b[1];
+        const len = Math.hypot(sx, sy) || 1;
+        const n = [sx / len, sy / len];
+        return { n, k: 1 / Math.max(0.62, a[0] * n[0] + a[1] * n[1]) };
+    });
+}
+/** The polygon of a band along a polyline between two offsets, over a range of vertices. */
+function band(points, nrm, inner, outer, i0 = 0, i1 = points.length - 1) {
+    const side = (offset) => {
+        const out = [];
+        for (let i = i0; i <= i1; i += 1)
+            out.push([points[i][0] + nrm[i].n[0] * offset * nrm[i].k, points[i][1] + nrm[i].n[1] * offset * nrm[i].k]);
+        return out;
+    };
+    return [...side(inner), ...side(outer).reverse()];
+}
+/** The aisles of a band polygon made by `band`: lines from every third vertex of its inner edge to the matching one of its outer, so that blocks begin and end on them. */
+function aislesOf(polygon) {
+    const n = polygon.length;
+    const out = [];
+    for (let i = 2; i < n / 2 - 1; i += 3)
+        out.push([polygon[i], polygon[n - 1 - i]]);
+    return out;
+}
+/** The stands of a ballpark, as data. */
+export function parkLayout(input) {
+    const { crowd } = input;
+    const shape = crowd.shape ?? "horseshoe";
+    // The fence in the drawing's own frame (y is minus the distance out), every second point, with its bearing from dead centre.
+    const fence = input.fence.filter((_, i) => i % 2 === 0 || i === input.fence.length - 1).map(([u, v]) => [u, -v]);
+    const bearing = ([x, y]) => (Math.atan2(x, -y) * 180) / Math.PI;
+    const pole = (dist(fence[0]) + dist(fence[fence.length - 1])) / 2;
+    const R = input.backstop + 22;
+    const S = pole + (shape === "grandstand" ? 0 : 25);
+    const q = Math.SQRT1_2;
+    // The infield's inner edge from the left pole in to home plate and out to the right pole: along each foul line at a distance that eases from the pole's 14 feet to the curve's
+    // radius behind home plate (a smooth step, so that it meets the curve with no corner), round behind home plate on a circle about it.
+    const gap = (s) => 14 + (R - 14) * (0.5 + 0.5 * Math.cos(Math.PI * Math.min(1, s / pole)));
+    const inner = [];
+    const lineSteps = 8;
+    for (let i = lineSteps; i >= 0; i -= 1) {
+        const s = (S * i) / lineSteps;
+        inner.push([-q * s - q * gap(s), -q * s + q * gap(s)]);
+    }
+    const arcSteps = 8;
+    for (let k = 1; k < arcSteps; k += 1) {
+        const a = ((135 - (90 * k) / arcSteps) * Math.PI) / 180;
+        inner.push([R * Math.cos(a), R * Math.sin(a)]);
+    }
+    for (let i = 0; i <= lineSteps; i += 1) {
+        const s = (S * i) / lineSteps;
+        inner.push([q * s + q * gap(s), -q * s + q * gap(s)]);
+    }
+    const nI = normals(inner);
+    const rings = [];
+    const add = (id, tier, pieces, from, to, height, fill) => {
+        const [first, ...rest] = pieces;
+        rings.push({
+            id,
+            tier,
+            region: { kind: "poly", points: first },
+            ...(rest.length > 0 ? { more: rest.map((points) => ({ kind: "poly", points })) } : {}),
+            hole: null,
+            from,
+            to,
+            height,
+            rake: Math.round((Math.atan2(height[1] - height[0], Math.max(1, to - from)) * 180) / Math.PI * 10) / 10,
+            fill,
+            seats: pieces.reduce((n, points) => n + seatsIn({ kind: "poly", points }, null), 0),
+            aisles: pieces.flatMap((points) => aislesOf(points)),
+        });
+    };
+    const lowerDepth = 60;
+    const walk = 7;
+    const upperDepth = 56;
+    add("lower", "lower", [band(inner, nI, 0, lowerDepth)], 0, lowerDepth, [4, 40], 1);
+    add("upper", "upper", [band(inner, nI, lowerDepth + walk, lowerDepth + walk + upperDepth)], lowerDepth + walk, lowerDepth + walk + upperDepth, [52, 104], 0.88);
+    const concourses = [{ region: { kind: "poly", points: band(inner, nI, lowerDepth - 0.5, lowerDepth + walk + 0.5) }, hole: null }];
+    // The outfield: bleachers right behind the fence, radially from home plate, but for a gap at the batter's eye in the horseshoe; and, where the park has seats on top of a wall,
+    // a band of them along the wall at its height.
+    const wall = 12;
+    const depth = 54;
+    if (shape !== "grandstand") {
+        const nF = fence.map((p) => ({ n: [p[0] / (dist(p) || 1), p[1] / (dist(p) || 1)], k: 1 }));
+        const eye = (i) => Math.abs(fence[i][0]) < pole * 0.07 && shape === "horseshoe";
+        const runs = [];
+        let start = 0;
+        for (let i = 0; i <= fence.length; i += 1) {
+            if (i === fence.length || eye(i)) {
+                if (i - 1 > start)
+                    runs.push([start, i - 1]);
+                start = i + 1;
+            }
+        }
+        const pieces = runs.map(([a, b]) => band(fence, nF, wall, wall + depth, a, b));
+        if (pieces.length > 0)
+            add("bleachers", "bleachers", pieces, wall, wall + depth, [4, 30], 0.9);
+        for (const w of input.seatsOnWalls ?? []) {
+            const on = fence.map((p, i) => ({ i, b: bearing(p) })).filter(({ i, b }) => b >= w.from - 0.01 && b <= w.to + 0.01 && !eye(i));
+            if (on.length > 2)
+                add("wall-seats", "wall", [band(fence, nF, 0, 8, on[0].i, on[on.length - 1].i)], 0, 8, [w.height, w.height + 5], 0.95);
+        }
+    }
+    // The visitors: a block along the third-base line, from aisle to aisle, in the two tiers; and a card display round behind home plate.
+    const sectors = [];
+    if (crowd.awayEnd !== "none") {
+        const awayLeft = crowd.awayEnd !== "right";
+        const a0 = awayLeft ? 2 : 17;
+        const a1 = awayLeft ? 8 : 23;
+        sectors.push({ ring: "lower", kind: "away", points: band(inner, nI, 0, lowerDepth, a0, a1) });
+        sectors.push({ ring: "upper", kind: "away", points: band(inner, nI, lowerDepth + walk, lowerDepth + walk + upperDepth, a0, a1) });
+    }
+    if (crowd.tifo !== undefined)
+        sectors.push({ ring: "lower", kind: crowd.tifo === "away" ? "tifo-away" : "tifo-home", points: band(inner, nI, 0, lowerDepth, 11, 14) });
+    const gaps = [];
+    if (crowd.gaps) {
+        gaps.push({ kind: "tunnel", box: [-8, R - 1, 8, R + lowerDepth + 1] });
+        gaps.push({ kind: "camera", box: [-20, R + lowerDepth + walk + 8, 20, R + lowerDepth + walk + 18] });
+    }
+    // The field's box and how far the stands reach beyond it.
+    const us = input.fence.map(([u]) => u);
+    const vs = input.fence.map(([, v]) => v);
+    const box = { x: Math.min(...us), y: -Math.max(...vs), w: Math.max(...us) - Math.min(...us), h: Math.max(...vs) + input.backstop };
+    const all = rings.flatMap((r) => [r.region, ...(r.more ?? [])].flatMap((o) => (o.kind === "poly" ? o.points : [])));
+    const reach = {
+        left: Math.max(0, box.x - Math.min(...all.map(([x]) => x))),
+        right: Math.max(0, Math.max(...all.map(([x]) => x)) - (box.x + box.w)),
+        top: Math.max(0, box.y - Math.min(...all.map(([, y]) => y))),
+        bottom: Math.max(0, Math.max(...all.map(([, y]) => y)) - (box.y + box.h)),
+    };
+    return { sport: "mlb", shape, box, rings, covers: [], concourses, sectors, gaps, reach, seats: rings.reduce((n, r) => n + r.seats, 0) };
+}