@johnmorrisdotca/kyogijo-stadiums 0.25.0 → 0.27.0

package/dist/types.d.ts

@@ -287,7 +287,8 @@ export interface CrowdOptions {
     /**
      * The stands of the arena's real venue, for an NHL `arena` the package has one of (`VENUES`, `@johnmorrisdotca/kyogijo-stadiums/venues`): the outline of its building from OpenStreetMap, the rink lying along
      * the building as it does in the world (a small arrow says where north is), and a bowl of the number of tiers and the seats the sources give, fitted inside the building, under its kind of roof. An arena with no venue
-     * is drawn with the usual stands. Off by default. The drawing needs the credit `VENUE_ATTRIBUTION`. See `docs/venues.md`.
+     * is drawn with the usual stands. Off by default. The drawing needs the credit `VENUE_ATTRIBUTION`. See `docs/venues.md`. The same for a football field (`sport: "cfl"`) or a soccer pitch in a real stadium (`stadium`, or a `ground` that is one;
+     * `docs/stadiums.md`): the building, the field lying in it and a bowl of the configuration's seats.
      */
     real?: boolean;
     /** `false` draws no seats: of a real venue (`real`) only its building and the arrow that says where north is, which is what the floor of the 3D view needs under the stands it raises. On by default. */
@@ -684,6 +685,8 @@ export interface SurfaceOptions {
     pitch?: SoccerPitchId | SoccerSize;
     /** The soccer ground to draw: a key of `GROUNDS`. The pitch has the size its article publishes (the international 105 by 68 m where none is), and the drawing carries the ground's name for `year`. A `pitch` of your own wins over the ground's size. */
     ground?: string;
+    /** The stadium to draw a football field (`sport: "cfl"`) or a soccer pitch in, for `crowd: { real: true }`: a key of `STADIUMS` (`bc-place`). A soccer drawing with a `ground` that is a stadium of `STADIUMS` needs no other. */
+    stadium?: string;
     /** The arena to draw an NHL rink or an NBA court of: a key of `ARENAS`. The rink or the court has the size its sources publish where that differs from the league's (the league's where none does), the markings are those of `year`, and the drawing carries the arena's name for `year`. A `league` of your own wins over the arena's size. */
     arena?: string;
     /** Draw a soccer pitch in a data provider's own coordinates (`opta`, `statsbomb`, `wyscout`, `tracab`, `metrica`, `skillcorner`, `secondspectrum`, `impect`, `uefa`, `international`), or in a frame of your own: the lines stand where the provider puts them, and an empty `ky-data` group in its units is put in the drawing for raw data. */

package/dist/venue.d.ts

@@ -6,6 +6,8 @@ import type { SurfaceOptions } from "./types.ts";
 export interface VenueSettings {
     /** Roofs and canopies over the top tier of the stands: a canopy over the back of the top tier in the open, a lid over a hall. They give way to the eye as the walls do. Off by default. */
     roof?: boolean;
+    /** A retractable roof (a real venue's: BC Place's) drawn open, the fabric gathered into its pod, instead of closed over the opening. Closed by default. */
+    roofOpen?: boolean;
     /** How finely the curves are cut: `low` a facet to each corner, `auto` (the default) three, `high` six; an oval is 12, 28 or 56 facets round. */
     detail?: Cut;
 }

package/dist/venue.js

@@ -151,7 +151,7 @@ export function standsVenueOf(stands, crowd, o, v, lift) {
         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. A real venue has its own: the walls of its building and a roof of its kind over them.
     if (stands.real !== undefined && v.roof === true)
-        items.push(...realBuilding(stands.real, topRing(stands), centre, lift, ARC_STEPS[cut].oval * 2));
+        items.push(...realBuilding(stands.real, topRing(stands), centre, lift, ARC_STEPS[cut].oval * 2, v.roofOpen === true));
     const top = v.roof === true && crowd.roof && stands.real === undefined ? topRing(stands) : undefined;
     if (top !== undefined) {
         const lid = INDOOR.includes(String(o.sport));

package/dist/venue.real.d.ts

@@ -11,6 +11,11 @@ export declare const roofAt: (real: RealShell, p: Pt) => number;
  * The walls and the roof of a real venue. The hall is the building's outline cut to the bowl's wall and a margin (`RealShell.hall`): its rim is where a ray from the middle meets the one or the other first, in `steps`
  * rays. A wall stands on each stretch of the rim, up to the roof's height over it; the roof is a band from the rim in to the inner edge of the top tier (the middle stays open, as the 3D view's roofs are).
  */
-export declare function realBuilding(real: RealShell, top: StandRing | undefined, centre: readonly [number, number], lift: number, steps: number): Items;
+export declare function realBuilding(real: RealShell, top: StandRing | undefined, centre: readonly [number, number], lift: number, steps: number, open?: boolean): Items;
+/** The pod in the middle of a cable roof's opening, as a share of the opening's size, and how thick it is, in feet (ours: the article says the fabric gathers into a pod above the video board, not how large it is). */
+export declare const POD: {
+    readonly share: 0.24;
+    readonly thick: 9;
+};
 type Items = Upright[];
 export {};

package/dist/venue.real.js

@@ -1,5 +1,6 @@
-// The building of a real venue, raised: its walls, standing on the outline OpenStreetMap gives, and its roof over the top tier, a lid that rises towards the middle or a saddle that rises at the two ends and falls at the two
-// sides. Both are asked for with the roof (`venue: { roof: true }`) and give way to the eye as the other walls do. Pure: data in, planes out.
+// The building of a real venue, raised: its walls, standing on the outline OpenStreetMap gives, and its roof over the top tier, a lid that rises towards the middle, a saddle that rises at the two ends and falls at the two
+// sides, or a cable-supported roof that rises to an opening over the surface which a retractable fabric closes (BC Place's, with the fabric gathered into its pod when `roofOpen` is asked). All are asked for with the roof
+// (`venue: { roof: true }`) and give way to the eye as the other walls do. Pure: data in, planes out.
 import { rayAt } from "./crowd.js";
 import { n, shy, wall } from "./turn.kit.js";
 import { pointList, raked } from "./venue.geom.js";
@@ -54,7 +55,7 @@ function slopeThrough(points) {
  * The walls and the roof of a real venue. The hall is the building's outline cut to the bowl's wall and a margin (`RealShell.hall`): its rim is where a ray from the middle meets the one or the other first, in `steps`
  * rays. A wall stands on each stretch of the rim, up to the roof's height over it; the roof is a band from the rim in to the inner edge of the top tier (the middle stays open, as the 3D view's roofs are).
  */
-export function realBuilding(real, top, centre, lift, steps) {
+export function realBuilding(real, top, centre, lift, steps, open = false) {
     const items = [];
     const c = [centre[0], centre[1]];
     const rim = Array.from({ length: steps }, (_, k) => {
@@ -74,13 +75,17 @@ export function realBuilding(real, top, centre, lift, steps) {
     });
     if (planes.length > 0)
         items.push({ id: "shell", kind: "walls", at: centre, height: Math.max(...planes.map((p) => p.o[2])), planes });
-    if (top?.hole == null)
+    const crown = real.roof === "cable" ? real.crown : undefined;
+    if (top?.hole == null && crown === undefined)
         return items;
     const roof = [];
-    const hole = top.hole;
-    const inner = rim.map((_, k) => rayAt(hole, c[0], c[1], (2 * Math.PI * k) / steps));
-    const rise = real.roof === "saddle" ? 0 : LID_RISE;
-    const zOf = (p, inward) => lift + roofAt(real, p) + (inward ? rise : 0);
+    // A cable roof rises from the rim of the hall to the opening over the surface; any other is a band from the rim in to the inner edge of the top tier.
+    const inner = rim.map((_, k) => {
+        const angle = (2 * Math.PI * k) / steps;
+        return crown === undefined ? rayAt(top.hole, c[0], c[1], angle) : firstHit(crown.opening, c, angle) ?? rayAt(top.hole, c[0], c[1], angle);
+    });
+    const rise = real.roof === "saddle" || real.roof === "cable" ? 0 : LID_RISE;
+    const zOf = (p, inward) => lift + roofAt(real, p) + (inward ? (crown === undefined ? rise : crown.rise) : 0);
     for (let k = 0; k < steps; k += 1) {
         const [a, b] = [rim[k], rim[(k + 1) % steps]];
         const [ai, bi] = [inner[k], inner[(k + 1) % steps]];
@@ -93,11 +98,53 @@ export function realBuilding(real, top, centre, lift, steps) {
             continue;
         const mid = [(a[0] + b[0] + ai[0] + bi[0]) / 4, (a[1] + b[1] + ai[1] + bi[1]) / 4];
         const away = Math.hypot(mid[0] - c[0], mid[1] - c[1]);
-        const piece = raked(`roof-${k}`, "roof", quad, slope, [ex / el, ey / el], (corners) => `<polygon class="u-roof" points="${pointList(corners)}"/>`);
+        // A cable roof's cables run from the rim to the opening along the edge of each piece (ours: the drawing's cables are as many as its pieces, not the roof's own count).
+        const paint = (corners) => `<polygon class="u-roof" points="${pointList(corners)}"/>${crown === undefined ? "" : `<path class="u-cable" d="M${n(corners[0][0])} ${n(corners[0][1])}L${n(corners[3][0])} ${n(corners[3][1])}"/>`}`;
+        const piece = raked(`roof-${k}`, "roof", quad, slope, [ex / el, ey / el], paint);
         if (piece !== undefined)
             roof.push({ ...piece, shy: [(mid[0] - c[0]) / away, (mid[1] - c[1]) / away] });
     }
+    if (crown !== undefined)
+        roof.push(...cablePod(real, crown, inner, c, lift, steps, open));
     if (roof.length > 0)
         items.push({ id: "roof", kind: "roof", at: centre, height: Math.max(...roof.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]])), planes: roof });
     return items;
 }
+/** The pod in the middle of a cable roof's opening, as a share of the opening's size, and how thick it is, in feet (ours: the article says the fabric gathers into a pod above the video board, not how large it is). */
+export const POD = { share: 0.24, thick: 9 };
+/**
+ * What lies over the opening of a cable roof: the pod in the middle (a box hung at the crown's height) and, with the roof closed, the fabric between the pod and the opening's edge, drawn thin so that the seats
+ * show through it. Open, only the pod is there: the fabric has gathered into it.
+ */
+function cablePod(real, crown, edge, c, lift, steps, open) {
+    const planes = [];
+    const z = lift + real.edge + crown.rise;
+    const pod = edge.map((p) => [c[0] + (p[0] - c[0]) * POD.share, c[1] + (p[1] - c[1]) * POD.share]);
+    if (!open) {
+        for (let k = 0; k < steps; k += 1) {
+            const [a, b] = [edge[k], edge[(k + 1) % steps]];
+            const [ai, bi] = [pod[k], pod[(k + 1) % steps]];
+            const el = Math.hypot(b[0] - a[0], b[1] - a[1]);
+            if (el < 1e-6)
+                continue;
+            const mid = [(a[0] + b[0] + ai[0] + bi[0]) / 4, (a[1] + b[1] + ai[1] + bi[1]) / 4];
+            const away = Math.hypot(mid[0] - c[0], mid[1] - c[1]);
+            const piece = raked(`fabric-${k}`, "roof", [ai, bi, b, a], { x0: c[0], y0: c[1], z0: z, gx: 0, gy: 0 }, [(b[0] - a[0]) / el, (b[1] - a[1]) / el], (corners) => `<polygon class="u-fabric" points="${pointList(corners)}"/>`);
+            if (piece !== undefined)
+                planes.push({ ...piece, shy: [(mid[0] - c[0]) / away, (mid[1] - c[1]) / away], fadeTo: 0.04 });
+        }
+    }
+    // The pod: a flat top and the sides of a ring of boxes, one to each piece.
+    const top = z + POD.thick;
+    const topFace = raked("pod-top", "roof", pod, { x0: c[0], y0: c[1], z0: top, gx: 0, gy: 0 }, [1, 0], (corners) => `<polygon class="u-pod" points="${pointList(corners)}"/>`);
+    if (topFace !== undefined)
+        planes.push(topFace);
+    for (let k = 0; k < steps; k += 1) {
+        const [a, b] = [pod[k], pod[(k + 1) % steps]];
+        const long = Math.hypot(b[0] - a[0], b[1] - a[1]);
+        if (long < 0.5)
+            continue;
+        planes.push({ ...shy(wall(`pod-${k}`, "roof", a[0], a[1], b[0], b[1], z, top, `<rect class="u-pod" width="${n(long)}" height="${n(POD.thick)}"/>`), c), fadeTo: 0.3 });
+    }
+    return planes;
+}

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.25.0";
+export declare const VERSION = "0.27.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.25.0";
+export const VERSION = "0.27.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@johnmorrisdotca/kyogijo-stadiums",
-  "version": "0.25.0",
+  "version": "0.27.0",
   "description": "Kyogijo Stadiums 競技場, 40 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, the MMA cage, 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",
@@ -133,6 +133,16 @@
       "import": "./dist/venues-entry.js",
       "default": "./dist/venues-entry.js"
     },
+    "./stadiums": {
+      "types": "./dist/stadiums-entry.d.ts",
+      "import": "./dist/stadiums-entry.js",
+      "default": "./dist/stadiums-entry.js"
+    },
+    "./district": {
+      "types": "./dist/district-entry.d.ts",
+      "import": "./dist/district-entry.js",
+      "default": "./dist/district-entry.js"
+    },
     "./grounds": {
       "types": "./dist/grounds-entry.d.ts",
       "import": "./dist/grounds-entry.js",
@@ -238,6 +248,11 @@
       "import": "./dist/turn-entry.js",
       "default": "./dist/turn-entry.js"
     },
+    "./flythrough": {
+      "types": "./dist/flythrough-entry.d.ts",
+      "import": "./dist/flythrough-entry.js",
+      "default": "./dist/flythrough-entry.js"
+    },
     "./element/define": {
       "types": "./dist/element-define.d.ts",
       "import": "./dist/element-define.js",
@@ -286,6 +301,8 @@
     "arenas:check": "node scripts/check-arenas.mjs",
     "venues": "node scripts/build-venues.mjs",
     "venues:fetch": "node scripts/fetch-venues.mjs",
+    "stadiums": "node scripts/build-stadiums.mjs",
+    "stadiums:fetch": "node scripts/fetch-stadiums.mjs",
     "boards": "node scripts/make-boards.mjs",
     "grounds": "node scripts/build-grounds.mjs",
     "grounds:check": "node scripts/check-grounds.mjs",