@johnmorrisdotca/kyogijo-stadiums 0.7.0 → 0.8.0

package/dist/venue.js

@@ -0,0 +1,172 @@
+// The stands round a surface, raised: `crowdStands()` says where each tier of seats is (its outline, the height of its first and last row, its aisles, the blocks of visitors and the places left
+// open), and this makes of it what the 3D view stands on the floor: every tier a strip of raked planes (a quad to every straight side and a few to every corner, so that a whole bowl is a few dozen
+// elements, however many seats it has), textured with the crowd's own pattern and the lines of its rows, the concourses between the tiers, the low wall under the first row, the seats on top of a
+// ballpark's wall, and, when asked, the roof or canopy over the top tier. Pure: data in, planes out.
+import { densityOf, resolveCrowd } from "./crowd.js";
+import { patterns } from "./crowd.draw.js";
+import { crowdStands } from "./draw.js";
+import { groundById } from "./grounds.js";
+import { clipAround, clipConvex, clipSegment, areaOf, pointList, raked, slopeOf, stripsOf, tidy } from "./venue.geom.js";
+import { n, shy, wall } from "./turn.kit.js";
+export const NO_VENUE = { items: [], defs: "", reach: 0 };
+/** The sports played under a roof: their stands have a lid and not a canopy. */
+const INDOOR = ["nhl", "nba", "volleyball", "badminton", "tabletennis", "handball", "judo", "karate", "kendo", "sumo", "dojo", "curling", "squash", "racquetball", "pickleball", "netball", "skating", "swimming", "waterpolo", "diving", "artisticswimming", "teqball", "roundnet", "sepaktakraw"];
+/** How far the roof stands over the top row at its edge, in feet (ours: no rule gives it), and how far it reaches over the seats. */
+export const ROOF = { clearance: 26, canopyReach: 0.62, canopyDrop: 6, lidRise: 26 };
+const round = (v) => Math.round(v * 1000) / 1000;
+/** The top of a set of planes. */
+const topOf = (planes) => Math.max(0, ...planes.flatMap((p) => [p.o[2], p.o[2] + p.u[2], p.o[2] + p.v[2], p.o[2] + p.u[2] + p.v[2]]));
+/** The tiers a roof covers: the highest of those that are not a ballpark's wall seats or bleachers. */
+function topRing(stands) {
+    const rings = stands.rings.filter((r) => r.tier !== "wall" && r.tier !== "bleachers");
+    return rings.reduce((best, r) => (best === undefined || r.height[1] > best.height[1] ? r : best), undefined);
+}
+/** The quads of the strips of a ring, with their slopes. */
+function* quadsOf(strips) {
+    for (const strip of strips)
+        for (let i = 0; i + 1 < strip.inner.length; i += 1)
+            yield [strip.inner[i], strip.inner[i + 1], strip.outer[i + 1], strip.outer[i]];
+}
+/** The stands of a surface as planes: `undefined`-free, an empty venue when the options have no crowd (or the crowd is a hall's gallery, which `venue.room.ts` raises). */
+export function standsVenue(o, v, lift) {
+    const stands = crowdStands(o);
+    const crowd = resolveCrowd(o.crowd);
+    if (stands === undefined || crowd === undefined || stands.gallery === true)
+        return NO_VENUE;
+    const cut = v.detail ?? "auto";
+    const fine = crowd.detail !== "plain" && o.detail !== "simple";
+    const density = densityOf(crowd, stands.seats, groundById(o.ground)?.capacity);
+    const tifo = { home: stands.sectors.some((s) => s.kind === "tifo-home"), away: stands.sectors.some((s) => s.kind === "tifo-away") };
+    const pid = `${v.id}-v`;
+    const defs = fine ? patterns(pid, crowd, density, tifo.home || tifo.away ? tifo : undefined, false, true) : "";
+    const centre = [stands.box.x + stands.box.w / 2, stands.box.y + stands.box.h / 2];
+    const covers = stands.covers;
+    const inCover = (p) => covers.some(([x0, y0, x1, y1]) => p[0] >= x0 && p[0] <= x1 && p[1] >= y0 && p[1] <= y1);
+    const pieces = (poly) => (covers.length === 0 ? [poly] : clipAround(poly, covers));
+    const seatPlanes = [];
+    const wallSeats = [];
+    let count = 0;
+    const paint = (ring, piece) => (corners, local) => {
+        let svg = `<polygon class="u-bed" points="${pointList(corners)}"/>`;
+        const people = ring.fill < 0.95 ? ` fill-opacity="${round(1 - Math.min(0.5, (1 - ring.fill) * 1.6))}"` : "";
+        svg += fine ? `<polygon fill="url(#${pid}-cr-h)"${people} points="${pointList(corners)}"/>` : `<polygon class="u-blk" fill-opacity="${round(0.28 + 0.6 * density * ring.fill)}" points="${pointList(corners)}"/>`;
+        for (const s of stands.sectors) {
+            if (s.ring !== ring.id)
+                continue;
+            const part = tidy(clipConvex(s.points, piece));
+            if (part.length < 3 || Math.abs(areaOf(part)) < 0.05)
+                continue;
+            const points = pointList(part.map(local));
+            if (s.kind === "away")
+                svg += fine ? `<polygon fill="url(#${pid}-cr-a)" points="${points}"/>` : `<polygon class="u-blk-a" fill-opacity="${round(0.3 + 0.6 * density)}" points="${points}"/>`;
+            else
+                svg += fine ? `<polygon fill="url(#${pid}-cr-${s.kind === "tifo-home" ? "th" : "ta"})" points="${points}"/>` : `<polygon class="${s.kind === "tifo-home" ? "u-th" : "u-ta"}" points="${points}"/>`;
+        }
+        if (fine) {
+            let plain = "";
+            let vomitory = "";
+            ring.aisles.forEach(([a, b], i) => {
+                const seg = clipSegment(a, b, piece);
+                if (seg === undefined || Math.hypot(seg[1][0] - seg[0][0], seg[1][1] - seg[0][1]) < 0.5)
+                    return;
+                const [p, q] = [local(seg[0]), local(seg[1])];
+                const d = `M${n(p[0])} ${n(p[1])}L${n(q[0])} ${n(q[1])}`;
+                if (i % 4 === 0)
+                    vomitory += d;
+                else
+                    plain += d;
+            });
+            if (plain !== "")
+                svg += `<path class="ky-cr-aisle" fill="none" stroke-width="1.1" d="${plain}"/>`;
+            if (vomitory !== "")
+                svg += `<path class="ky-cr-aisle" fill="none" stroke-width="2.4" d="${vomitory}"/>`;
+        }
+        return svg;
+    };
+    // The tiers. A ring that no concourse leads to is the first of its chain: a low wall stands under its first row.
+    const chained = new Set();
+    const links = stands.concourses.map((c, ci) => {
+        let at = stands.rings.findIndex((r) => r.hole === c.region);
+        if (at < 1)
+            at = Math.min(ci + 1, stands.rings.length - 1);
+        chained.add(stands.rings[at]);
+        return { c, before: stands.rings[at - 1], after: stands.rings[at] };
+    });
+    for (const ring of stands.rings) {
+        const strips = stripsOf(ring.region, ring.hole, ring.more ?? [], cut);
+        const into = ring.tier === "wall" ? wallSeats : seatPlanes;
+        for (const q of quadsOf(strips)) {
+            const slope = slopeOf(q, lift + ring.height[0], lift + ring.height[1]);
+            if (slope === undefined)
+                continue;
+            for (const piece of pieces(tidy(q))) {
+                count += 1;
+                const p = raked(`${ring.id}-${count}`, "seats", piece, slope.slope, slope.along, paint(ring, piece));
+                if (p !== undefined)
+                    into.push({ ...p, shy: slope.out });
+            }
+        }
+        // The low wall under the first row of a tier the walks do not lead to (a ballpark's wall seats stand on the fence, which the fence's own planes make).
+        if (ring.tier !== "wall" && !chained.has(ring) && ring.height[0] > 0.5) {
+            for (const strip of strips) {
+                for (let i = 0; i + 1 < strip.inner.length; i += 1) {
+                    const [a, b] = [strip.inner[i], strip.inner[i + 1]];
+                    if (Math.hypot(b[0] - a[0], b[1] - a[1]) < 0.5 || inCover([(a[0] + b[0]) / 2, (a[1] + b[1]) / 2]))
+                        continue;
+                    const h = lift + ring.height[0];
+                    const w = wall(`${ring.id}-front-${i}`, "fascia", a[0], a[1], b[0], b[1], 0, h, `<rect class="u-fascia" width="${n(Math.hypot(b[0] - a[0], b[1] - a[1]))}" height="${n(h)}"/>`);
+                    seatPlanes.push(shy(w, centre));
+                }
+            }
+        }
+    }
+    // The walks between the tiers: a plane from the outer edge of one tier up to the first row of the next.
+    for (const { c, before, after } of links) {
+        if (before === undefined || after === undefined)
+            continue;
+        for (const q of quadsOf(stripsOf(c.region, c.hole, [], cut))) {
+            const slope = slopeOf(q, lift + before.height[1], lift + after.height[0]);
+            if (slope === undefined)
+                continue;
+            for (const piece of pieces(tidy(q))) {
+                count += 1;
+                const p = raked(`walk-${count}`, "concourse", piece, slope.slope, slope.along, (corners) => `<polygon class="u-conc" points="${pointList(corners)}"/>`);
+                if (p !== undefined)
+                    seatPlanes.push({ ...p, shy: slope.out });
+            }
+        }
+    }
+    const items = [];
+    if (seatPlanes.length > 0)
+        items.push({ id: "stands", kind: "stands", at: centre, height: topOf(seatPlanes), planes: seatPlanes });
+    if (wallSeats.length > 0)
+        items.push({ id: "wall-seats", kind: "wall-seats", at: centre, height: topOf(wallSeats), planes: wallSeats });
+    // The roof: a canopy over the back of the top tier, or a lid over it in a hall.
+    const top = v.roof === true && crowd.roof ? topRing(stands) : undefined;
+    if (top !== undefined) {
+        const lid = INDOOR.includes(String(o.sport));
+        const reach = lid ? 1 : ROOF.canopyReach;
+        const zOut = lift + top.height[1] + ROOF.clearance;
+        const zIn = lid ? zOut + ROOF.lidRise : zOut - ROOF.canopyDrop;
+        const planes = [];
+        for (const strip of stripsOf(top.region, top.hole, top.more ?? [], cut)) {
+            // The roof's inner edge is part of the way in from the tier's outer edge to its inner.
+            const inner = strip.outer.map((p, i) => [p[0] + (strip.inner[i][0] - p[0]) * reach, p[1] + (strip.inner[i][1] - p[1]) * reach]);
+            for (const q of quadsOf([{ inner, outer: strip.outer }])) {
+                const slope = slopeOf(q, zIn, zOut);
+                if (slope === undefined)
+                    continue;
+                for (const piece of pieces(tidy(q))) {
+                    count += 1;
+                    const p = raked(`roof-${count}`, "roof", piece, slope.slope, slope.along, (corners) => `<polygon class="u-roof" points="${pointList(corners)}"/>`);
+                    if (p !== undefined)
+                        planes.push({ ...p, shy: slope.out });
+                }
+            }
+        }
+        if (planes.length > 0)
+            items.push({ id: "roof", kind: "roof", at: centre, height: topOf(planes), planes });
+    }
+    const r = stands.reach;
+    return { items, defs, reach: Math.max(r.left, r.right, r.top, r.bottom) + 6 };
+}

