@johnmorrisdotca/kyogijo-stadiums 0.24.0 → 0.27.0

package/dist/stadiums.d.ts

@@ -0,0 +1,158 @@
+import { type Box, type Pt, type RealBowl } from "./crowd.ts";
+import { type Ground } from "./grounds.ts";
+import { VENUE_ATTRIBUTION } from "./venues.ts";
+export { VENUE_ATTRIBUTION };
+/** How a fact is known: `documented` is what a source cited with it says; `plausible` is ours, for a bowl no source describes. */
+export type StadiumBasis = "documented" | "plausible";
+/** The configurations of a stadium: the field the seats are counted for. `cfl` is the football field of the Canadian league, `soccer` a soccer pitch. */
+export type StadiumConfigId = "cfl" | "soccer";
+/** The kinds of roof the stadiums have: `cable` is a cable-supported roof with an opening over the field that a retractable fabric closes; `fixed` a lid over the bowl. */
+export type StadiumRoof = "cable" | "fixed";
+/** What one configuration of a stadium is: its sport and its seats, and where the figure was read. */
+export interface StadiumConfigData {
+    sport: "cfl" | "soccer";
+    /** The seats for this configuration: the infobox's figure for it, or Wikidata's. */
+    seats: number;
+    source: "wikidata" | "wikipedia";
+    /** What was read, in a few words of ours. */
+    read: string;
+}
+/** The facts of a stadium: the seats of each configuration, the number of bowls and the kind of roof, each with what a source says. No text of an article is kept. */
+export interface RealStadiumData {
+    /** The key: `bc-place`, the key of the stadium's ground in `GROUNDS`. */
+    id: string;
+    /** The Wikidata item of the stadium. */
+    wikidata: string;
+    /** The key of the stadium's ground in `GROUNDS` (its name, its place, its pitch). */
+    ground: string;
+    /** The English Wikipedia article the facts that are not Wikidata's were read from, at a revision. */
+    en: {
+        title: string;
+        revision: number;
+    };
+    configs: Record<StadiumConfigId, StadiumConfigData>;
+    tiers: {
+        /** The seating levels (bowls). */
+        count: 1 | 2 | 3;
+        basis: StadiumBasis;
+        /** The seats of the lowest bowl, where a source gives them: the lower tier's band holds this many whatever the configuration (the upper bowl is what is opened or closed for the others). */
+        lowerSeats?: number;
+        read: string;
+    };
+    roof: {
+        kind: StadiumRoof;
+        basis: StadiumBasis;
+        read: string; /** A cable roof's opening over the field, as the article gives it, in metres. */
+        opening?: {
+            length: number;
+            width: number;
+            unit: "m";
+        };
+    };
+}
+/** What OpenStreetMap gave of a stadium: ODbL 1.0 data, "(c) OpenStreetMap contributors". */
+export interface StadiumOsm {
+    /** The element the outline is: `way/24705904`. */
+    source: string;
+    read: string;
+    base: string;
+    licence: "ODbL-1.0";
+    attribution: string;
+    /** The roof OpenStreetMap maps over the building: its heights in metres (`height` to the top of the roof, `rise` of that the roof's own) and the opening in it as `[longitude, latitude]`. */
+    roof?: {
+        source: string;
+        height?: number;
+        rise?: number;
+        outer?: string;
+        opening?: {
+            source: string;
+            ring: [number, number][];
+        };
+    };
+    /** The building's outline as `[longitude, latitude]`, not repeating its first point. */
+    ring: [number, number][];
+    /**
+     * How the field lies, worked out when the data was made: the heading of its long side (degrees clockwise from north, 0 to under 180), how that is known (`opening`: from the roof's opening, which the article says is
+     * the field's size; `building`: from the long axis of the building's main hall, an inference; `none`: no direction, 90 is stood in), how much of a direction the building has (`strength`) and how much longer than
+     * wide the opening or the hall is (`elongation`), and the middle of the field as `[longitude, latitude]`.
+     */
+    axis: {
+        heading: number;
+        basis: "opening" | "building" | "none";
+        strength: number;
+        elongation: number;
+        centre: [number, number];
+    };
+}
+/** A stadium: its facts and what OpenStreetMap gave. */
+export interface RealStadium extends RealStadiumData {
+    osm: StadiumOsm;
+}
+/** How the field lies in the building: its long side's heading, how that is known, and the way north points on the page (degrees clockwise from the top). */
+export interface StadiumOrientation {
+    heading: number;
+    basis: "opening" | "building" | "none";
+    north: number;
+}
+/** The stadiums by key. */
+export declare const STADIUMS: Readonly<Record<string, RealStadium>>;
+/** The keys of `STADIUMS`, in the order of the data. */
+export declare const STADIUM_IDS: readonly string[];
+/** The stadium with a key, or `undefined`. */
+export declare const stadiumById: (id: string | undefined) => RealStadium | undefined;
+/** The stadium whose Wikidata item is `Q612227`, or `undefined`. */
+export declare const stadiumByWikidata: (wikidata: string | undefined) => RealStadium | undefined;
+/** The ground a stadium is (its name, place and pitch). */
+export declare const groundOfStadium: (stadium: RealStadium) => Ground;
+/** How the field lies in a stadium's building (see `StadiumOsm.axis`). */
+export declare const stadiumOrientation: (stadium: RealStadium) => StadiumOrientation;
+/** The configuration a sport is: `cfl` or `soccer`, or `undefined` for a sport a stadium has no configuration for. */
+export declare const stadiumConfigOf: (sport: string | undefined) => StadiumConfigId | undefined;
+/** The seats of a stadium for a configuration. */
+export declare const stadiumSeats: (stadium: RealStadium, config: StadiumConfigId) => number;
+/** The height of the first row above the field, in feet, the rise of a bowl's rows by the number of bowls (what the lowest, a middle and the upper rise, at most), and the rise of the walk between two bowls (a suite level): ours, no source gives them. */
+export declare const STADIUM_FIRST_HEIGHT = 5;
+export declare const STADIUM_RISES: Readonly<Record<1 | 2 | 3, readonly number[]>>;
+export declare const STADIUM_WALK_RISE = 24;
+/** The height a roof's rim stands over the top row, at the least, in feet. */
+export declare const STADIUM_CLEARANCE = 22;
+/** The plan of a stadium for a configuration: its building in the drawing's frame, the bowl fitted inside, and how it lies. */
+export interface StadiumPlan {
+    stadium: RealStadium;
+    config: StadiumConfigId;
+    orientation: StadiumOrientation;
+    /** The field, in the drawing's frame. */
+    box: Box;
+    /** The building's outline in feet, in the drawing's frame (the field's long side along x, in the middle of the building's hall). */
+    footprint: Pt[];
+    /** The roof's opening in feet, in the drawing's frame, where OpenStreetMap maps it. */
+    opening: Pt[] | undefined;
+    /** The stands for `layoutOf`: bowls, first row, ground, and the building and roof. */
+    bowl: RealBowl;
+    /** The seats the bowls hold, by bowl, and in all: equal to the configuration's seats where the building has room (`fit` is `fits`). */
+    seats: {
+        tier: string;
+        seats: number;
+    }[];
+    total: number;
+    /** The floor a seat takes in the plan, in square feet (one of `SEAT_AREAS`). */
+    seatArea: number;
+    fit: "fits" | "tight";
+}
+/**
+ * The plan of a stadium's bowl for a configuration: the building's outline turned so that the field lies along x, a first row round a football field's footprint as a gridiron's stands have it, the largest bowl-shaped
+ * outline that fits the building round the middle of the field, and between the two the bowls, the outer edge of each placed so that its band holds the share of the configuration's seats the sources give it, with a walk
+ * between them. The bowl is the same building for football and soccer (the seats of the configuration differ, and the field).
+ * @example
+ * ```ts
+ * import { planStadium, stadiumById } from "@johnmorrisdotca/kyogijo-stadiums/stadiums";
+ * const plan = planStadium(stadiumById("bc-place")!, "soccer", { x: 0, y: 0, w: 344.5, h: 223.1 });
+ * console.log(plan.orientation.basis, plan.seats.map((t) => t.tier).join(" "), plan.total);
+ * // opening lower upper 52497
+ * ```
+ */
+export declare function planStadium(stadium: RealStadium, config: StadiumConfigId, box: Box): StadiumPlan;
+/** The stands of a stadium for `layoutOf` and the 3D view, round a field: `planStadium`'s bowl. */
+export declare const stadiumBowl: (stadium: RealStadium, config: StadiumConfigId, box: Box) => RealBowl;
+/** Whether the bowl lies inside the building: every corner of every bowl's outer edge is inside the footprint. */
+export declare function stadiumBowlInside(plan: StadiumPlan): boolean;

