@johnmorrisdotca/kyogijo-stadiums 0.12.1 → 0.13.0

package/dist/turn.model.d.ts

@@ -1,5 +1,5 @@
 import { KYOGIJO_STRINGS } from "./strings.ts";
-import { type TurnPreset, type TurnView } from "./turn.camera.ts";
+import { type PresetTable, type TurnPreset, type TurnView } from "./turn.camera.ts";
 import type { Plane } from "./turn.kit.ts";
 import { type UprightOptions, type Uprights } from "./uprights.ts";
 import type { VenueSettings } from "./venue.ts";
@@ -29,7 +29,7 @@ export interface TurnSettings {
     motion?: "auto" | "smooth" | "none";
     /** The drawing the floor is, in place of `drawKyogijo`: a chart's `draw`, for instance. It is given the options with the view's own changes (the whole surface, lying wide). */
     floor?: (options: SurfaceOptions | ScoreOptions) => string;
-    /** How long a lens the eye has, as a multiple of the view's longer side: 1.7 by default, and the larger it is the flatter the picture. */
+    /** How long a lens the eye has, as a multiple of the view's longer side: 8 by default (`LENS`), and the larger it is the flatter the picture; a short lens makes the near end of a turning floor swell. */
     lens?: number;
     /** The size the first view is worked out for, in pixels, when the markup is made away from a page. 960 by 600 by default. */
     size?: {
@@ -93,11 +93,25 @@ export interface TurnModel {
     view: TurnView;
     /** False when there is nothing to turn: a badge is a strip, not a surface. */
     turnable: boolean;
+    /** The four viewpoints, when the model has its own (a tournament layout's); the sport's when missing. */
+    presets?: PresetTable;
+    /** 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 options with what makes the floor of a 3D view: the whole surface, lying wide, at its full size. */
 export declare function floorOptions(options: SurfaceOptions | ScoreOptions): SurfaceOptions | ScoreOptions;
 /** The view a set of settings opens on. */
-export declare const openingView: (settings: Pick<TurnSettings, "preset" | "view">, sport?: string) => TurnView;
+export declare const openingView: (settings: Pick<TurnSettings, "preset" | "view">, sport?: string | PresetTable) => TurnView;
+/**
+ * The scene's extent in pixels from its middle: the area it is fitted to (in feet, in the drawing's frame) widened to take in every plane that is not the ground, and as high as the highest of them (or of `lift`, the height
+ * of the floor itself).
+ */
+export declare function sceneBox(planes: readonly Plane[], area: {
+    x0: number;
+    y0: number;
+    x1: number;
+    y1: number;
+}, lift: number, centre: readonly [number, number], scale: number): Box3;
 /** Work out a 3D view from the options of a drawing. */
 export declare function buildTurn(options: SurfaceOptions | ScoreOptions, settings?: TurnSettings): TurnModel;
 /** The words of the 3D view in the model's language. */

package/dist/turn.model.js

@@ -33,6 +33,38 @@ function crowdVars(floor) {
 }
 /** The view a set of settings opens on. */
 export const openingView = (settings, sport) => clampView({ ...(presetView(settings.preset, sport) ?? presetView(TURN_DEFAULT, sport)), ...settings.view });
+/**
+ * The scene's extent in pixels from its middle: the area it is fitted to (in feet, in the drawing's frame) widened to take in every plane that is not the ground, and as high as the highest of them (or of `lift`, the height
+ * of the floor itself).
+ */
+export function sceneBox(planes, area, lift, centre, scale) {
+    let [x0, y0, x1, y1] = [area.x0, area.y0, area.x1, area.y1];
+    let top = lift;
+    for (const p of planes) {
+        // A billboard turns about its middle: whichever way it faces, it lies within a circle as wide as it is.
+        const reach = p.billboard === true ? Math.hypot(...p.u) / 2 : 0;
+        for (const [a, b] of [[0, 0], [1, 0], [0, 1], [1, 1]]) {
+            const point = [p.o[0] + a * p.u[0] + b * p.v[0], p.o[1] + a * p.u[1] + b * p.v[1], p.o[2] + a * p.u[2] + b * p.v[2]];
+            if (reach > 0) {
+                const middle = [p.o[0] + (p.u[0] + p.v[0]) / 2, p.o[1] + (p.u[1] + p.v[1]) / 2];
+                x0 = Math.min(x0, middle[0] - reach);
+                x1 = Math.max(x1, middle[0] + reach);
+                y0 = Math.min(y0, middle[1] - reach);
+                y1 = Math.max(y1, middle[1] + reach);
+                top = Math.max(top, point[2]);
+                continue;
+            }
+            if (p.kind !== "ground") {
+                x0 = Math.min(x0, point[0]);
+                x1 = Math.max(x1, point[0]);
+                y0 = Math.min(y0, point[1]);
+                y1 = Math.max(y1, point[1]);
+            }
+            top = Math.max(top, point[2]);
+        }
+    }
+    return { x0: (x0 - centre[0]) * scale, x1: (x1 - centre[0]) * scale, y0: (y0 - centre[1]) * scale, y1: (y1 - centre[1]) * scale, z0: 0, z1: top * scale };
+}
 /** Work out a 3D view from the options of a drawing. */
 export function buildTurn(options, settings = {}) {
     const asked = floorOptions(options);
@@ -66,33 +98,8 @@ export function buildTurn(options, settings = {}) {
     const centre = [vx + vw / 2, vy + vh / 2];
     // The scene's extent: the playing surface (the whole floor where it has no uprights), and whatever stands beyond it (a net behind a goal line). The ground
     // round the surface is not counted, so that the view is fitted to what is played on and the ground runs out of the picture.
-    const area = uprights.area ?? { x0: vx, y0: vy, x1: vx + vw, y1: vy + vh };
-    let [x0, y0, x1, y1] = [area.x0, area.y0, area.x1, area.y1];
-    let top = uprights.lift;
-    for (const p of planes) {
-        // A billboard turns about its middle: whichever way it faces, it lies within a circle as wide as it is.
-        const reach = p.billboard === true ? Math.hypot(...p.u) / 2 : 0;
-        for (const [a, b] of [[0, 0], [1, 0], [0, 1], [1, 1]]) {
-            const point = [p.o[0] + a * p.u[0] + b * p.v[0], p.o[1] + a * p.u[1] + b * p.v[1], p.o[2] + a * p.u[2] + b * p.v[2]];
-            if (reach > 0) {
-                const middle = [p.o[0] + (p.u[0] + p.v[0]) / 2, p.o[1] + (p.u[1] + p.v[1]) / 2];
-                x0 = Math.min(x0, middle[0] - reach);
-                x1 = Math.max(x1, middle[0] + reach);
-                y0 = Math.min(y0, middle[1] - reach);
-                y1 = Math.max(y1, middle[1] + reach);
-                top = Math.max(top, point[2]);
-                continue;
-            }
-            if (p.kind !== "ground") {
-                x0 = Math.min(x0, point[0]);
-                x1 = Math.max(x1, point[0]);
-                y0 = Math.min(y0, point[1]);
-                y1 = Math.max(y1, point[1]);
-            }
-            top = Math.max(top, point[2]);
-        }
-    }
-    const box = { x0: (x0 - centre[0]) * scale, x1: (x1 - centre[0]) * scale, y0: (y0 - centre[1]) * scale, y1: (y1 - centre[1]) * scale, z0: 0, z1: top * scale };
+    const area = uprights.whole === true || uprights.area === undefined ? { x0: vx, y0: vy, x1: vx + vw, y1: vy + vh } : uprights.area;
+    const box = sceneBox(planes, area, uprights.lift, centre, scale);
     const { title, description } = describe(o);
     const standing = describeUprights(o, uprights, language);
     return {

package/dist/turn.style.js

@@ -15,6 +15,7 @@ export const KYOGIJO_TURN_STYLE = `
 .ky-turn-floor,.ky-up{position:absolute;left:0;top:0;transform-origin:0 0;pointer-events:none}
 .ky-turn-floor>svg{display:block;width:100%;height:auto}
 .ky-up>svg{display:block;overflow:visible}
+.ky-up[data-crop]>svg{width:100%;height:100%;overflow:hidden}
 @media (max-width:560px){.ky-turn-view{--ky-turn-ratio:5/4}.ky-turn-controls button{padding:0 10px;font-size:.85rem}}
 .ky-turn .u-sbframe{fill:var(--ky-up-sbframe);stroke:var(--ky-up-sbedge);stroke-width:.25}
 .ky-turn .u-sbline{stroke:var(--ky-up-sbline)}
@@ -29,8 +30,10 @@ export const KYOGIJO_TURN_STYLE = `
 .ky-turn .u-table{fill:var(--ky-up-table)}
 .ky-turn .u-foot{fill:var(--ky-up-foot)}
 .ky-turn .u-ground{fill:var(--ky-up-ground)}
+.ky-turn .u-shadow{fill:#000;fill-opacity:.16}
 .ky-turn .u-wall{fill:var(--ky-up-wall)}
 .ky-turn .u-clay{fill:var(--ky-up-clay)}
+.ky-turn .u-clay-side{fill:color-mix(in srgb,var(--ky-dirt,var(--ky-up-clay)) 74%,#000)}
 .ky-turn .u-cap{fill:var(--ky-up-cap)}
 .ky-turn .u-board{fill:var(--ky-up-board)}
 .ky-turn .u-glass{fill:var(--ky-up-glass)}
@@ -96,6 +99,10 @@ export const KYOGIJO_TURN_STYLE = `
 .ky-turn .u-seatback{fill:var(--ky-up-seatb)}
 .ky-turn .u-railline{stroke:var(--ky-up-railw);stroke-width:.3;stroke-linecap:square}
 .ky-turn .u-matedge{fill:var(--ky-up-matedge)}
+.ky-turn .u-surround{fill:var(--ky-mu-barrier,#161a1f);fill-opacity:.92}
+.ky-turn .u-surround-rim{fill:var(--ky-mu-chair,#ece7da);fill-opacity:.55}
+.ky-turn .u-chair{fill:var(--ky-mu-chair,#ece7da);stroke:var(--ky-mu-chair-edge,#4a4f56);stroke-width:.06}
+.ky-turn .u-chair-side{fill:color-mix(in srgb,var(--ky-mu-chair,#ece7da) 62%,#000);stroke:var(--ky-mu-chair-edge,#4a4f56);stroke-width:.04}
 .ky-turn-controls{display:flex;flex-wrap:wrap;gap:8px;margin-top:10px;align-items:center}
 .ky-turn-group{display:flex;flex-wrap:wrap;gap:6px}
 .ky-turn-controls button{font:inherit;font-size:.9rem;font-weight:600;min-width:44px;min-height:44px;padding:0 12px;border-radius:999px;border:1px solid var(--ky-turn-rule);background:var(--ky-turn-chip);color:var(--ky-turn-ink);cursor:pointer;display:inline-flex;align-items:center;justify-content:center}

package/dist/uprights.budo.d.ts

@@ -10,6 +10,8 @@ export interface BudoUprights {
         x1: number;
         y1: number;
     };
+    /** The view is fitted to the whole floor (a platform stands in it), not to `area`. */
+    whole: boolean;
 }
 /** The walls of a dojo, 3 m high (ours). */
 export declare const DOJO_WALL = 3;

package/dist/uprights.budo.js

@@ -3,11 +3,15 @@
 // (a judo platform's height is not in the rules: "it depends on the sightlines"). The plans are in metres in the frame of their own origin, and the drawing's frame is feet from the corner of the plan's
 // box, so every point goes through `at`. The mound's height is the option's; the azuchi's (1.5 m or 1.8 m) and a dojo wall's (3 m) are ours: no rule gives them.
 import { budoPlan } from "./budo/plan.js";
-import { n, plane, shy, wall } from "./turn.kit.js";
+import { flat, n, plane, shy, wall } from "./turn.kit.js";
 const K = 1 / 0.3048;
 /** The walls of a dojo, 3 m high (ours). */
 export const DOJO_WALL = 3;
-/** The planes of the dohyō's clay mound: its four sides, from the floor of the hall up to the clay. */
+/**
+ * The planes of the dohyō's clay mound, a solid block: its four sides, from the floor of the hall up to the clay, and its flat top, which is the drawing's own clay with the ring of straw bales on it, lifted to the
+ * mound's height (the floor itself lies on the hall's floor, so that the ground round the mound stays low). The sides are one tone darker than the top, so that top and sides are lit the same way; whichever way
+ * the view is turned, the sides on the far side are drawn first and the top over them (see `layoutOf`), so the mound never looks hollow.
+ */
 function moundPlanes(plan, at, height) {
     const L = plan.sumo;
     if (L === undefined)
@@ -17,8 +21,10 @@ function moundPlanes(plan, at, height) {
     const planes = [];
     corners.forEach((a, i) => {
         const c = corners[(i + 1) % 4];
-        planes.push(wall(`mound-${i + 1}`, "wall", a[0], a[1], c[0], c[1], 0, height, `<rect width="${n(Math.hypot(c[0] - a[0], c[1] - a[1]))}" height="${n(height)}" class="u-clay"/>`));
+        planes.push(wall(`mound-${i + 1}`, "wall", a[0], a[1], c[0], c[1], 0, height, `<rect width="${n(Math.hypot(c[0] - a[0], c[1] - a[1]))}" height="${n(height)}" class="u-clay u-clay-side"/>`));
     });
+    const [a, c] = [corners[0], corners[2]];
+    planes.push({ ...flat("mound-top", "platform", a[0], a[1], c[0], c[1], height, ""), crop: true });
     return planes;
 }
 /** The azuchi's face, a slope from the foot of the mound up to its top, and the target of each shooter standing against it. */
@@ -54,10 +60,11 @@ export function budoUprights(o, thin) {
     const at = (x, y) => [(x - ox) * K, (y - oy) * K];
     const area = { x0: 0, y0: 0, x1: (plan.box.x1 - ox) * K, y1: (plan.box.y1 - oy) * K };
     const items = [];
-    let lift = 0;
+    // The floor lies on the hall's floor (`lift` is 0): the mound is a block standing on it, with its own top.
+    const lift = 0;
     if (plan.sumo !== undefined) {
-        lift = plan.sumo.height * K;
-        items.push({ id: "mound", kind: "mound", at: at(plan.sumo.centre[0], plan.sumo.centre[1]), height: lift, planes: moundPlanes(plan, at, lift) });
+        const height = plan.sumo.height * K;
+        items.push({ id: "mound", kind: "mound", at: at(plan.sumo.centre[0], plan.sumo.centre[1]), height, planes: moundPlanes(plan, at, height) });
     }
     if (plan.kyudo !== undefined) {
         const built = azuchiPlanes(plan, at);
@@ -83,5 +90,5 @@ export function budoUprights(o, thin) {
         items.push({ id: "walls", kind: "walls", at: centre, height: h, planes });
     }
     void thin;
-    return { items, lift, area };
+    return { items, lift, area, whole: plan.sumo !== undefined };
 }

package/dist/uprights.d.ts

@@ -29,6 +29,8 @@ export interface Uprights {
         x1: number;
         y1: number;
     };
+    /** True when the view is fitted to the whole floor drawing, not to `area` (which is then only where the score board goes): a raised platform stands in a floor that must not be cut at any angle. */
+    whole?: boolean;
     /** The patterns the venue's planes are drawn with (the contents of an SVG `defs`), when it has any. */
     defs?: string;
     /** How far the venue reaches beyond the surface, in feet, when it has one: the ground a floor needs for it to stand on. */

package/dist/uprights.js

@@ -41,6 +41,7 @@ export function uprightsFor(o, settings = {}) {
     let lift = 0;
     let thin = 0.2;
     let area;
+    let whole = false;
     if (sport === "nfl" || sport === "cfl" || sport === "ifaf") {
         const spec = league?.family === "football" ? fieldOf(league, o.year) : footballIn(sport, o.year);
         const shape = league?.family === "football" || sport === "ifaf" ? "slingshot" : rulesFor(sport, o.year).rules.postShape;
@@ -112,6 +113,7 @@ export function uprightsFor(o, settings = {}) {
         thin = thinnest(area.x1, area.y1);
         items = budoUprights({ ...o, sport }, thin).items;
         lift = built.lift;
+        whole = built.whole;
     }
     else if (isFieldSport(sport)) {
         const plan = fieldPlan({ ...o, sport });
@@ -145,7 +147,7 @@ export function uprightsFor(o, settings = {}) {
     }
     if (settings.only !== undefined)
         items = items.filter((item) => settings.only.includes(item.kind));
-    return { items, lift, thin, area, ...(defs === "" ? {} : { defs }), ...(reach === 0 ? {} : { reach }) };
+    return { items, lift, thin, area, ...(whole ? { whole } : {}), ...(defs === "" ? {} : { defs }), ...(reach === 0 ? {} : { reach }) };
 }
 /** A length in feet as a rulebook would print it in `unit`: metres to the centimetre, feet to a tenth. */
 function said(feet, unit, language) {

package/dist/uprights.net.js

@@ -100,7 +100,18 @@ export function netUprights(plan, geo, settings, thin) {
             items.push({ id: "table", kind: "table-legs", at: [L / 2, W / 2], height: lift, planes: tableBody(0, 0, L, W, lift, thin, false) });
             // The floor of the hall, under the table.
             const room = Math.max(L, W) * 5;
-            items.push({ id: "ground", kind: "table-legs", at: [L / 2, W / 2], height: 0, planes: [flat("ground", "ground", -room, -room, L + room, W + room, 0, `<rect width="${n(L + 2 * room)}" height="${n(W + 2 * room)}" class="u-ground"/>`)] });
+            // Under the table lies its shadow on that floor, so that the legs stand on something.
+            const grow = Math.max(convertLength(0.25, "m", "ft"), thin * 4);
+            items.push({
+                id: "ground",
+                kind: "table-legs",
+                at: [L / 2, W / 2],
+                height: 0,
+                planes: [
+                    flat("ground", "ground", -room, -room, L + room, W + room, 0, `<rect width="${n(L + 2 * room)}" height="${n(W + 2 * room)}" class="u-ground"/>`),
+                    flat("table-shadow", "ground", -grow / 2, -grow / 2, L + grow / 2, W + grow / 2, 0.005, `<rect width="${n(L + grow)}" height="${n(W + grow)}" rx="${n(grow)}" class="u-shadow"/>`),
+                ],
+            });
             return { items, lift };
         }
         default:

package/dist/venue.d.ts

@@ -1,3 +1,4 @@
+import { type Crowd, type CrowdStands } from "./crowd.ts";
 import { type Cut } from "./venue.geom.ts";
 import { type Upright } from "./turn.kit.ts";
 import type { SurfaceOptions } from "./types.ts";
@@ -29,3 +30,8 @@ export declare const ROOF: {
 };
 /** 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 declare function standsVenue(o: SurfaceOptions, v: VenueBuild, lift: number): Venue;
+/**
+ * The stands the model says (`crowdStands`, or the stands of a tournament layout's hall) as planes: what `standsVenue` makes of a surface's, for stands that were worked out some other way. `o` is the little of the
+ * drawing's options it reads: the sport (whether a roof is a lid), the detail (`simple` is the plain crowd) and the ground (whose capacity sets the density).
+ */
+export declare function standsVenueOf(stands: CrowdStands, crowd: Crowd, o: Pick<SurfaceOptions, "sport" | "detail" | "ground">, v: VenueBuild, lift: number): Venue;

package/dist/venue.js

@@ -33,6 +33,13 @@ export function standsVenue(o, v, lift) {
     const crowd = resolveCrowd(o.crowd);
     if (stands === undefined || crowd === undefined || stands.gallery === true)
         return NO_VENUE;
+    return standsVenueOf(stands, crowd, { sport: o.sport, detail: o.detail, ground: o.ground }, v, lift);
+}
+/**
+ * The stands the model says (`crowdStands`, or the stands of a tournament layout's hall) as planes: what `standsVenue` makes of a surface's, for stands that were worked out some other way. `o` is the little of the
+ * drawing's options it reads: the sport (whether a roof is a lid), the detail (`simple` is the plain crowd) and the ground (whose capacity sets the density).
+ */
+export function standsVenueOf(stands, crowd, o, v, lift) {
     const cut = v.detail ?? "auto";
     const fine = crowd.detail !== "plain" && o.detail !== "simple";
     const density = densityOf(crowd, stands.seats, groundById(o.ground)?.capacity);

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.12.1";
+export declare const VERSION = "0.13.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.12.1";
+export const VERSION = "0.13.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@johnmorrisdotca/kyogijo-stadiums",
-  "version": "0.12.1",
+  "version": "0.13.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",