package/dist/venue.room.d.ts

@@ -0,0 +1,9 @@
+import { type Venue, type VenueBuild } from "./venue.ts";
+import type { SurfaceOptions } from "./types.ts";
+/** The height of the wood on a dojo's walls, in metres (ours: no source gives it). */
+export declare const WAINSCOT = 0.9;
+/** How far a gallery's floor slab projects in front of the first row beyond the wall's own thickness, and how thick it is, in metres (ours). */
+export declare const SLAB_PROJECTION = 0.5;
+export declare const SLAB = 0.35;
+/** The raised parts of a budō surface's room: what `dojoRoom()` says, for the options. An empty venue for a surface with no room. */
+export declare function roomVenue(o: SurfaceOptions, v: VenueBuild, lift: number): Venue;

package/dist/venue.room.js

@@ -0,0 +1,240 @@
+// The room round a budō surface, raised from `dojoRoom()`: the walls of a dojo with the doors and windows in them, the raised seat of honour (the kamiza's dais), the banner, the shrine, the balconies with their
+// rows of seats and their rails, and the edge of the mats, a few centimetres over the floor. The sumo dohyō's mound is the budō uprights' own (from the plan's data). Metres in the room's data, feet here.
+import { densityOf, resolveCrowd } from "./crowd.js";
+import { patterns } from "./crowd.draw.js";
+import { dojoRoom } from "./budo/room.js";
+import { NO_VENUE } from "./venue.js";
+import { flat, n, plane, shy as shyOf, wall } from "./turn.kit.js";
+const K = 1 / 0.3048;
+/** The height of the wood on a dojo's walls, in metres (ours: no source gives it). */
+export const WAINSCOT = 0.9;
+/** How far a gallery's floor slab projects in front of the first row beyond the wall's own thickness, and how thick it is, in metres (ours). */
+export const SLAB_PROJECTION = 0.5;
+export const SLAB = 0.35;
+/**
+ * The tile of the gallery's seats: one seat wide and one row deep, a cushion at the front and its back behind it, read by every tread. A seat is as wide as the side's seats make it (`RoomBalcony.seatWidth`).
+ * The blocks of seats come from `seatBlocks`.
+ */
+const seatTile = (id, width, row) => `<pattern id="${id}-seat" width="${n(width)}" height="${n(row)}" patternUnits="userSpaceOnUse"><rect class="u-seatcush" x="${n(width * 0.1)}" y="${n(row * 0.1)}" width="${n(width * 0.8)}" height="${n(row * 0.55)}" rx=".2"/><rect class="u-seatback" x="${n(width * 0.1)}" y="${n(row * 0.72)}" width="${n(width * 0.8)}" height="${n(row * 0.2)}" rx=".12"/></pattern>`;
+/** The blocks of seats along a row as one path of rectangles, and the aisles between them as another, from the balcony's own sections and seat width. Feet along the row, `row` deep. */
+function seatBlocks(b, row) {
+    const w = b.seatWidth * K;
+    const aisle = b.aisle * K;
+    let x = 0;
+    let seats = "";
+    let aisles = "";
+    const pieces = [];
+    b.sections.forEach((k, i) => {
+        seats += `M${n(x)} 0h${n(k * w)}v${n(row)}h${n(-k * w)}Z`;
+        x += k * w;
+        if (i < b.sections.length - 1) {
+            aisles += `M${n(x)} 0h${n(aisle)}v${n(row)}h${n(-aisle)}Z`;
+            pieces.push([x, aisle]);
+            x += aisle;
+        }
+    });
+    return { seats, aisles, pieces };
+}
+/** The thinnest a mat's edge is drawn, in feet, so that the 5 cm of a competition mat does not vanish on a large floor. */
+const LEAST_EDGE = 0.12;
+/** A plane of the room that gives way to the eye: down to a hundredth, because the gallery's steps and its walls lie over one another on the screen and would add up to a veil. */
+const shy = (p, centre) => ({ ...shyOf(p, centre), fadeTo: 0.01 });
+const box = (b) => [b.x0 * K, b.y0 * K, b.x1 * K, b.y1 * K];
+/** The planes of a box standing on the floor: four sides and a top, in feet. */
+function block(id, kind, b, z0, z1, side, top, centre) {
+    const [x0, y0, x1, y1] = box(b);
+    const edge = (a, b2, c, d, i) => shy(wall(`${id}-${i}`, kind, a, b2, c, d, z0, z1, `<rect class="${side}" width="${n(Math.hypot(c - a, d - b2))}" height="${n(z1 - z0)}"/>`), centre);
+    return [edge(x0, y0, x1, y0, 1), edge(x1, y0, x1, y1, 2), edge(x1, y1, x0, y1, 3), edge(x0, y1, x0, y0, 4), flat(`${id}-top`, kind, x0, y0, x1, y1, z1, `<rect class="${top}" width="${n(x1 - x0)}" height="${n(y1 - y0)}"/>`)];
+}
+/** A wall of the room with its doors and windows drawn on it. */
+function wallPlane(w, openings, centre, room) {
+    if (w.height === undefined || w.thickness === 0)
+        return undefined;
+    const [ax, ay] = [w.from[0] * K, w.from[1] * K];
+    const [bx, by] = [w.to[0] * K, w.to[1] * K];
+    const long = Math.hypot(bx - ax, by - ay);
+    const dx = (bx - ax) / long;
+    const dy = (by - ay) / long;
+    const H = w.height * K;
+    // A dojo with a gallery has honey wood panelling the whole height of its walls, up to the gallery's floor (boards a metre or so wide, ours); one without has a cream wall over a wainscot of wood a belt high.
+    const panelled = room.balconies.length > 0;
+    const band = panelled ? H : Math.min(WAINSCOT * K, H);
+    let svg = panelled ? `<rect class="u-wainscot" width="${n(long)}" height="${n(H)}"/>` : `<rect class="u-room" width="${n(long)}" height="${n(H)}"/><rect class="u-wainscot" y="${n(H - band)}" width="${n(long)}" height="${n(band)}"/><path class="u-wainline" fill="none" d="M0 ${n(H - band)}H${n(long)}"/>`;
+    if (panelled) {
+        let seams = "";
+        for (let at = 1.2 * K; at < long; at += 1.2 * K)
+            seams += `M${n(at)} 0V${n(H)}`;
+        svg += `<path class="u-panel" fill="none" d="${seams}"/>`;
+    }
+    // The kamiza: on its wall a recessed alcove of darker wood with a white-framed shrine and a hanging scroll in it, a tall purple banner (plain) beside it; the dark banner of the room's data stands in front (ours).
+    const kamiza = room.banners.find((m) => m.wall === w.side);
+    if (panelled && kamiza !== undefined) {
+        const [bx0, by0, bx1, by1] = box(kamiza.box);
+        const centreAt = ((bx0 + bx1) / 2 - ax) * dx + ((by0 + by1) / 2 - ay) * dy;
+        const z = (m) => H - m * K;
+        const m2 = K;
+        svg += `<rect class="u-alcove" x="${n(centreAt - 2.2 * m2)}" y="${n(z(3.4))}" width="${n(4.4 * m2)}" height="${n(3.2 * m2)}"/><path class="u-frame" fill="none" d="M${n(centreAt - 2.2 * m2)} ${n(z(0.2))}V${n(z(3.4))}H${n(centreAt + 2.2 * m2)}V${n(z(0.2))}"/>`;
+        svg += `<rect class="u-shrinef" x="${n(centreAt - 1.7 * m2)}" y="${n(z(1.9))}" width="${n(1.1 * m2)}" height="${n(0.9 * m2)}"/><rect class="u-scroll" x="${n(centreAt + 0.9 * m2)}" y="${n(z(2.9))}" width="${n(0.55 * m2)}" height="${n(1.5 * m2)}"/>`;
+        svg += `<rect class="u-purple" x="${n(centreAt + 2.9 * m2)}" y="${n(z(3.5))}" width="${n(0.9 * m2)}" height="${n(2.7 * m2)}"/>`;
+    }
+    for (const { o, kind } of openings) {
+        if (o.wall !== w.side)
+            continue;
+        const [x0, y0, x1, y1] = box(o.box);
+        const s = [(x0 - ax) * dx + (y0 - ay) * dy, (x1 - ax) * dx + (y1 - ay) * dy].sort((p, q) => p - q);
+        const top = H - o.head * K;
+        const height = (o.head - o.sill) * K;
+        const width = s[1] - s[0];
+        svg += `<rect class="u-${kind}" x="${n(s[0])}" y="${n(top)}" width="${n(width)}" height="${n(height)}"/>`;
+        // A door has a leaf's panels; a window its sash, a cross.
+        svg += kind === "window" ? `<path class="u-sash" fill="none" d="M${n(s[0] + width / 2)} ${n(top)}v${n(height)}M${n(s[0])} ${n(top + height / 2)}h${n(width)}"/>` : `<path class="u-sash" fill="none" d="M${n(s[0] + width / 2)} ${n(top)}v${n(height)}"/>`;
+    }
+    return shy(wall(`wall-${w.side}`, "wall", ax, ay, bx, by, 0, H, svg), centre);
+}
+/** The banner on the kamiza's wall: a plain dark band, drawn on its own plane in front of the wall's inner face. */
+function bannerPlane(room, centre) {
+    return room.banners.map((b) => {
+        const [x0, y0, x1, y1] = box(b.box);
+        const alongX = x1 - x0 >= y1 - y0;
+        // The face of the banner's footprint that is nearest the room.
+        const face = b.wall === "north" ? y1 : b.wall === "south" ? y0 : b.wall === "west" ? x1 : x0;
+        const [ax, ay, bx, by] = alongX ? [x0, face, x1, face] : [face, y0, face, y1];
+        const long = Math.hypot(bx - ax, by - ay);
+        const h = (b.top - b.bottom) * K;
+        return shy(wall(b.id, "banner", ax, ay, bx, by, b.bottom * K, b.top * K, `<rect class="u-banner" width="${n(long)}" height="${n(h)}"/><path class="u-bannerline" fill="none" d="M${n(long * 0.08)} ${n(h * 0.06)}H${n(long * 0.92)}M${n(long * 0.08)} ${n(h * 0.94)}H${n(long * 0.92)}"/>`), centre);
+    });
+}
+/**
+ * One balcony: its rows of seats as steps (a tread of seats and a riser to each row, the first row a step over the gallery's floor and the last at the height the gallery's data gives), a rail along its front
+ * edge, and a wall behind the last row. The room's wall stays below the gallery's floor: the gallery overlooks the floor over it.
+ */
+function balconyPlanes(b, pid, people, centre, room) {
+    const [x0, y0, x1, y1] = box(b.box);
+    // The direction away from the room, and the front edge of the balcony: the line along it nearest the room.
+    const out = b.side === "north" ? [0, -1] : b.side === "south" ? [0, 1] : b.side === "west" ? [-1, 0] : [1, 0];
+    const front = b.side === "north" ? [[x0, y1], [x1, y1]] : b.side === "south" ? [[x0, y0], [x1, y0]] : b.side === "west" ? [[x1, y0], [x1, y1]] : [[x0, y0], [x0, y1]];
+    const at = (offset) => [[front[0][0] + out[0] * offset, front[0][1] + out[1] * offset], [front[1][0] + out[0] * offset, front[1][1] + out[1] * offset]];
+    const floor = b.height * K;
+    const rise = b.rowRise * K;
+    const row = (b.box.x1 - b.box.x0 > b.box.y1 - b.box.y0 ? b.box.y1 - b.box.y0 : b.box.x1 - b.box.x0) * K / b.rows;
+    const planes = [];
+    const long = Math.hypot(front[1][0] - front[0][0], front[1][1] - front[0][1]);
+    for (let r = 0; r < b.rows; r += 1) {
+        const [a, c] = at(r * row);
+        const [d] = at((r + 1) * row);
+        const z = floor + (r + 1) * rise;
+        // The tread: a dark floor with the aisles across it in lighter wood and the blocks of seats between them, flat at the row's height. The riser under its front edge is dark too, with the stairs of the aisles in lighter wood.
+        const blocks = seatBlocks(b, row);
+        const tread = plane(`gallery-${b.side}-${r + 1}`, "seats", [a[0], a[1], z], [c[0] - a[0], c[1] - a[1], 0], [d[0] - a[0], d[1] - a[1], 0], `<rect class="u-gbed" width="${n(long)}" height="${n(row)}"/><path class="u-aisle" d="${blocks.aisles}"/><path fill="url(#${pid}-${b.side}-seat)" d="${blocks.seats}"/>${people ? `<path fill="url(#${pid}-cr-h)" d="${blocks.seats}"/>` : ""}`);
+        planes.push({ ...tread, shy: out, fadeTo: 0.01 });
+        const stairs = blocks.pieces.map(([x, w]) => `M${n(x)} 0h${n(w)}v${n(rise)}h${n(-w)}Z`).join("");
+        planes.push(shy(wall(`gallery-${b.side}-riser-${r + 1}`, "fascia", a[0], a[1], c[0], c[1], z - rise, z, `<rect class="u-gbed u-riser" width="${n(long)}" height="${n(rise)}"/><path class="u-aisle u-stair" d="${stairs}"/>`), centre));
+    }
+    // The floor slab projects from the wall over the room: its edge is a wall's thickness and half a metre in front of the first row, with a band of its thickness under it, and the rail stands on that edge.
+    const wallT = room.walls[0]?.thickness ?? 0.3;
+    const reach = (wallT + SLAB_PROJECTION) * K;
+    const [fa, fc] = at(-reach);
+    const slabT = SLAB * K;
+    planes.push({ ...plane(`gallery-${b.side}-slab`, "platform", [fa[0], fa[1], floor], [fc[0] - fa[0], fc[1] - fa[1], 0], [front[0][0] - fa[0], front[0][1] - fa[1], 0], `<rect class="u-slab" width="${n(long)}" height="${n(reach)}"/>`), shy: out, fadeTo: 0.01 });
+    planes.push(shy(wall(`gallery-${b.side}-slab-edge`, "fascia", fa[0], fa[1], fc[0], fc[1], floor - slabT, floor, `<rect class="u-slabedge" width="${n(long)}" height="${n(slabT)}"/>`), centre));
+    // The rail along the slab's edge, white: a top bar and posts about every half metre.
+    const rail = b.rail * K;
+    let posts = "";
+    for (let s2 = 0; s2 <= long + 0.01; s2 += (1 / 0.3048) / 2)
+        posts += `M${n(Math.min(s2, long))} 0V${n(rail)}`;
+    planes.push(shy(wall(`rail-${b.side}`, "rail", fa[0], fa[1], fc[0], fc[1], floor, floor + rail, `<path class="u-railline" fill="none" d="M0 0H${n(long)}M0 ${n(rail / 2)}H${n(long)}${posts}"/>`), centre));
+    // The wall behind the last row, up to the ceiling, with the large windows high in it on the side that has them.
+    const [e0, e1] = at(b.rows * row);
+    const top = room.ceiling === undefined ? floor + b.rows * rise + rail : room.ceiling.height * K;
+    // Plain off-white above the seats; on the kamiza's side a round clock at the middle and a door at each end, high in the wall (ours).
+    let back = `<rect class="u-room" width="${n(long)}" height="${n(top)}"/>`;
+    if (room.banners.some((m) => m.wall === b.side)) {
+        const seatsTop = floor + b.rows * rise + rail;
+        const cr = 0.6 * K;
+        const cy = top - (room.ceiling === undefined ? 1.6 : 2.2) * K;
+        back += `<circle class="u-clockface" cx="${n(long / 2)}" cy="${n(cy)}" r="${n(cr)}"/><path class="u-clockhands" fill="none" d="M${n(long / 2)} ${n(cy)}v${n(-cr * 0.7)}M${n(long / 2)} ${n(cy)}l${n(cr * 0.45)} ${n(cr * 0.2)}"/>`;
+        for (const at of [long * 0.06, long * 0.94 - 1.8 * K])
+            back += `<rect class="u-door" x="${n(at)}" y="${n(top - seatsTop > 0 ? top - (seatsTop + 0.4 * K + 2.1 * K) : 0)}" width="${n(1.8 * K)}" height="${n(2.1 * K)}"/>`;
+    }
+    for (const w of room.upperWindows) {
+        if (w.side !== b.side)
+            continue;
+        // The stretch along the wall is measured from the balcony's start, which is the wall's start side of the box.
+        const s0 = w.from * K;
+        const s1 = w.to * K;
+        back += `<rect class="u-window" x="${n(s0)}" y="${n(top - w.head * K)}" width="${n(s1 - s0)}" height="${n((w.head - w.sill) * K)}"/><path class="u-sash" fill="none" d="M${n((s0 + s1) / 2)} ${n(top - w.head * K)}v${n((w.head - w.sill) * K)}M${n(s0)} ${n(top - ((w.head + w.sill) / 2) * K)}h${n(s1 - s0)}"/>`;
+    }
+    planes.push(shy(wall(`gallery-back-${b.side}`, "fascia", e0[0], e0[1], e1[0], e1[1], 0, top, back), centre));
+    return planes;
+}
+/** The raised parts of a budō surface's room: what `dojoRoom()` says, for the options. An empty venue for a surface with no room. */
+export function roomVenue(o, v, lift) {
+    const room = dojoRoom(o);
+    if (room === undefined)
+        return NO_VENUE;
+    const centre = [((room.floor.x0 + room.floor.x1) / 2) * K, ((room.floor.y0 + room.floor.y1) / 2) * K];
+    const items = [];
+    let defs = "";
+    // Walls with their openings.
+    const openings = [...room.doors.map((o2) => ({ o: o2, kind: "door" })), ...room.windows.map((o2) => ({ o: o2, kind: "window" }))];
+    const walls = room.walls.flatMap((w) => wallPlane(w, openings, centre, room) ?? []);
+    if (walls.length > 0)
+        items.push({ id: "walls", kind: "walls", at: centre, height: Math.max(...room.walls.map((w) => (w.height ?? 0) * K)), planes: walls });
+    // The seat of honour's dais, the banner and the shrine.
+    for (const p of room.platforms) {
+        if (p.id !== "dais")
+            continue;
+        items.push({ id: "dais", kind: "dais", at: [((p.box.x0 + p.box.x1) / 2) * K, ((p.box.y0 + p.box.y1) / 2) * K], height: p.height * K, planes: block("dais", "platform", p.box, 0, p.height * K, "u-dais-side", "u-dais", centre) });
+    }
+    if (room.banners.length > 0)
+        items.push({ id: "banner", kind: "banner", at: centre, height: Math.max(...room.banners.map((b) => b.top)) * K, planes: bannerPlane(room, centre) });
+    if (room.shrine !== undefined)
+        items.push({ id: "shrine", kind: "shrine", at: [((room.shrine.box.x0 + room.shrine.box.x1) / 2) * K, ((room.shrine.box.y0 + room.shrine.box.y1) / 2) * K], height: room.shrine.height * K, planes: block("shrine", "shrine", room.shrine.box, 0, room.shrine.height * K, "u-shrine-side", "u-shrine", centre) });
+    // The balconies, with the crowd of the drawing in them (a few people when it has one, the empty seats when it has none).
+    if (room.balconies.length > 0) {
+        const crowd = resolveCrowd(o.crowd);
+        const fine = (crowd === undefined || crowd.detail !== "plain") && o.detail !== "simple";
+        const own = crowd ?? resolveCrowd(true);
+        // The seats at a seat's 2 by 2.3 feet; a gallery is empty unless the options say how full.
+        const seats = room.balconies.reduce((sum, b) => sum + ((b.box.x1 - b.box.x0) * (b.box.y1 - b.box.y0) * K * K) / 4.6, 0);
+        const density = crowd === undefined ? 0 : crowd.density !== undefined || crowd.attendance !== undefined ? densityOf(own, seats, undefined) : 0;
+        const pid = `${v.id}-v`;
+        for (const bal of room.balconies)
+            defs += seatTile(`${pid}-${bal.side}`, bal.seatWidth * K, bal.rowDepth * K);
+        if (fine && density > 0)
+            defs += patterns(pid, own, density, undefined, true, true);
+        const planes = room.balconies.flatMap((b) => balconyPlanes(b, pid, density > 0 && fine, centre, room));
+        const top = Math.max(...room.balconies.map((b) => (b.height + b.rows * b.rowRise) * K));
+        items.push({ id: "gallery", kind: "gallery", at: centre, height: top, planes });
+        // A pale ceiling over the galleries when a roof is asked for: a strip over each, open over the floor so that the floor is never hidden.
+        if (v.roof === true && room.ceiling !== undefined) {
+            const z = room.ceiling.height * K;
+            // A pale grey band, with a box light every 6 m or so along it.
+            const ceiling = room.balconies.map((b) => {
+                const w = (b.box.x1 - b.box.x0) * K;
+                const h = (b.box.y1 - b.box.y0) * K;
+                const alongX = w >= h;
+                const long = alongX ? w : h;
+                const wide = alongX ? h : w;
+                let lights = "";
+                for (let at = 3 * K; at < long - 2 * K; at += 6 * K)
+                    lights += alongX ? `<rect class="u-light" x="${n(at)}" y="${n(wide * 0.3)}" width="${n(1.2 * K)}" height="${n(wide * 0.4)}"/>` : `<rect class="u-light" x="${n(wide * 0.3)}" y="${n(at)}" width="${n(wide * 0.4)}" height="${n(1.2 * K)}"/>`;
+                return shy(flat(`ceiling-${b.side}`, "roof", ...box(b.box), z, `<rect class="u-ceiling" width="${n(w)}" height="${n(h)}"/>${lights}`), centre);
+            });
+            items.push({ id: "roof", kind: "roof", at: centre, height: z, planes: ceiling });
+        }
+    }
+    // The edge of the mats: they stand a few centimetres over the floor round them (the IJF's 5 cm), so that their thickness shows at the outer edge.
+    if (room.mats !== undefined) {
+        const m = room.surround?.inner ?? room.floor;
+        const t = Math.max(room.mats.thickness * K, LEAST_EDGE);
+        const [x0, y0, x1, y1] = box(m);
+        const side = room.mats.edge === "rounded" ? "u-matedge u-rounded" : "u-matedge";
+        const edge = (a, b, c, d, i) => shy(wall(`mat-edge-${i}`, "matedge", a, b, c, d, lift - t, lift, `<rect class="${side}" width="${n(Math.hypot(c - a, d - b))}" height="${n(t)}"/>`), centre);
+        items.push({ id: "mat-edge", kind: "mat-edge", at: centre, height: room.mats.thickness * K, planes: [edge(x0, y0, x1, y0, 1), edge(x1, y0, x1, y1, 2), edge(x1, y1, x0, y1, 3), edge(x0, y1, x0, y0, 4)] });
+    }
+    // The ground the balconies stand on: how far they reach beyond the floor.
+    const f = room.floor;
+    const reach = room.balconies.reduce((most, b) => Math.max(most, f.x0 - b.box.x0, f.y0 - b.box.y0, b.box.x1 - f.x1, b.box.y1 - f.y1), 0) * K;
+    return { items, defs, reach: reach > 0 ? reach + 3 : 0 };
+}