package/dist/stadiums.data.d.ts

@@ -0,0 +1,2 @@
+import type { RealStadiumData } from "./stadiums.ts";
+export declare const STADIUM_DATA: RealStadiumData[];

package/dist/stadiums.data.js

@@ -0,0 +1,11 @@
+export const STADIUM_DATA = [
+    {
+        "id": "bc-place",
+        "wikidata": "Q612227",
+        "ground": "bc-place",
+        "en": { "title": "BC Place", "revision": 1372065649 },
+        "configs": { "cfl": { "sport": "cfl", "seats": 54500, "source": "wikipedia", "read": "the infobox's first capacity, 54,500, which Wikidata's capacity (P1083) also gives; the article's stand for football of the CFL's club" }, "soccer": { "sport": "soccer", "seats": 52497, "source": "wikipedia", "read": "the infobox's capacity for the 2026 world cup of soccer, 52,497, 2,003 fewer than its first" } },
+        "tiers": { "count": 2, "basis": "documented", "lowerSeats": 27695, "read": "the infobox's lower bowl of 27,695 seats, and the article's lower and upper bowls (the club that plays soccer there sold only the lower bowl)" },
+        "roof": { "kind": "cable", "basis": "documented", "read": "the article: a retractable roof supported by cables, the largest of its kind, its opening 100 by 85 metres (the size of the field), the fabric retracting into a pod in the middle of the opening above the suspended video board", "opening": { "length": 100, "width": 85, "unit": "m" } },
+    },
+];

package/dist/stadiums.js

@@ -0,0 +1,210 @@
+// The real stadiums: for a stadium that stages football and soccer, the outline of its building and the way its field lies in it (from OpenStreetMap, ODbL 1.0), and a bowl of the seats of each configuration, the
+// number of bowls and the kind of roof the sources give (Wikidata, CC0, and the English Wikipedia article each fact cites), fitted inside the outline. It is the stadium's counterpart of `venues.ts`, for a surface that is a
+// field and not a rink: level one is the building, level two a plausible bowl, and it stops there (no team's, ticket seller's or federation's seat map is read or copied, no section or row is named, and no mark of a club, a
+// league or a tournament is drawn). The drawing is `drawKyogijo({ sport: "cfl", stadium, crowd: { real: true } })` (or `sport: "soccer"` with a `ground` or a `stadium`) and, in 3D, the same options in `buildTurn`.
+import { NORTH_ROOM, aislesOf, areaOfOutline, outlinePoints } from "./crowd.js";
+import { FEET_PER_METRE, FOOTBALL } from "./geometry.js";
+import { groundById } from "./grounds.js";
+import { GAP, HALL, MAX_RAKE, SEAT_AREAS, WALL, VENUE_ATTRIBUTION } from "./venues.js";
+import { boxOf, edgeDistance, inside, metresFrom, middleOf, northOn, turnedTo } from "./venues.geo.js";
+import { STADIUM_DATA } from "./stadiums.data.js";
+import { STADIUM_OSM } from "./stadiums.osm.data.js";
+export { VENUE_ATTRIBUTION };
+/** The stadiums by key. */
+export const STADIUMS = Object.freeze(Object.fromEntries(STADIUM_DATA.map((data) => [data.id, Object.freeze({ ...data, osm: STADIUM_OSM[data.id] })])));
+/** The keys of `STADIUMS`, in the order of the data. */
+export const STADIUM_IDS = Object.freeze(STADIUM_DATA.map((data) => data.id));
+/** The stadium with a key, or `undefined`. */
+export const stadiumById = (id) => (id !== undefined && Object.prototype.hasOwnProperty.call(STADIUMS, id) ? STADIUMS[id] : undefined);
+/** The stadium whose Wikidata item is `Q612227`, or `undefined`. */
+export const stadiumByWikidata = (wikidata) => Object.values(STADIUMS).find((s) => s.wikidata === wikidata);
+/** The ground a stadium is (its name, place and pitch). */
+export const groundOfStadium = (stadium) => {
+    const ground = groundById(stadium.ground);
+    if (ground === undefined)
+        throw new Error(`${stadium.id} has no ground ${stadium.ground}`);
+    return ground;
+};
+const round = (value, places = 1) => Math.round(value * 10 ** places) / 10 ** places;
+const lonLat = (ring) => ring.map(([lon, lat]) => [lon, lat]);
+/** How the field lies in a stadium's building (see `StadiumOsm.axis`). */
+export const stadiumOrientation = (stadium) => ({ heading: stadium.osm.axis.heading, basis: stadium.osm.axis.basis, north: round(northOn(stadium.osm.axis.heading)) });
+/** The configuration a sport is: `cfl` or `soccer`, or `undefined` for a sport a stadium has no configuration for. */
+export const stadiumConfigOf = (sport) => (sport === "cfl" || sport === "soccer" ? sport : undefined);
+/** The seats of a stadium for a configuration. */
+export const stadiumSeats = (stadium, config) => stadium.configs[config].seats;
+// ---- The bowl. ----
+/** How far the first row is from a football field's footprint (the CFL's, the field and its end zones) along a side and at an end, and the corner's radius: the package's own gridiron profile (`crowd.ts`), so that a real stadium's first row is the usual one. */
+const FIRST_ROW = { side: 42, end: 28, corner: 60 };
+/** The height of the first row above the field, in feet, the rise of a bowl's rows by the number of bowls (what the lowest, a middle and the upper rise, at most), and the rise of the walk between two bowls (a suite level): ours, no source gives them. */
+export const STADIUM_FIRST_HEIGHT = 5;
+export const STADIUM_RISES = { 1: [60], 2: [38, 62], 3: [32, 26, 56] };
+export const STADIUM_WALK_RISE = 24;
+/** The height a roof's rim stands over the top row, at the least, in feet. */
+export const STADIUM_CLEARANCE = 22;
+/** The share of the seats in the lowest bowl where no source says. */
+const LOWER_SHARE = 0.5;
+const CORNER = 0.7;
+/** How many of a bowl's seats are taken, relative to the stands', as `crowd.ts` has them. */
+const FILL = { lower: 1, middle: 0.94, upper: 0.88 };
+const TIER_IDS = { 1: ["lower"], 2: ["lower", "upper"], 3: ["lower", "middle", "upper"] };
+const lerp = (a, b, t) => a + (b - a) * t;
+const between = (a, b, t) => ({ kind: "rrect", x0: lerp(a.x0, b.x0, t), y0: lerp(a.y0, b.y0, t), x1: lerp(a.x1, b.x1, t), y1: lerp(a.y1, b.y1, t), r: lerp(a.r, b.r, t) });
+/** The parameter in `[lo, hi]` at which an increasing function reaches `target` (bisection), or `hi` where it does not. */
+function solveFor(f, lo, hi, target) {
+    if (f(hi) <= target)
+        return hi;
+    let [a, b] = [lo, hi];
+    for (let i = 0; i < 48; i += 1) {
+        const m = (a + b) / 2;
+        if (f(m) < target)
+            a = m;
+        else
+            b = m;
+    }
+    return (a + b) / 2;
+}
+/** Plans already made, by stadium, configuration and field: a plan is a pure function of them, and a drawing asks for it more than once. */
+const PLANS = new WeakMap();
+/**
+ * The plan of a stadium's bowl for a configuration: the building's outline turned so that the field lies along x, a first row round a football field's footprint as a gridiron's stands have it, the largest bowl-shaped
+ * outline that fits the building round the middle of the field, and between the two the bowls, the outer edge of each placed so that its band holds the share of the configuration's seats the sources give it, with a walk
+ * between them. The bowl is the same building for football and soccer (the seats of the configuration differ, and the field).
+ * @example
+ * ```ts
+ * import { planStadium, stadiumById } from "@johnmorrisdotca/kyogijo-stadiums/stadiums";
+ * const plan = planStadium(stadiumById("bc-place")!, "soccer", { x: 0, y: 0, w: 344.5, h: 223.1 });
+ * console.log(plan.orientation.basis, plan.seats.map((t) => t.tier).join(" "), plan.total);
+ * // opening lower upper 52497
+ * ```
+ */
+export function planStadium(stadium, config, box) {
+    const key = `${config}|${box.x}|${box.y}|${box.w}|${box.h}`;
+    const mine = PLANS.get(stadium) ?? new Map();
+    PLANS.set(stadium, mine);
+    const known = mine.get(key);
+    if (known !== undefined)
+        return known;
+    const made = plan(stadium, config, box);
+    mine.set(key, made);
+    return made;
+}
+function plan(stadium, config, rink) {
+    const orientation = stadiumOrientation(stadium);
+    const origin = middleOf(lonLat(stadium.osm.ring));
+    const turned = (ring) => metresFrom(origin, lonLat(ring)).map((p) => turnedTo(orientation.heading, p));
+    const outline = turned(stadium.osm.ring);
+    const [middle] = turned([stadium.osm.axis.centre]);
+    const at = [rink.x + rink.w / 2, rink.y + rink.h / 2];
+    const place = (ring) => ring.map(([x, y]) => [round((x - middle[0]) * FEET_PER_METRE + at[0], 2), round((y - middle[1]) * FEET_PER_METRE + at[1], 2)]);
+    const footprint = place(outline);
+    const fb = boxOf(footprint);
+    const openingRing = stadium.osm.roof?.opening?.ring;
+    const opening = openingRing === undefined ? undefined : place(turned(openingRing));
+    // The first row round a football field's footprint, and the largest bowl-shaped outline that fits inside the building round the middle of the field.
+    const gridiron = FOOTBALL.cfl;
+    const length = gridiron.length + 2 * gridiron.endZone;
+    const first = { kind: "rrect", x0: at[0] - length / 2 - FIRST_ROW.end, y0: at[1] - gridiron.width / 2 - FIRST_ROW.side, x1: at[0] + length / 2 + FIRST_ROW.end, y1: at[1] + gridiron.width / 2 + FIRST_ROW.side, r: FIRST_ROW.corner };
+    const shapedAs = (long, s) => ({ kind: "rrect", x0: at[0] - long * s, y0: at[1] - s, x1: at[0] + long * s, y1: at[1] + s, r: CORNER * s });
+    const largest = (long) => {
+        let [lo, hi] = [60, Math.max(fb.x1 - fb.x0, fb.y1 - fb.y0)];
+        for (let i = 0; i < 24; i += 1) {
+            const m = (lo + hi) / 2;
+            if (outlinePoints(shapedAs(long, m)).every((p) => inside(footprint, p) && edgeDistance(footprint, p) >= WALL))
+                lo = m;
+            else
+                hi = m;
+        }
+        return lo;
+    };
+    const tries = [1.15, 1.25, 1.35, 1.45, 1.6].map((long) => ({ long, s: largest(long) }));
+    const best = tries.reduce((a, b) => (a.long * a.s * a.s >= b.long * b.s * b.s ? a : b));
+    const wall = shapedAs(best.long, best.s);
+    const outer = { ...wall, x0: Math.min(wall.x0, first.x0 - 40), y0: Math.min(wall.y0, first.y0 - 40), x1: Math.max(wall.x1, first.x1 + 40), y1: Math.max(wall.y1, first.y1 + 40) };
+    const depth = (first.x0 - outer.x0) + (first.y0 - outer.y0) + (outer.x1 - first.x1) + (outer.y1 - first.y1);
+    const gap = GAP / Math.max(20, depth / 4);
+    const seatsTotal = stadium.configs[config].seats;
+    const count = stadium.tiers.count;
+    const lower = stadium.tiers.lowerSeats === undefined ? (count === 1 ? 1 : count === 2 ? LOWER_SHARE : 0.36) : stadium.tiers.lowerSeats / seatsTotal;
+    const shares = count === 1 ? [1] : count === 2 ? [lower, 1 - lower] : [lower, (1 - lower) * 0.36, (1 - lower) * 0.64];
+    const outlineAt = (t) => between(first, outer, t);
+    const build = (area) => {
+        const seatsOf = (region, hole) => Math.round((areaOfOutline(region) - areaOfOutline(hole)) / area);
+        const rings = [];
+        let t0 = 0;
+        let tight = false;
+        let up = STADIUM_FIRST_HEIGHT;
+        shares.forEach((share, k) => {
+            const wanted = seatsTotal * share;
+            const t1 = solveFor((t) => seatsOf(outlineAt(t), outlineAt(t0)), t0, 1, wanted);
+            if (seatsOf(outlineAt(t1), outlineAt(t0)) < wanted - 1)
+                tight = true;
+            const region = outlineAt(t1);
+            const hole = outlineAt(t0);
+            const tier = TIER_IDS[count][k];
+            const run = (region.y1 - hole.y1 + (hole.y0 - region.y0)) / 2;
+            const rise = Math.min(STADIUM_RISES[count][k], Math.max(6, run * Math.tan((MAX_RAKE * Math.PI) / 180)));
+            const h0 = k === 0 ? STADIUM_FIRST_HEIGHT : up + STADIUM_WALK_RISE;
+            const h1 = h0 + rise;
+            up = h1;
+            rings.push({
+                id: tier,
+                tier,
+                region,
+                hole,
+                from: round(hole.y1 - first.y1, 2),
+                to: round(region.y1 - first.y1, 2),
+                height: [round(h0), round(h1)],
+                rake: round((Math.atan2(h1 - h0, Math.max(1, run)) * 180) / Math.PI),
+                fill: FILL[tier],
+                seats: seatsOf(region, hole),
+                aisles: aislesOf(region, hole),
+            });
+            t0 = Math.min(1, t1 + gap);
+        });
+        return { rings, tight };
+    };
+    let seatArea = SEAT_AREAS[0];
+    let made = build(seatArea);
+    for (const area of SEAT_AREAS.slice(1)) {
+        if (!made.tight)
+            break;
+        seatArea = area;
+        made = build(area);
+    }
+    const { rings, tight } = made;
+    // The rounding of each bowl's seats leaves the total a seat or two off the configuration's: the last bowl takes the difference.
+    const missing = seatsTotal - rings.reduce((sum, ring) => sum + ring.seats, 0);
+    if (!tight && Math.abs(missing) <= 3)
+        rings[rings.length - 1].seats += missing;
+    const total = rings.reduce((sum, ring) => sum + ring.seats, 0);
+    const top = rings[rings.length - 1].height[1];
+    const roof = stadium.osm.roof;
+    const rise = roof?.rise === undefined ? 0 : round(roof.rise * FEET_PER_METRE);
+    // The rim of the roof stands where OpenStreetMap maps it (its height less the roof's own rise), and at the least over the top row by a roof's clearance.
+    const mapped = roof?.height === undefined ? 0 : round((roof.height - (roof.rise ?? 0)) * FEET_PER_METRE);
+    const edge = Math.max(mapped, top + STADIUM_CLEARANCE);
+    const cable = stadium.roof.kind === "cable" && opening !== undefined && rise > 0;
+    const north = orientation.basis === "none" ? undefined : orientation.north;
+    const room = north === undefined ? 0 : NORTH_ROOM;
+    const bowl = {
+        rings,
+        off: { left: rink.x - first.x0, right: first.x1 - rink.x - rink.w, top: rink.y - first.y0, bottom: first.y1 - rink.y - rink.h },
+        reach: { left: Math.max(0, rink.x - fb.x0), right: Math.max(0, fb.x1 - rink.x - rink.w), top: Math.max(0, rink.y - fb.y0) + room, bottom: Math.max(0, fb.y1 - rink.y - rink.h) },
+        shell: {
+            footprint,
+            hall: { ...outer, x0: outer.x0 - HALL, y0: outer.y0 - HALL, x1: outer.x1 + HALL, y1: outer.y1 + HALL, r: outer.r + HALL },
+            ...(north === undefined ? {} : { north }),
+            roof: cable ? "cable" : "fixed",
+            edge,
+            ...(cable ? { crown: { rise, opening } } : {}),
+        },
+    };
+    return { stadium, config, orientation, box: rink, footprint, opening, bowl, seats: rings.map((ring) => ({ tier: ring.tier, seats: ring.seats })), total, seatArea, fit: tight ? "tight" : "fits" };
+}
+/** The stands of a stadium for `layoutOf` and the 3D view, round a field: `planStadium`'s bowl. */
+export const stadiumBowl = (stadium, config, box) => planStadium(stadium, config, box).bowl;
+/** Whether the bowl lies inside the building: every corner of every bowl's outer edge is inside the footprint. */
+export function stadiumBowlInside(plan) {
+    return outlinePoints(plan.bowl.rings[plan.bowl.rings.length - 1].region).every((p) => inside(plan.footprint, p));
+}