package/dist/version.d.ts

@@ -1,2 +1,2 @@
 /** The package's version: the same as package.json's, and a test holds them to each other. */
-export declare const VERSION = "0.7.0";
+export declare const VERSION = "0.8.0";

package/dist/version.js

@@ -1,2 +1,2 @@
 /** The package's version: the same as package.json's, and a test holds them to each other. */
-export const VERSION = "0.7.0";
+export const VERSION = "0.8.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@johnmorrisdotca/kyogijo-stadiums",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Kyogijo Stadiums 競技場, 39 sports' surfaces as SVG, drawn to scale from the rulebooks: NFL, CFL and IFAF football fields, an NHL rink, an NBA court, MLB ballparks, soccer pitches, curling sheets, athletics stadiums, speed skating, short track and figure skating rinks, swimming pools, water polo fields, diving wells, artistic swimming areas, and the courts and fields of tennis, volleyball (indoor, beach and sitting), badminton, pickleball, table tennis, padel, squash, racquetball, sepak takraw, teqball, roundnet, netball, lacrosse, rugby, Australian football, Gaelic games, cricket, field hockey and handball, and the budo of judo, karate, kendo, sumo and kyudo with a dojo of tatami laid as real units, with each team's name and logo on its side and the score in the middle, stands and a crowd, a pageant of flags, and a 3D view. Light and dark, accessible, a compact badge for lists, a helper for React and a custom element. Zero dependencies.",
   "keywords": [
     "sports",