package/dist/stadiums.osm.data.d.ts

@@ -0,0 +1,2 @@
+import type { StadiumOsm } from "./stadiums.ts";
+export declare const STADIUM_OSM: Record<string, StadiumOsm>;

package/dist/stadiums.osm.data.js

@@ -0,0 +1,58 @@
+export const STADIUM_OSM = {
+    "bc-place": {
+        "source": "way/24705904",
+        "read": "2026-10-20",
+        "base": "2026-10-20T21:46:16Z",
+        "licence": "ODbL-1.0",
+        "attribution": "(c) OpenStreetMap contributors, ODbL 1.0, openstreetmap.org/copyright",
+        "axis": { "heading": 52.8, "basis": "opening", "strength": 1.47, "elongation": 1.19, "centre": [-123.112002, 49.276698] },
+        "roof": {
+            "source": "relation/5836463",
+            "height": 61,
+            "rise": 13,
+            "outer": "way/390133856",
+            "opening": { "source": "way/390133855", "ring": [
+                    [-123.111972, 49.277139],
+                    [-123.112337, 49.277016],
+                    [-123.112599, 49.276841],
+                    [-123.112723, 49.276687],
+                    [-123.112664, 49.276512],
+                    [-123.11246, 49.276337],
+                    [-123.112245, 49.276253],
+                    [-123.112009, 49.276257],
+                    [-123.111607, 49.276414],
+                    [-123.111323, 49.276614],
+                    [-123.111296, 49.276806],
+                    [-123.111403, 49.276943],
+                    [-123.111564, 49.277065],
+                    [-123.111757, 49.277146],
+                ] },
+        },
+        "ring": [
+            [-123.113517, 49.276312],
+            [-123.113285, 49.276073],
+            [-123.112893, 49.275773],
+            [-123.112614, 49.275683],
+            [-123.112399, 49.27566],
+            [-123.112137, 49.275686],
+            [-123.11166, 49.275795],
+            [-123.111225, 49.275999],
+            [-123.110853, 49.276199],
+            [-123.110572, 49.276409],
+            [-123.110433, 49.276556],
+            [-123.110371, 49.276724],
+            [-123.110396, 49.276902],
+            [-123.110692, 49.277303],
+            [-123.111152, 49.277629],
+            [-123.111379, 49.277714],
+            [-123.111649, 49.277751],
+            [-123.111894, 49.277728],
+            [-123.112475, 49.277543],
+            [-123.112833, 49.277379],
+            [-123.113189, 49.27718],
+            [-123.113573, 49.276831],
+            [-123.113643, 49.276657],
+            [-123.113623, 49.276478],
+        ],
+    },
+};

package/dist/strings.d.ts

@@ -504,6 +504,23 @@ export interface KyogijoWords {
         arenaSize: string;
         /** An arena whose rink is said to have been shorter than the NHL's, with no size given: {arena}. */
         arenaUnknown: string;
+        /** The stands of an arena's real venue: {seats} seats in {tiers} tiers, fitted inside the outline of {arena}'s building from OpenStreetMap. */
+        real: string;
+        /** How the rink lies in it: along the building's long axis (an inference), as OpenStreetMap maps the ice, or not known. */
+        realBuilding: string;
+        realMapped: string;
+        realNone: string;
+        /** The stands of a stadium's real venue: {seats} seats in {tiers} bowls, fitted inside the outline of {stadium}'s building from OpenStreetMap. */
+        stadium: string;
+        /** How the field lies in it: along the roof's opening (which is the field's size), along the building's long axis (an inference), or not known. */
+        stadiumOpening: string;
+        stadiumBuilding: string;
+        stadiumNone: string;
+        /** A district: a plan of {count} real venues at their real positions, {mode}; and what `mode` says for the two kinds of plan, and the word before the credit. */
+        district: string;
+        districtNeighbours: string;
+        districtCity: string;
+        districtCredit: string;
         /** A game decided on penalties: {name}, and the shoot-out score {a}-{b}, winner first. */
         wonPens: string;
         /** The shoot-out, as it is written beside a status: {a} and {b}, in the order of the sides on the drawing. */

package/dist/strings.js

@@ -199,7 +199,7 @@ export const KYOGIJO_STRINGS = {
             },
         },
         scoreTitle: "{away} {awayScore}, {home} {homeScore}",
-        said: { home: "home", away: "away", won: "{name} won.", tied: "The game is level.", park: "The outfield fence follows the figures published for {park}.", officially: "Its official name is {name}.", ground: "The pitch follows the size published for {ground}.", groundDefault: "No pitch size is published for {ground}, so the pitch has the international size of 105 by 68 metres.", arenaRink: "{arena}, hockey rink", arenaCourt: "{arena}, basketball court", arenaRinkAbout: "an ice hockey rink, {length} by {width} feet ({lengthM} by {widthM} metres) with rounded corners, with its red and blue lines, face-off circles, creases and goal nets", arenaCourtAbout: "a basketball court, {length} by {width} feet ({lengthM} by {widthM} metres), with its keys, three-point lines, free-throw circles and the centre circle", arenaSize: "The size is the one published for {arena}.", arenaUnknown: "The article says the rink of {arena} was shorter than the NHL's but gives no size, so the NHL's is drawn.", era: "The markings are those of the {season} season.", hammer: "{name} has the hammer.", ends: "By end, {name}: {list}.", total: "Total", wonPens: "{name} won {a}-{b} on penalties.", pens: "{a}-{b} pens", on: "Drawn as", sep: ", ", stop: ".", colon: ": ", gap: " " },
+        said: { home: "home", away: "away", won: "{name} won.", tied: "The game is level.", park: "The outfield fence follows the figures published for {park}.", officially: "Its official name is {name}.", ground: "The pitch follows the size published for {ground}.", groundDefault: "No pitch size is published for {ground}, so the pitch has the international size of 105 by 68 metres.", arenaRink: "{arena}, hockey rink", arenaCourt: "{arena}, basketball court", arenaRinkAbout: "an ice hockey rink, {length} by {width} feet ({lengthM} by {widthM} metres) with rounded corners, with its red and blue lines, face-off circles, creases and goal nets", arenaCourtAbout: "a basketball court, {length} by {width} feet ({lengthM} by {widthM} metres), with its keys, three-point lines, free-throw circles and the centre circle", arenaSize: "The size is the one published for {arena}.", arenaUnknown: "The article says the rink of {arena} was shorter than the NHL's but gives no size, so the NHL's is drawn.", real: "The stands are a plausible bowl of {seats} seats in {tiers} tiers, fitted inside the outline of the building of {arena} from OpenStreetMap ((c) OpenStreetMap contributors); it is not the arena's plan.", realBuilding: "The rink lies along the building's long axis, which is an inference, and the arrow points north.", realMapped: "The rink lies as OpenStreetMap maps the ice, and the arrow points north.", realNone: "The rink's orientation is not known, so it is drawn east-west with north at the top.", stadium: "The stands are a plausible bowl of {seats} seats in {tiers} bowls, fitted inside the outline of the building of {stadium} from OpenStreetMap ((c) OpenStreetMap contributors); it is not the stadium's plan.", stadiumOpening: "The field lies along the opening in the roof, which is the size of the field, and the arrow points north.", stadiumBuilding: "The field lies along the building's long axis, which is an inference, and the arrow points north.", stadiumNone: "The field's orientation is not known, so it is drawn east-west with north at the top.", district: "A plan of {count} real venues at their real positions and orientations, from the outlines OpenStreetMap maps; {mode}.", districtNeighbours: "it is fitted close round the buildings", districtCity: "it keeps the real distances, with a grid of kilometres and a scale", districtCredit: "Credit:", era: "The markings are those of the {season} season.", hammer: "{name} has the hammer.", ends: "By end, {name}: {list}.", total: "Total", wonPens: "{name} won {a}-{b} on penalties.", pens: "{a}-{b} pens", on: "Drawn as", sep: ", ", stop: ".", colon: ": ", gap: " " },
         budo: {
             sides: { north: "north", south: "south", east: "east", west: "west" },
             judo: "a judo contest area of {contest} by {contest} metres in a safety area {safety} metres wide, laid with tatami of {tatami}",
@@ -758,7 +758,7 @@ export const KYOGIJO_STRINGS = {
             },
         },
         scoreTitle: "{away} {awayScore}、{home} {homeScore}",
-        said: { home: "ホーム", away: "アウェイ", won: "{name}の勝ちです。", tied: "同点です。", park: "外野フェンスは、{park}の公表されている距離をもとに描かれています。", officially: "正式名称は{name}です。", ground: "ピッチは、{ground}の公表されている広さをもとに描かれています。", groundDefault: "{ground}のピッチの広さは公表されていないため、国際標準の105×68mで描かれています。", arenaRink: "{arena}のアイスホッケーリンク", arenaCourt: "{arena}のバスケットボールコート", arenaRinkAbout: "アイスホッケーのリンク。{length}フィート（約{lengthM}m）×{width}フィート（約{widthM}m）で角が丸く、レッドライン、ブルーライン、フェイスオフサークル、クリース、ゴールがあります", arenaCourtAbout: "バスケットボールのコート。{length}フィート（約{lengthM}m）×{width}フィート（約{widthM}m）で、ペイントエリア、スリーポイントライン、フリースローサークル、センターサークルがあります", arenaSize: "広さは、{arena}の公表されている数値をもとに描かれています。", arenaUnknown: "{arena}のリンクはNHLの規格より短かったとされていますが、広さが示されていないため、NHLの規格で描かれています。", era: "ラインやマークは{season}シーズンのものです。", hammer: "{name}がハンマー（最後の1投）を持っています。", ends: "{name}のエンドごとの得点：{list}。", total: "合計", wonPens: "{name}がPK戦を{a}-{b}で制しました。", pens: "PK戦 {a}-{b}", on: "図の内容", sep: "、", stop: "。", colon: "：", gap: "" },
+        said: { home: "ホーム", away: "アウェイ", won: "{name}の勝ちです。", tied: "同点です。", park: "外野フェンスは、{park}の公表されている距離をもとに描かれています。", officially: "正式名称は{name}です。", ground: "ピッチは、{ground}の公表されている広さをもとに描かれています。", groundDefault: "{ground}のピッチの広さは公表されていないため、国際標準の105×68mで描かれています。", arenaRink: "{arena}のアイスホッケーリンク", arenaCourt: "{arena}のバスケットボールコート", arenaRinkAbout: "アイスホッケーのリンク。{length}フィート（約{lengthM}m）×{width}フィート（約{widthM}m）で角が丸く、レッドライン、ブルーライン、フェイスオフサークル、クリース、ゴールがあります", arenaCourtAbout: "バスケットボールのコート。{length}フィート（約{lengthM}m）×{width}フィート（約{widthM}m）で、ペイントエリア、スリーポイントライン、フリースローサークル、センターサークルがあります", arenaSize: "広さは、{arena}の公表されている数値をもとに描かれています。", arenaUnknown: "{arena}のリンクはNHLの規格より短かったとされていますが、広さが示されていないため、NHLの規格で描かれています。", real: "スタンドは、OpenStreetMapの建物の輪郭（(c) OpenStreetMap contributors）の内側に収まるように、{arena}の{seats}席・{tiers}層を推定して描いたもので、アリーナの設計図ではありません。", realBuilding: "リンクは建物の長い軸に沿って置いており（推定）、矢印は北を指します。", realMapped: "リンクの向きはOpenStreetMapに記録された氷面のとおりで、矢印は北を指します。", realNone: "リンクの向きは分かっていないため、東西に置き、北を上にしています。", stadium: "{stadium}の建物の輪郭（OpenStreetMap、(c) OpenStreetMap contributors）の内側に、{seats}席・{tiers}層のスタンドを推定して描いています。スタジアムの設計図ではありません。", stadiumOpening: "フィールドは屋根の開口部（フィールドと同じ大きさ）に沿って置いており、矢印は北を指します。", stadiumBuilding: "フィールドは建物の長い軸に沿って置いており（推定）、矢印は北を指します。", stadiumNone: "フィールドの向きは分かっていないため、東西に置き、北を上にしています。", district: "OpenStreetMapの建物の輪郭をもとに、{count}か所の実在の会場を実際の位置と向きのとおりに並べた配置図です。{mode}。", districtNeighbours: "建物のすぐ近くまで寄せて描いています", districtCity: "実際の距離を保ち、1km方眼と縮尺を添えています", districtCredit: "出典：", era: "ラインやマークは{season}シーズンのものです。", hammer: "{name}がハンマー（最後の1投）を持っています。", ends: "{name}のエンドごとの得点：{list}。", total: "合計", wonPens: "{name}がPK戦を{a}-{b}で制しました。", pens: "PK戦 {a}-{b}", on: "図の内容", sep: "、", stop: "。", colon: "：", gap: "" },
         budo: {
             sides: { north: "北", south: "南", east: "東", west: "西" },
             judo: "柔道の試合場。試合場内は{contest}m四方、幅{safety}mの安全地帯があり、{tatami}の畳を敷いています",

package/dist/turn.kit.d.ts

@@ -35,6 +35,11 @@ export interface Plane {
     fadeTo?: number;
     /** How low the eye must be for a `shy` plane to begin to give way: the share (of the plane's side being towards the eye, times the sine of the pitch) at which the fade starts; 0.1 when missing. A low barrier takes a high one, so that it stays whole until the eye is nearly level with it. */
     fadeAt?: number;
+    /**
+     * The building (a `TurnModel.groups` index) a plane belongs to, in a scene of several that stand apart (a district's): the view draws one building's planes all before another's, by which side of the line between
+     * them the eye is on, and the planes of one building among themselves by depth.
+     */
+    group?: number;
 }
 /** What stands on the surface as a thing a reader would name: a net, a basket, a goal, a pair of posts. */
 export type UprightKind = "scoreboard" | "net" | "antennae" | "goalposts" | "netposts" | "hoop" | "goal" | "boards" | "stumps" | "pylons" | "flags" | "fence" | "backstop" | "foul-poles" | "table-legs" | "walls" | "starting-blocks" | "backstroke-flags" | "false-start-rope" | "springboards" | "platforms" | "judges-stand" | "hurdles" | "steeplechase" | "high-jump" | "pole-vault" | "cage" | "padding" | "rink-boards" | "mound" | "azuchi" | "targets" | "stands" | "wall-seats" | "roof" | "gallery" | "dais" | "banner" | "shrine" | "mat-edge" | "surrounds" | "officials" | "judges" | "deck" | "cage-fence" | "cage-posts" | "ring-ropes" | "ring-posts";

package/dist/turn.markup.d.ts

@@ -7,6 +7,13 @@ import type { ScoreOptions, SurfaceOptions } from "./types.ts";
  * (`centre`, in feet).
  */
 export declare function planeMatrix(p: Plane, scale: number, centre?: readonly [number, number]): number[];
+/**
+ * The order to draw buildings that stand apart in, far first: `rank[g]` is how many of the others `g` stands in front of. One building is in front of another when a line can be put between them and the eye is on its
+ * side (from the side of a line, the eye sees what is on its own side of it first, whatever the heights); two that no line separates go by how near their middles are.
+ */
+export declare function groupRanks(groups: readonly {
+    hull: readonly (readonly [number, number])[];
+}[], yaw: number): number[];
 /** Where everything is for a view in a container: the placement, the matrix of each element and its place in the stack. */
 export interface Layout {
     at: Placement;

package/dist/turn.markup.js

@@ -19,6 +19,40 @@ export function planeMatrix(p, scale, centre = [0, 0]) {
     const w = unit(cross(u, v));
     return [u[0], u[1], u[2], 0, v[0], v[1], v[2], 0, w[0], w[1], w[2], 0, (p.o[0] - centre[0]) * scale, (p.o[1] - centre[1]) * scale, p.o[2] * scale, 1];
 }
+/**
+ * The order to draw buildings that stand apart in, far first: `rank[g]` is how many of the others `g` stands in front of. One building is in front of another when a line can be put between them and the eye is on its
+ * side (from the side of a line, the eye sees what is on its own side of it first, whatever the heights); two that no line separates go by how near their middles are.
+ */
+export function groupRanks(groups, yaw) {
+    const a = (yaw * Math.PI) / 180;
+    // The direction on the plan towards the eye: depth grows with `x sin(yaw) + y cos(yaw)`.
+    const toward = [Math.sin(a), Math.cos(a)];
+    const middle = groups.map((g) => [g.hull.reduce((s, p) => s + p[0], 0) / g.hull.length, g.hull.reduce((s, p) => s + p[1], 0) / g.hull.length]);
+    const rank = new Array(groups.length).fill(0);
+    groups.forEach((g, i) => groups.forEach((h, j) => {
+        if (j <= i)
+            return;
+        // The axes tried for a line between them: the line through the middles' centre at right angles to the way from one to the other, then others round the circle.
+        const base = Math.atan2(middle[j][1] - middle[i][1], middle[j][0] - middle[i][0]);
+        let side = 0;
+        for (let k = 0; k < 36 && side === 0; k += 1) {
+            const t = base + (k % 2 === 0 ? 1 : -1) * Math.ceil(k / 2) * (Math.PI / 36);
+            const axis = [Math.cos(t), Math.sin(t)];
+            const along = (p) => p[0] * axis[0] + p[1] * axis[1];
+            if (Math.max(...g.hull.map(along)) < Math.min(...h.hull.map(along)))
+                side = axis[0] * toward[0] + axis[1] * toward[1] > 0 ? 1 : -1;
+        }
+        // No line between them: the nearer middle is in front.
+        if (side === 0)
+            side = middle[j][0] * toward[0] + middle[j][1] * toward[1] > middle[i][0] * toward[0] + middle[i][1] * toward[1] ? 1 : -1;
+        // `side` 1: `h` is nearer to the eye than `g`.
+        if (side > 0)
+            rank[j] += 1;
+        else
+            rank[i] += 1;
+    }));
+    return rank;
+}
 /** Work a view out in a container `width` by `height` pixels. */
 export function layoutOf(model, view, width, height, lens) {
     const distance = eyeDistance(width, height, lens ?? model.lens);
@@ -34,8 +68,10 @@ export function layoutOf(model, view, width, height, lens) {
     // sorted with the rest, by its middle, so that the legs and the skirt on the far side are drawn under it and the ones on the near side over it, and nothing under the top shows through it.
     const depth = (p) => depthOf([(p.o[0] + (p.u[0] + p.v[0]) / 2 - centre[0]) * s, (p.o[1] + (p.u[1] + p.v[1]) / 2 - centre[1]) * s, (p.o[2] + (p.u[2] + p.v[2]) / 2) * s], view, at);
     const raised = model.uprights.lift > 0;
-    const order = [...planes.map((p, i) => ({ i: i + 1, ground: p.kind === "ground", depth: depth(p) })), ...(raised ? [{ i: 0, ground: false, depth: depth(floor) }] : [])].filter((one) => !one.ground);
-    order.sort((a, b) => a.depth - b.depth);
+    const order = [...planes.map((p, i) => ({ i: i + 1, ground: p.kind === "ground", depth: depth(p), group: p.group })), ...(raised ? [{ i: 0, ground: false, depth: depth(floor), group: undefined }] : [])].filter((one) => !one.ground);
+    // Buildings that stand apart are drawn one after another, the far one first; a plane of none (the floor) goes by its depth alone.
+    const rank = model.groups === undefined ? undefined : groupRanks(model.groups, view.yaw);
+    order.sort((a, b) => (rank === undefined || a.group === undefined || b.group === undefined ? 0 : rank[a.group] - rank[b.group]) || a.depth - b.depth);
     const stack = new Array(model.planes.length + 1).fill(0);
     stack[0] = 1;
     order.forEach((one, rank) => {

package/dist/turn.model.d.ts

@@ -100,6 +100,10 @@ export interface TurnModel {
     lens?: number;
     /** The flat drawing to show where the 3D view cannot be drawn, when it is not `drawKyogijo`'s of `options` (a tournament layout's). */
     flat?: string;
+    /** The buildings of a scene that has several standing apart (a district's), each as the convex hull of its outline in the drawing's frame, in feet: the planes that name one (`Plane.group`) are stacked building by building. */
+    groups?: {
+        hull: readonly (readonly [number, number])[];
+    }[];
     /** The board the options ask for (`board`), laid over the view: a layer of its own, never a plane of the scene. */
     board?: ResolvedBoard;
 }

package/dist/turn.model.js

@@ -89,7 +89,9 @@ export function buildTurn(options, settings = {}) {
     const reach = uprights.reach;
     const margin = reach === undefined ? undefined : convertLength(reach, "ft", lengthUnit(asked));
     const own = asked.margin;
-    const base = reach !== undefined && crowdOpt !== undefined && crowdOpt !== false ? { ...asked, crowd: undefined, margin: Math.max(margin ?? 0, typeof own === "number" && Number.isFinite(own) ? own : 0) } : asked;
+    // (A real venue's building stays on the floor, with the arrow that says where north is: the crowd drawn without its seats.)
+    const keep = resolveCrowd(crowdOpt)?.real === true ? { real: true, stands: false } : undefined;
+    const base = reach !== undefined && crowdOpt !== undefined && crowdOpt !== false ? { ...asked, crowd: keep, margin: Math.max(margin ?? 0, typeof own === "number" && Number.isFinite(own) ? own : 0) } : asked;
     const o = boarded ? { ...base, plate: false, size: asked.size === "compact" ? "full" : asked.size } : base;
     const floor = settings.floor === undefined ? drawKyogijo(o) : settings.floor(o);
     const found = VIEWBOX.exec(floor);

package/dist/turn.style.js

@@ -66,7 +66,13 @@ export const KYOGIJO_TURN_STYLE = `
 .ky-turn .u-th{fill:var(--ky-cr-home)}
 .ky-turn .u-conc{fill:var(--ky-cr-conc)}
 .ky-turn .u-fascia{fill:var(--ky-up-fascia)}
+.ky-turn .u-shell{fill:var(--ky-up-fascia);stroke:var(--ky-up-roofline);stroke-width:.6}
 .ky-turn .u-roof{fill:var(--ky-up-roof);stroke:var(--ky-up-roofline);stroke-width:.8;stroke-linejoin:round}
+.ky-turn .u-signplate{fill:var(--ky-turn-bg);fill-opacity:.9;stroke:var(--ky-turn-rule);stroke-width:.5}
+.ky-turn .u-sign{fill:var(--ky-turn-ink);font-family:var(--ky-font,system-ui,-apple-system,"Segoe UI","Hiragino Sans","Noto Sans JP",sans-serif);font-weight:600}
+.ky-turn .u-cable{fill:none;stroke:var(--ky-up-roofline);stroke-width:1}
+.ky-turn .u-fabric{fill:var(--ky-up-roof);fill-opacity:.55;stroke:none}
+.ky-turn .u-pod{fill:var(--ky-up-fascia);stroke:var(--ky-up-roofline);stroke-width:.6}
 .ky-turn .ky-up-seats svg{opacity:var(--ky-cr-dim)}
 .ky-turn .ky-cr-seat{fill:none;stroke:var(--ky-cr-empty);stroke-width:1.3;stroke-opacity:.65}
 .ky-turn .ky-cr-h{stroke:var(--ky-cr-home)}