@johnmorrisdotca/kyogijo-stadiums 0.12.2 → 0.14.0

package/dist/multi.draw.js

@@ -14,6 +14,7 @@ import { MULTI_WORDS } from "./multi.words.js";
 import { outlineOf } from "./outline.js";
 import { fill } from "./strings.js";
 import { textWidth } from "./text.js";
+import { uprightsFor } from "./uprights.js";
 import { VERSION } from "./version.js";
 const metres = (ft) => ft / FEET_PER_METRE;
 const clamp = (v, lo, hi) => Math.min(hi, Math.max(lo, v));
@@ -46,6 +47,14 @@ const floorClass = (layout) => (layout.spec.kind === "budo" ? "ky-bud-t2" : "ky-
  * ```
  */
 export function drawMulti(options = {}) {
+    return multiDrawing(options, false).svg;
+}
+/**
+ * The drawing of a layout, with what it was worked out from. `raise` makes the floor of a 3D view instead of the flat picture: the barriers, the officials' chairs, the scoreboard and the stands are left out (the 3D
+ * view stands them up), and a surface that stands over the floor (a table tennis table) is left off it too, with a soft shadow in its place. Everything else is the same string. With `uprights` false the 3D view stands
+ * nothing but the stands up, so the barriers and the rest stay on the floor.
+ */
+export function multiDrawing(options, raise, uprights = true) {
     const o = options;
     const language = o.language === "ja" ? "ja" : "en";
     const words = MULTI_WORDS[language];
@@ -80,8 +89,13 @@ export function drawMulti(options = {}) {
     let style = "";
     let look;
     let cellsMarkup = "";
+    const lifted = [];
     const surfaceBox = outlineOf(spec.surface).box;
     const common = { ...spec.surface, margin: 0, language };
+    // A surface that stands over the floor (a table tennis table's top, 76 cm up) is raised by the 3D view as a plane of its own.
+    const up = raise && uprights;
+    const lift = up && spec.kind === "cells" ? uprightsFor(common).lift : 0;
+    const raised = lift > 0;
     if (spec.kind === "budo") {
         const drawn = inner(drawKyogijo({ ...common, id: `${gid}-s`, ...(o.style === "none" ? { style: "none" } : {}) }));
         style = drawn.style;
@@ -97,6 +111,13 @@ export function drawMulti(options = {}) {
                 style = drawn.style;
                 look = drawn.look;
             }
+            if (raised) {
+                // The floor has its shadow, soft and a little larger; the top is a plane of the 3D view.
+                const grow = 0.8;
+                cellsMarkup += el("rect", { class: "ky-mu-shadow", x: num(cell.x - grow / 2), y: num(cell.y - grow / 2), width: num(cell.w + grow), height: num(cell.h + grow), rx: num(grow) });
+                lifted.push({ cell, body: drawn.body, box: { x: surfaceBox.x, y: surfaceBox.y, w: surfaceBox.w, h: surfaceBox.h }, lift });
+                return;
+            }
             // A surface turned a quarter stands across the layout: the drawing's own top left goes to the cell's top right, and the drawing is turned.
             const place = cell.turn ? `translate(${num(cell.x + cell.w)} ${num(cell.y)}) rotate(90) translate(${num(-surfaceBox.x)} ${num(-surfaceBox.y)})` : `translate(${num(cell.x - surfaceBox.x)} ${num(cell.y - surfaceBox.y)})`;
             cellsMarkup += el("g", { class: "ky-mu-cell", "data-cell": cell.n, transform: place }, drawn.body);
@@ -106,10 +127,10 @@ export function drawMulti(options = {}) {
     let floorMarkup = "";
     floorMarkup += el("rect", { class: floorClass(layout), x: 0, y: 0, width: num(layout.floor.w), height: num(layout.floor.h) });
     let over = "";
-    if (spec.parts.barriers === true)
+    if (!up && spec.parts.barriers === true)
         for (const c of layout.cells)
             over += el("rect", { class: "ky-mu-barrier", x: num(c.bay.x + 0.5), y: num(c.bay.y + 0.5), width: num(c.bay.w - 1), height: num(c.bay.h - 1), rx: 0.4 });
-    if (spec.parts.officials === true) {
+    if (!up && spec.parts.officials === true) {
         for (const c of layout.cells) {
             if (c.turn) {
                 // Beside the net, on the right of a surface that stands across the layout.
@@ -123,10 +144,10 @@ export function drawMulti(options = {}) {
             over += el("rect", { class: "ky-mu-desk", x: num(cx - 5), y: num(c.y - 3.1), width: 3.6, height: 1.1, rx: 0.2 });
         }
     }
-    if (spec.parts.scoreboard === "each")
+    if (!up && spec.parts.scoreboard === "each")
         for (const c of layout.cells)
             over += el("rect", { class: "ky-mu-sb", x: num(c.x + c.w / 2 - 2), y: num(c.y + c.h + 1.2), width: 4, height: 1.4, rx: 0.2 });
-    const sb = layout.shared;
+    const sb = up ? undefined : layout.shared;
     if (sb !== undefined) {
         over += el("rect", { class: "ky-mu-sb", x: num(sb.x), y: num(sb.y), width: num(sb.w), height: num(sb.h), rx: 0.5 });
         // One scoreboard for all: a quarter of it for each of four areas, or one panel for each when they are fewer or more.
@@ -186,6 +207,7 @@ export function drawMulti(options = {}) {
     let reach = { left: 0, right: 0, top: 0, bottom: 0 };
     let defs = "";
     let crowdStyle = "";
+    let standing;
     const wide = { x: 0, y: 0, w: hall.w, h: hall.h };
     const boards = layout.slots.filter((s) => s.kind === "board");
     const boardsMargin = withSlots && boards.length > 0 ? 5 : 0;
@@ -202,13 +224,18 @@ export function drawMulti(options = {}) {
         const standsLike = venue?.standsLike ?? spec.sport;
         const crowd = resolveCrowd({ gaps: false, awayEnd: "none", roof: stadium.roof, shape: stadium.shape, density: stadium.density, detail: stadium.detail === "plain" ? "plain" : "fine" });
         const stands = layoutOf({ sport: standsLike, box: wide, crowd, awaySide: "right", arena: venue?.shape === "octagon" });
-        const density = stadium.crowd === false ? 0 : densityOf(crowd, stands.seats, undefined);
-        const drawn = drawCrowd(stands, { id: `${gid}-cr`, crowd, density, fine: crowd.detail !== "plain", ground: "ky-mu-apron" });
-        defs += drawn.defs;
         const wall = venue?.shape === "octagon" ? el("path", { class: "ky-mu-wall", d: octagonD(hall.w / 2, hall.w / 2, hall.w / 2) }) : el("rect", { class: "ky-mu-wall", x: 0, y: 0, width: num(hall.w), height: num(hall.h), rx: 0.5 });
-        hallMarkup = drawn.markup + hallMarkup + wall;
+        if (raise)
+            hallMarkup += wall;
+        else {
+            const density = stadium.crowd === false ? 0 : densityOf(crowd, stands.seats, undefined);
+            const drawn = drawCrowd(stands, { id: `${gid}-cr`, crowd, density, fine: crowd.detail !== "plain", ground: "ky-mu-apron" });
+            defs += drawn.defs;
+            hallMarkup = drawn.markup + hallMarkup + wall;
+            crowdStyle = KYOGIJO_CROWD_STYLE;
+        }
         reach = stands.reach;
-        crowdStyle = KYOGIJO_CROWD_STYLE;
+        standing = { stands, crowd, standsLike };
     }
     else if (venue !== undefined) {
         hallMarkup += el("rect", { class: "ky-mu-hall", x: 0, y: 0, width: num(hall.w), height: num(hall.h) });
@@ -267,7 +294,8 @@ export function drawMulti(options = {}) {
         "data-theme": o.theme === "light" || o.theme === "dark" ? o.theme : undefined,
         "data-version": VERSION,
     }, `<title id="${titleId}">${esc(title)}</title><desc id="${descId}">${esc(description)}</desc>` + css + (defs === "" ? "" : `<defs>${defs}</defs>`) + el("rect", { class: "ky-mu-apron", x: num(view.x), y: num(view.y), width: num(vw), height: num(vh) }) + hallLayer + group + overhang + slotTexts + labelsMarkup);
-    return root;
+    const frame = { layout, hall, lw, lh, ox, oy, turned, to };
+    return { svg: root, frame, fit, ...(standing === undefined ? {} : { stands: standing }), lifted, view: { x: view.x, y: view.y, w: vw, h: vh }, title, description };
 }
 /** Where an empty place is, in words: the surface it belongs to, the side or end it is at, and whether it is on the mats. */
 function slotWhere(slot, layout, words) {

package/dist/multi.style.js

@@ -6,8 +6,8 @@ const FLOORS = {
     red: { light: ["#b3362b", "#fdf3f1"], dark: ["#7a241d", "#f3d8d4"] },
     ice: { light: ["#e4eef5", "#1d2b36"], dark: ["#a9bccb", "#10181f"] },
 };
-const COMMON_LIGHT = "--ky-mu-neutral:#bdb9ad;--ky-mu-barrier:#161a1f;--ky-mu-board:#1d2430;--ky-mu-board-ink:#f4f1ea;--ky-mu-chair:#ece7da;--ky-mu-chair-edge:#4a4f56;--ky-mu-sb:#10151b;--ky-mu-sb-ink:#f6f6f6;--ky-mu-wall:#3a4048;--ky-mu-hall:#d9d5c8;--ky-mu-over:#c0392b";
-const COMMON_DARK = "--ky-mu-neutral:#2b2f2c;--ky-mu-barrier:#05070a;--ky-mu-board:#0d1218;--ky-mu-board-ink:#e8e4da;--ky-mu-chair:#b9b4a6;--ky-mu-chair-edge:#050607;--ky-mu-sb:#05080b;--ky-mu-sb-ink:#e9e9e9;--ky-mu-wall:#0a0c0f;--ky-mu-hall:#1b1f1c;--ky-mu-over:#e0614f";
+const COMMON_LIGHT = "--ky-mu-neutral:#bdb9ad;--ky-mu-barrier:#161a1f;--ky-mu-board:#1d2430;--ky-mu-board-ink:#f4f1ea;--ky-mu-chair:#ece7da;--ky-mu-chair-edge:#4a4f56;--ky-mu-sb:#10151b;--ky-mu-sb-ink:#f6f6f6;--ky-mu-wall:#3a4048;--ky-mu-hall:#d9d5c8;--ky-mu-over:#c0392b;--ky-mu-shadow:rgba(0,0,0,.2)";
+const COMMON_DARK = "--ky-mu-neutral:#2b2f2c;--ky-mu-barrier:#05070a;--ky-mu-board:#0d1218;--ky-mu-board-ink:#e8e4da;--ky-mu-chair:#b9b4a6;--ky-mu-chair-edge:#050607;--ky-mu-sb:#05080b;--ky-mu-sb-ink:#e9e9e9;--ky-mu-wall:#0a0c0f;--ky-mu-hall:#1b1f1c;--ky-mu-over:#e0614f;--ky-mu-shadow:rgba(0,0,0,.45)";
 const hallVars = (which) => Object.entries(FLOORS).map(([name, f]) => `--ky-mu-f-${name}:${f[which][0]}`).join(";");
 const looks = (which) => Object.entries(FLOORS).map(([name, f]) => `.kyogijo.ky-multi[data-floor=${name}]{--ky-mu-floor:${f[which][0]};--ky-mu-slot:${f[which][1]}}`).join("");
 /**
@@ -27,6 +27,7 @@ ${Object.entries(FLOORS).map(([name, f]) => `html[data-theme=dark] .kyogijo.ky-m
 .kyogijo .ky-mu-hallfloor{fill:var(--ky-mu-neutral);stroke:var(--ky-mu-wall);stroke-width:.8}
 ${Object.keys(FLOORS).map((name) => `.kyogijo .ky-mu-hf-${name}{fill:var(--ky-mu-f-${name})}`).join("\n")}
 .kyogijo .ky-mu-wall{fill:none;stroke:var(--ky-mu-wall);stroke-width:2.2;stroke-linejoin:round}
+.kyogijo .ky-mu-shadow{fill:var(--ky-mu-shadow)}
 .kyogijo .ky-mu-over{fill:none;stroke:var(--ky-mu-over);stroke-width:1.4;stroke-dasharray:5 3}
 .kyogijo .ky-mu-barrier{fill:none;stroke:var(--ky-mu-barrier);stroke-width:1;stroke-opacity:.9}
 .kyogijo .ky-mu-board{fill:var(--ky-mu-board)}

package/dist/multi.turn.d.ts

@@ -0,0 +1,32 @@
+import type { MultiOptions } from "./multi.types.ts";
+import { type PresetTable } from "./turn.camera.ts";
+import { type KyogijoTurn } from "./turn.dom.ts";
+import { type TurnModel, type TurnSettings } from "./turn.model.ts";
+import type { Sport } from "./types.ts";
+/** How high a surround stands: the ITTF's "about 75 cm" (Handbook 3.2.3.3). A layout of another sport with surrounds has the same (ours: no other rulebook is read for it). */
+export declare const SURROUND_HEIGHT: number;
+/**
+ * The viewpoints of a layout. Overhead, broadcast and the low corner are a single surface's (`TURN_PRESETS`); the end-on view of a net sport looks along its surfaces' length, where the nets are seen whole, as `NET_PRESETS` does. All are turned a quarter where
+ * the floor or the surfaces stand across the picture, so that the long way of the floor runs across the screen. `floor` is the picture's frame (the hall's, turned if the hall asks) and `lengthAlongX` says whether the surfaces' length runs along its x.
+ */
+export declare function multiPresets(sport: Sport, floor: {
+    w: number;
+    h: number;
+}, lengthAlongX: boolean): PresetTable;
+/**
+ * A tournament layout as a 3D model: the floor is the layout's flat drawing, and on it stand each surface as it stands on its own page, the surrounds, the umpires' chairs and score tables, the scoreboards and, with `stadium`, the stands
+ * of the hall. A `TurnModel` like any other: `turnMarkupOf` and `mountMultiTurn` make a view of it.
+ */
+export declare function buildMultiTurn(options: MultiOptions, settings?: TurnSettings): TurnModel;
+/**
+ * Mount a tournament layout as a 3D view in a container: the same view as `mountKyogijoTurn`'s, with the controls, the pointer, the keys and the auto-turn of every 3D view, over the layout's floor with each surface standing on it.
+ * @example
+ * ```ts no-run
+ * import { mountMultiTurn } from "@johnmorrisdotca/kyogijo-stadiums/multi";
+ * const view = mountMultiTurn(document.querySelector("#hall")!, { preset: "tabletennis-4", stadium: true }, { preset: "broadcast" });
+ * view.set({ yaw: 40 });
+ * ```
+ */
+export declare function mountMultiTurn(host: HTMLElement, options: MultiOptions, settings?: TurnSettings): KyogijoTurn<MultiOptions>;
+/** A tournament layout as the markup of a 3D view, still until a page's script makes it turn: pure, so a server can make it. */
+export declare function multiTurnMarkup(options: MultiOptions, settings?: TurnSettings): string;

package/dist/multi.turn.js

@@ -0,0 +1,253 @@
+// A tournament layout in 3D: the 3D view of `turn.ts`, with a layout's several surfaces on its floor. Nothing here is drawn a second way. Each surface stands as it does on its own page (`uprightsFor`: the nets and posts, a table
+// tennis table's legs and skirt), moved to where the layout puts it, and the stands of the stadium round the hall are the 3D view's own (`standsVenueOf`); what only a layout has (the surrounds between the areas, the umpires'
+// chairs and score tables, the scoreboards) is stood up from the same figures the flat drawing draws, and the floor is the flat drawing itself, `multiDrawing` made for raising. The model it makes is a `TurnModel`, so the
+// camera, the controls, the pointer, the auto-turn and the tests of every other 3D view are this one's.
+import { FEET_PER_METRE } from "./geometry.js";
+import { multiDrawing } from "./multi.draw.js";
+import { outlineOf } from "./outline.js";
+import { hash } from "./format.js";
+import { TURN_PRESETS, NET_PRESETS, wrap } from "./turn.camera.js";
+import { flat, n, plane, shy, thinnest, wall } from "./turn.kit.js";
+import { mountTurn } from "./turn.dom.js";
+import { turnMarkupOf } from "./turn.markup.js";
+import { openingView, sceneBox } from "./turn.model.js";
+import { describeUprights, planesOf, uprightsFor } from "./uprights.js";
+import { standsVenueOf } from "./venue.js";
+import { isNetSport } from "./court.js";
+/** How high a surround stands: the ITTF's "about 75 cm" (Handbook 3.2.3.3). A layout of another sport with surrounds has the same (ours: no other rulebook is read for it). */
+export const SURROUND_HEIGHT = 0.75 * FEET_PER_METRE;
+/** The longest piece a surround is cut into, in feet: a long wall is several planes, so that each is drawn in its place among the surfaces and the chairs and not as one slab sorted by its middle. */
+const SURROUND_PIECE = 10;
+/** An umpire's chair's seat and a score table's top, in feet over the floor (ours: the rule gives no height for either). */
+const CHAIR = 1.5;
+const DESK = 2.5;
+/** Where the scoreboards hang (ours): the one over the middle of the floor has its lower edge 13 feet up and its cables run 8 feet above its top; the one at each surface stands 2.6 feet off the floor. */
+const HUNG = { bottom: 13, cables: 8 };
+const STANDING = { legs: 2.6, tall: 1.4 };
+const mapOf = (to) => {
+    const [e, f] = to(0, 0);
+    const [px, py] = to(1, 0);
+    const [qx, qy] = to(0, 1);
+    return { a: px - e, b: qx - e, c: py - f, d: qy - f, e, f };
+};
+const at = (m, x, y) => [m.a * x + m.b * y + m.e, m.c * x + m.d * y + m.f];
+const dir = (m, x, y) => [m.a * x + m.b * y, m.c * x + m.d * y];
+/** A plane moved by a map, under a new id. A plane that stands in a frame turned a quarter turns with it: its corner, its two sides and the way it faces out. */
+function place(p, m, id) {
+    const [ox, oy] = at(m, p.o[0], p.o[1]);
+    const [ux, uy] = dir(m, p.u[0], p.u[1]);
+    const [vx, vy] = dir(m, p.v[0], p.v[1]);
+    const moved = { ...p, id, o: [ox, oy, p.o[2]], u: [ux, uy, p.u[2]], v: [vx, vy, p.v[2]] };
+    if (p.shy !== undefined)
+        moved.shy = dir(m, p.shy[0], p.shy[1]);
+    if (p.crop === true) {
+        // A picture of the floor over a rectangle keeps its sides along x and y.
+        const corners = [at(m, p.o[0], p.o[1]), at(m, p.o[0] + p.u[0], p.o[1] + p.u[1]), at(m, p.o[0] + p.v[0], p.o[1] + p.v[1]), at(m, p.o[0] + p.u[0] + p.v[0], p.o[1] + p.u[1] + p.v[1])];
+        const [x0, x1] = [Math.min(...corners.map((c) => c[0])), Math.max(...corners.map((c) => c[0]))];
+        const [y0, y1] = [Math.min(...corners.map((c) => c[1])), Math.max(...corners.map((c) => c[1]))];
+        moved.o = [x0, y0, p.o[2]];
+        moved.u = [x1 - x0, 0, 0];
+        moved.v = [0, y1 - y0, 0];
+    }
+    return moved;
+}
+const rect = (x, y, w, h) => ({ x0: x, y0: y, x1: x + w, y1: y + h });
+/** A solid box on the floor: four sides up to `z1` and a flat top. `cls` paints the top; the sides are one tone darker (`cls-side`). */
+function box(id, kind, r, z1, cls) {
+    const sides = [[r.x0, r.y0, r.x1, r.y0], [r.x1, r.y0, r.x1, r.y1], [r.x1, r.y1, r.x0, r.y1], [r.x0, r.y1, r.x0, r.y0]];
+    const planes = sides.map(([a, b, c, d], i) => wall(`${id}-${i + 1}`, kind, a, b, c, d, 0, z1, `<rect width="${n(Math.hypot(c - a, d - b))}" height="${n(z1)}" class="${cls}-side"/>`));
+    planes.push(flat(`${id}-top`, kind, r.x0, r.y0, r.x1, r.y1, z1, `<rect width="${n(r.x1 - r.x0)}" height="${n(r.y1 - r.y0)}" class="${cls}"/>`));
+    return planes;
+}
+/** The surround of one area: four sides over the rectangle, each in pieces of at most `SURROUND_PIECE`, facing out from the area's middle (it gives way to a nearly level eye, as the glass of a rink does, but only then). */
+function surround(id, r) {
+    const centre = [(r.x0 + r.x1) / 2, (r.y0 + r.y1) / 2];
+    const sides = [[r.x0, r.y0, r.x1, r.y0], [r.x1, r.y0, r.x1, r.y1], [r.x1, r.y1, r.x0, r.y1], [r.x0, r.y1, r.x0, r.y0]];
+    const planes = [];
+    sides.forEach(([xa, ya, xb, yb], side) => {
+        const long = Math.hypot(xb - xa, yb - ya);
+        const pieces = Math.max(1, Math.ceil(long / SURROUND_PIECE));
+        const rim = Math.min(0.3, SURROUND_HEIGHT * 0.12);
+        for (let i = 0; i < pieces; i += 1) {
+            const [t0, t1] = [i / pieces, (i + 1) / pieces];
+            const run = long / pieces;
+            const svg = `<rect width="${n(run)}" height="${n(SURROUND_HEIGHT)}" class="u-surround"/><rect width="${n(run)}" height="${n(rim)}" class="u-surround-rim"/>`;
+            const p = wall(`${id}-${side + 1}-${i + 1}`, "surround", xa + (xb - xa) * t0, ya + (yb - ya) * t0, xa + (xb - xa) * t1, ya + (yb - ya) * t1, 0, SURROUND_HEIGHT, svg);
+            planes.push({ ...shy(p, centre), fadeTo: 0.35, fadeAt: 0.85 });
+        }
+    });
+    return planes;
+}
+/** A scoreboard that faces the eye: its panel (and where it is divided into the panels of the areas), hung on cables from over its top, or standing on legs. */
+function board(id, cx, cy, wide, tall, bottom, extra, hung, cuts) {
+    const total = tall + extra;
+    const top = hung ? extra : 0;
+    const line = Math.max(0.12, wide * 0.008);
+    const holds = hung
+        ? `<path d="M${n(wide * 0.12)} 0V${n(extra)}M${n(wide * 0.88)} 0V${n(extra)}" class="u-sbline" fill="none" stroke-width="${n(line)}"/>`
+        : `<path d="M${n(wide * 0.14)} ${n(tall)}V${n(total)}M${n(wide * 0.86)} ${n(tall)}V${n(total)}" class="u-sbline" fill="none" stroke-width="${n(line * 1.6)}"/>`;
+    const panel = `<rect x="0" y="${n(top)}" width="${n(wide)}" height="${n(tall)}" rx="${n(wide * 0.02)}" class="u-sbframe"/>${cuts === "" ? "" : `<path d="${cuts}" transform="translate(0 ${n(top)})" class="u-sbline" fill="none" stroke-width="${n(line * 0.7)}"/>`}`;
+    return { ...plane(id, "screen", [cx - wide / 2, cy, bottom + total], [wide, 0, 0], [0, 0, -total], `${holds}${panel}`), billboard: true };
+}
+/**
+ * The viewpoints of a layout. Overhead, broadcast and the low corner are a single surface's (`TURN_PRESETS`); the end-on view of a net sport looks along its surfaces' length, where the nets are seen whole, as `NET_PRESETS` does. All are turned a quarter where
+ * the floor or the surfaces stand across the picture, so that the long way of the floor runs across the screen. `floor` is the picture's frame (the hall's, turned if the hall asks) and `lengthAlongX` says whether the surfaces' length runs along its x.
+ */
+export function multiPresets(sport, floor, lengthAlongX) {
+    const portrait = floor.h > floor.w ? 90 : 0;
+    const nets = isNetSport(sport);
+    const end = nets ? NET_PRESETS.end : TURN_PRESETS.end;
+    const along = nets ? (lengthAlongX ? 0 : 90) : portrait;
+    return {
+        overhead: { ...TURN_PRESETS.overhead, yaw: portrait },
+        broadcast: { ...TURN_PRESETS.broadcast, yaw: wrap(TURN_PRESETS.broadcast.yaw + portrait) },
+        end: { ...end, yaw: wrap(end.yaw + along) },
+        corner: { ...TURN_PRESETS.corner, yaw: wrap(TURN_PRESETS.corner.yaw + portrait) },
+    };
+}
+/**
+ * A tournament layout as a 3D model: the floor is the layout's flat drawing, and on it stand each surface as it stands on its own page, the surrounds, the umpires' chairs and score tables, the scoreboards and, with `stadium`, the stands
+ * of the hall. A `TurnModel` like any other: `turnMarkupOf` and `mountMultiTurn` make a view of it.
+ */
+export function buildMultiTurn(options, settings = {}) {
+    const wanted = settings.uprights;
+    const upOptions = wanted === false || wanted === true || wanted === undefined ? {} : wanted;
+    const on = wanted !== false;
+    const stadiumOn = settings.venue !== false && options.stadium !== undefined && options.stadium !== false;
+    const drawn = multiDrawing(stadiumOn ? options : { ...options, stadium: undefined }, true, on);
+    const { frame, title, description } = drawn;
+    const layout = frame.layout;
+    const spec = layout.spec;
+    const language = options.language === "ja" ? "ja" : "en";
+    const id = settings.id ?? (typeof options.id === "string" && options.id !== "" ? `${options.id}-turn` : `ky-turn-${hash(JSON.stringify([options, settings.uprights, settings.preset, settings.venue]))}`);
+    const only = upOptions.only;
+    const keep = (kind) => only === undefined || only.includes(kind);
+    const items = [];
+    const toPicture = mapOf(frame.to);
+    if (on) {
+        // ---- Each surface, as it stands on its own page, moved to its cell. ----
+        const common = { ...spec.surface, margin: 0, language };
+        if (spec.kind === "cells") {
+            const own = uprightsFor(common, { ...upOptions, venue: undefined, score: "floor" });
+            const surfaceBox = outlineOf(spec.surface).box;
+            for (const cell of layout.cells) {
+                const into = mapOf((x, y) => frame.to(...(cell.turn ? [cell.x + cell.w - y, cell.y + x] : [cell.x + x, cell.y + y])));
+                for (const item of own.items) {
+                    // The hall's floor under a table is the layout's own, so the planes that stood in for it are left behind.
+                    const planes = item.planes.filter((p) => p.kind !== "ground").map((p) => place(p, into, `c${cell.n}-${p.id}`));
+                    if (planes.length > 0)
+                        items.push({ ...item, id: `c${cell.n}-${item.id}`, at: at(into, item.at[0], item.at[1]), planes });
+                }
+            }
+            // A surface that stands over the floor (a table's top) is a plane of its own, with the surface's own drawing on it.
+            for (const lifted of drawn.lifted) {
+                const local = flat("table-top", "table", 0, 0, surfaceBox.w, surfaceBox.h, lifted.lift, `<g transform="translate(${n(-lifted.box.x)} ${n(-lifted.box.y)})">${lifted.body}</g>`);
+                const into = mapOf((x, y) => frame.to(...(lifted.cell.turn ? [lifted.cell.x + lifted.cell.w - y, lifted.cell.y + x] : [lifted.cell.x + x, lifted.cell.y + y])));
+                items.push({ id: `c${lifted.cell.n}-table-top`, kind: "table-legs", at: at(into, surfaceBox.w / 2, surfaceBox.h / 2), height: lifted.lift, planes: [place(local, into, `c${lifted.cell.n}-table-top`)] });
+            }
+        }
+        // ---- What only a layout has. ----
+        const parts = spec.parts;
+        const layoutPlanes = (ps) => ps.map((p) => place(p, toPicture, p.id));
+        if (parts.barriers === true && upOptions.boards !== false && keep("surrounds")) {
+            const planes = layout.cells.flatMap((c) => surround(`c${c.n}-surround`, { x0: c.bay.x + 0.5, y0: c.bay.y + 0.5, x1: c.bay.x + c.bay.w - 0.5, y1: c.bay.y + c.bay.h - 0.5 }));
+            items.push({ id: "surrounds", kind: "surrounds", at: at(toPicture, layout.floor.w / 2, layout.floor.h / 2), height: SURROUND_HEIGHT, planes: layoutPlanes(planes) });
+        }
+        if (parts.officials === true && keep("officials")) {
+            const planes = [];
+            for (const c of layout.cells)
+                planes.push(...officialsOf(c));
+            items.push({ id: "officials", kind: "officials", at: at(toPicture, layout.floor.w / 2, layout.floor.h / 2), height: DESK, planes: layoutPlanes(planes) });
+        }
+        if (keep("scoreboard")) {
+            const boards = [];
+            if (parts.scoreboard === "each")
+                for (const c of layout.cells)
+                    boards.push(board(`c${c.n}-scoreboard`, c.x + c.w / 2, c.y + c.h + 1.9, 4, STANDING.tall, 0, STANDING.legs, false, ""));
+            const sb = layout.shared;
+            if (sb !== undefined) {
+                const count = layout.cells.length;
+                const cols = count <= 4 ? Math.min(2, count) : count;
+                const rows = count <= 4 && count > 2 ? 2 : 1;
+                let cuts = "";
+                for (let i = 1; i < cols; i += 1)
+                    cuts += `M${n((sb.w * i) / cols)} 0v${n(sb.h)}`;
+                for (let j = 1; j < rows; j += 1)
+                    cuts += `M0 ${n((sb.h * j) / rows)}h${n(sb.w)}`;
+                boards.push(board("scoreboard", sb.x + sb.w / 2, sb.y + sb.h / 2, sb.w, sb.h, HUNG.bottom, HUNG.cables, true, cuts));
+            }
+            if (boards.length > 0)
+                items.push({ id: "scoreboard", kind: "scoreboard", at: at(toPicture, layout.floor.w / 2, layout.floor.h / 2), height: parts.scoreboard === "shared" ? HUNG.bottom : STANDING.legs, planes: layoutPlanes(boards) });
+        }
+    }
+    // ---- The stands of the stadium round the hall, in the picture's own frame. ----
+    let defs = "";
+    let crowdStyle = "";
+    if (drawn.stands !== undefined && keep("stands")) {
+        const roof = typeof settings.venue === "object" && settings.venue.roof !== undefined ? settings.venue.roof : typeof options.stadium === "object" && options.stadium.roof === true;
+        const venue = standsVenueOf(drawn.stands.stands, drawn.stands.crowd, { sport: drawn.stands.standsLike }, { ...(typeof settings.venue === "object" ? settings.venue : {}), roof, id }, 0);
+        items.push(...venue.items.filter((item) => item.kind !== "roof" || roof));
+        defs = venue.defs;
+        crowdStyle = "--ky-cr-home:#8b94a3;--ky-cr-away:#8b94a3";
+    }
+    // ---- The model. ----
+    const uprights = { items, lift: 0, thin: thinnest(drawn.view.w, drawn.view.h), area: { x0: drawn.view.x, y0: drawn.view.y, x1: drawn.view.x + drawn.view.w, y1: drawn.view.y + drawn.view.h }, whole: true, ...(defs === "" ? {} : { defs }) };
+    const planes = planesOf(uprights);
+    const scale = 1400 / Math.max(drawn.view.w, drawn.view.h);
+    const centre = [drawn.view.x + drawn.view.w / 2, drawn.view.y + drawn.view.h / 2];
+    const box3 = sceneBox(planes, uprights.area, 0, centre, scale);
+    const look = /^<svg[^>]* data-look="([^"]*)"/.exec(drawn.svg)?.[1];
+    const surfaceLike = { sport: spec.sport, language, ...(options.theme === undefined ? {} : { theme: options.theme }), ...(options.style === undefined ? {} : { style: options.style }) };
+    const standing = describeUprights(surfaceLike, uprights, language);
+    const first = layout.cells[0];
+    const presets = multiPresets(spec.sport, { w: frame.lw, h: frame.lh }, first === undefined || first.turn === frame.turned);
+    return {
+        id,
+        language,
+        options: surfaceLike,
+        title,
+        description: standing === "" ? description : `${description}${language === "ja" ? "" : " "}${standing}`,
+        standing,
+        floor: drawn.svg,
+        viewBox: { x: drawn.view.x, y: drawn.view.y, w: drawn.view.w, h: drawn.view.h },
+        scale,
+        uprights,
+        defs,
+        crowdStyle,
+        venue: drawn.stands !== undefined,
+        look: { sport: spec.sport, look: look ?? "plain" },
+        planes,
+        box: box3,
+        centre,
+        view: openingView(settings, presets),
+        turnable: true,
+        presets,
+        flat: multiDrawing(options, false).svg,
+    };
+}
+/** The umpire's chair and the score table beside a surface, where the flat drawing has them (feet, in the layout's frame). */
+function officialsOf(c) {
+    if (c.turn) {
+        // Beside the net, on the right of a surface that stands across the layout.
+        const cy = c.y + c.h / 2;
+        return [...box(`c${c.n}-chair`, "chair", rect(c.x + c.w + 1.8, cy - 3.2, 1.6, 1.6), CHAIR, "u-chair"), ...box(`c${c.n}-desk`, "desk", rect(c.x + c.w + 1.5, cy - 0.8, 1.1, 3.6), DESK, "u-chair")];
+    }
+    const cx = c.x + c.w / 2;
+    return [...box(`c${c.n}-chair`, "chair", rect(cx + 1.6, c.y - 3.4, 1.6, 1.6), CHAIR, "u-chair"), ...box(`c${c.n}-desk`, "desk", rect(cx - 5, c.y - 3.1, 3.6, 1.1), DESK, "u-chair")];
+}
+/**
+ * Mount a tournament layout as a 3D view in a container: the same view as `mountKyogijoTurn`'s, with the controls, the pointer, the keys and the auto-turn of every 3D view, over the layout's floor with each surface standing on it.
+ * @example
+ * ```ts no-run
+ * import { mountMultiTurn } from "@johnmorrisdotca/kyogijo-stadiums/multi";
+ * const view = mountMultiTurn(document.querySelector("#hall")!, { preset: "tabletennis-4", stadium: true }, { preset: "broadcast" });
+ * view.set({ yaw: 40 });
+ * ```
+ */
+export function mountMultiTurn(host, options, settings = {}) {
+    return mountTurn(host, options, settings, buildMultiTurn);
+}
+/** A tournament layout as the markup of a 3D view, still until a page's script makes it turn: pure, so a server can make it. */
+export function multiTurnMarkup(options, settings = {}) {
+    return turnMarkupOf(buildMultiTurn(options, settings), settings);
+}

package/dist/strings.d.ts

@@ -993,7 +993,7 @@ export interface KyogijoWords {
         item: string;
         itemSag: string;
         /** The names of what stands on the surface, by kind. */
-        parts: Record<"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", string>;
+        parts: Record<"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", string>;
     };
     /** The names of the zones that `zoneAt` answers with (rules.ts), by id. */
     rules: Record<RuleId, string>;

package/dist/strings.js

@@ -382,7 +382,7 @@ export const KYOGIJO_STRINGS = {
                 boundary: "Boundary", pitch: "Pitch", "bowling-crease": "Bowling crease", "popping-crease": "Popping crease", "return-crease": "Return crease", wicket: "Wicket", "thirty-yard-circle": "30-yard circle",
                 "twenty-three-line": "23-metre line", "shooting-circle": "Shooting circle", "penalty-spot": "Penalty spot", "broken-circle-line": "Broken line round the circle", "goal-area-line": "Goal-area line",
                 "finish-line": "Finish line", kerb: "Kerb", "lane-lines": "Lane lines", bend: "Bend", straight: "Straight", "infield-pitch": "Soccer pitch", "start-line": "Start line", breakline: "Breakline", "water-jump": "Water jump", "exchange-zone": "Takeover zone",
-                "referee-position": "Referee's place", "shiai-jo": "Shiai-jo", floorboard: "Floorboard", heri: "Heri, the mat's edge", "contest-area": "Contest area", "safety-area": "Safety area", "danger-zone": "Danger zone", "start-mark": "Start mark", "common-safe-zone": "Common safe zone", "free-zone": "Free zone", platform: "Platform", "technical-table": "Technical table", arena: "Arena floor", "competition-area": "Competition area", "boundary-band": "Boundary band", "start-mat": "Start mat", judge: "Judge", "between-areas": "Between the areas", "centre-cross": "Centre cross", "kaishi-sen": "Kaishi-sen", "outer-boundary": "Outer boundary", dohyo: "Dohyō", ring: "Ring", tawara: "Tawara", tokudawara: "Tokudawara", "shikiri-sen": "Shikiri-sen", "jano-me": "Jano-me", shajo: "Shajō", "shooting-position": "Shooting position", honza: "Honza", yamichi: "Yamichi", "yatori-michi": "Path for the arrows", azuchi: "Azuchi", mato: "Target", kamiza: "Kamiza", shimoza: "Shimoza", shinzen: "Shinzen", dais: "Dais, the seat of honour", banner: "Banner", entrance: "Entrance", window: "Window", tatami: "Tatami", wall: "Wall", "inner-lane": "Inner lane", "outer-lane": "Outer lane", "crossing-straight": "Crossing straight", "warm-up-lane": "Warm-up lane", padding: "Padding", infield: "Infield", "coaches-area": "Coaches' area", blocks: "Blocks", "track-line": "Line of the track", "start-lines": "Starting lines", ice: "Ice", "technical-panel": "Technical panel", referee: "Referee", "kiss-and-cry": "Kiss and cry", judges: "Judges", runway: "Runway", "take-off-board": "Take-off board", "landing-area": "Landing area", "throwing-circle": "Throwing circle", sector: "Landing sector", "stop-board": "Stop board", cage: "Cage", "throwing-arc": "Throwing arc", crossbar: "Crossbar", "landing-mat": "Landing mat", "run-up": "Run-up", "zero-line": "Zero line", box: "Box",
+                "referee-position": "Referee's place", "shiai-jo": "Shiai-jo", floorboard: "Floorboard", heri: "Heri, the mat's edge", "contest-area": "Contest area", "safety-area": "Safety area", "danger-zone": "Danger zone", "start-mark": "Start mark", "common-safe-zone": "Common safe zone", "free-zone": "Free zone", platform: "Platform", "technical-table": "Technical table", "centre-tape": "Centre tape", "kata-judges": "Judges, shomen side", "coach-chair": "Coach's chair", "kata-entry": "Entry and exit, opposite shomen", arena: "Arena floor", "competition-area": "Competition area", "boundary-band": "Boundary band", "start-mat": "Start mat", judge: "Judge", "between-areas": "Between the areas", "centre-cross": "Centre cross", "kaishi-sen": "Kaishi-sen", "outer-boundary": "Outer boundary", dohyo: "Dohyō", ring: "Ring", tawara: "Tawara", tokudawara: "Tokudawara", "shikiri-sen": "Shikiri-sen", "jano-me": "Jano-me", shajo: "Shajō", "shooting-position": "Shooting position", honza: "Honza", yamichi: "Yamichi", "yatori-michi": "Path for the arrows", azuchi: "Azuchi", mato: "Target", kamiza: "Kamiza", shimoza: "Shimoza", shinzen: "Shinzen", dais: "Dais, the seat of honour", banner: "Banner", entrance: "Entrance", window: "Window", tatami: "Tatami", wall: "Wall", "inner-lane": "Inner lane", "outer-lane": "Outer lane", "crossing-straight": "Crossing straight", "warm-up-lane": "Warm-up lane", padding: "Padding", infield: "Infield", "coaches-area": "Coaches' area", blocks: "Blocks", "track-line": "Line of the track", "start-lines": "Starting lines", ice: "Ice", "technical-panel": "Technical panel", referee: "Referee", "kiss-and-cry": "Kiss and cry", judges: "Judges", runway: "Runway", "take-off-board": "Take-off board", "landing-area": "Landing area", "throwing-circle": "Throwing circle", sector: "Landing sector", "stop-board": "Stop board", cage: "Cage", "throwing-arc": "Throwing arc", crossbar: "Crossbar", "landing-mat": "Landing mat", "run-up": "Run-up", "zero-line": "Zero line", box: "Box",
                 "seven-metre-line": "7-metre line", "four-metre-line": "4-metre line", "throw-off-area": "Throw-off area", "restraining-line": "Restraining line", "wing-line": "Wing line", "marking-area": "Marking area", "two-point-arc": "Two-point arc",
                 "lane-rope": "Lane rope", "lane-line": "Lane marking on the floor", "lane-end-cross": "Cross line at the end of the lane marking", "fifteen-metre-mark": "15 m mark", "touch-pad": "Touch panel", "starting-block": "Starting block", "backstroke-flags": "Backstroke flags", "false-start-rope": "False start rope", gutter: "Gutter",
                 "two-metre-line": "2 m line", "five-metre-mark": "5 m mark", "six-metre-line": "6 m line", "half-distance-line": "Half distance line", "re-entry-area": "Re-entry area", "referee-platform": "Referee platform", "official-table": "Official table", "substitution-area": "Substitution area",
@@ -432,7 +432,7 @@ export const KYOGIJO_STRINGS = {
             announce: "{name} view", announceAngle: "Turned to {yaw} degrees, seen from {pitch} degrees above the floor.",
             flat: "This browser cannot draw the 3D view, so the flat drawing is shown.",
             standing: "Standing on it, in the 3D view: {list}.", item: "{name} {h}", itemSag: "{name} {h} at the posts, {low} at the middle",
-            parts: { scoreboard: "scoreboard (lower edge)", net: "net", antennae: "antennae", goalposts: "goal posts", netposts: "net posts", hoop: "baskets", goal: "goals", boards: "boards and glass", stumps: "stumps", pylons: "pylons", flags: "corner flags", fence: "fence", backstop: "backstop", "foul-poles": "foul poles", "table-legs": "table top", walls: "walls", "starting-blocks": "starting blocks", "backstroke-flags": "backstroke flags", "false-start-rope": "false start rope", springboards: "springboards", platforms: "platforms", "judges-stand": "judges' stand", hurdles: "hurdles", steeplechase: "steeplechase barriers", "high-jump": "high jump uprights and bar", "pole-vault": "pole vault uprights and bar", cage: "discus and hammer cage", padding: "padding", "rink-boards": "boards", mound: "clay mound", azuchi: "azuchi", targets: "targets", stands: "stands", "wall-seats": "seats on top of the wall", roof: "roof", gallery: "gallery", dais: "dais", banner: "banner", shrine: "shrine", "mat-edge": "mat thickness" },
+            parts: { scoreboard: "scoreboard (lower edge)", net: "net", antennae: "antennae", goalposts: "goal posts", netposts: "net posts", hoop: "baskets", goal: "goals", boards: "boards and glass", stumps: "stumps", pylons: "pylons", flags: "corner flags", fence: "fence", backstop: "backstop", "foul-poles": "foul poles", "table-legs": "table top", walls: "walls", "starting-blocks": "starting blocks", "backstroke-flags": "backstroke flags", "false-start-rope": "false start rope", springboards: "springboards", platforms: "platforms", "judges-stand": "judges' stand", hurdles: "hurdles", steeplechase: "steeplechase barriers", "high-jump": "high jump uprights and bar", "pole-vault": "pole vault uprights and bar", cage: "discus and hammer cage", padding: "padding", "rink-boards": "boards", mound: "clay mound", azuchi: "azuchi", targets: "targets", stands: "stands", "wall-seats": "seats on top of the wall", roof: "roof", gallery: "gallery", dais: "dais", banner: "banner", shrine: "shrine", "mat-edge": "mat thickness", surrounds: "surrounds", officials: "umpires' chairs and score tables" },
         },
         rules: {
             "defensive-zone": "Defensive zone",
@@ -917,7 +917,7 @@ export const KYOGIJO_STRINGS = {
                 "distance-line": "距離を示すライン", "large-rectangle": "大きい長方形", "small-rectangle": "小さい長方形", "thirteen-metre-arc": "13メートルアーク", "forty-metre-arc": "40メートルアーク", "penalty-point": "ペナルティーマーク",
                 boundary: "バウンダリー", pitch: "ピッチ", "bowling-crease": "ボウリングクリース", "popping-crease": "ポッピングクリース", "return-crease": "リターンクリース", wicket: "ウィケット", "thirty-yard-circle": "30ヤードサークル",
                 "twenty-three-line": "23メートルライン", "shooting-circle": "シューティングサークル", "penalty-spot": "ペナルティースポット", "broken-circle-line": "サークルを囲む破線", "goal-area-line": "ゴールエリアライン",
-                "referee-position": "主審の位置", "shiai-jo": "試合場", floorboard: "床板", heri: "畳縁", "contest-area": "試合場内", "safety-area": "安全地帯", "danger-zone": "危険地帯", "start-mark": "開始線", "common-safe-zone": "共通の安全地帯", "free-zone": "フリーゾーン", platform: "畳の台", "technical-table": "係員席", arena: "アリーナの床", "competition-area": "試合場", "boundary-band": "境界の帯", "start-mat": "開始位置のマット", judge: "副審", "between-areas": "試合場の間", "centre-cross": "中央の×印", "kaishi-sen": "開始線", "outer-boundary": "場外の余地", dohyo: "土俵", ring: "土俵の円", tawara: "俵", tokudawara: "徳俵", "shikiri-sen": "仕切り線", "jano-me": "蛇の目", shajo: "射場", "shooting-position": "射位", honza: "本座", yamichi: "矢道", "yatori-michi": "矢取道", azuchi: "安土", mato: "的", kamiza: "上座", shimoza: "下座", shinzen: "神棚", dais: "上座の台", banner: "垂れ幕", entrance: "入口", window: "窓", tatami: "畳", wall: "壁", "inner-lane": "インレーン", "outer-lane": "アウトレーン", "crossing-straight": "交差ストレート", "warm-up-lane": "ウォームアップレーン", padding: "防護マット", infield: "インフィールド", "coaches-area": "コーチエリア", blocks: "ブロック", "track-line": "トラックのライン", "start-lines": "スタートライン", ice: "氷面", "technical-panel": "テクニカルパネル", referee: "レフェリー", "kiss-and-cry": "キス・アンド・クライ", judges: "ジャッジ席", runway: "助走路", "take-off-board": "踏切板", "landing-area": "砂場", "throwing-circle": "投てきサークル", sector: "着地場所", "stop-board": "足留材", cage: "囲い", "throwing-arc": "スターティング・ライン", crossbar: "バー", "landing-mat": "着地マット", "run-up": "助走路", "zero-line": "ゼロライン", box: "ボックス",
+                "referee-position": "主審の位置", "shiai-jo": "試合場", floorboard: "床板", heri: "畳縁", "contest-area": "試合場内", "safety-area": "安全地帯", "danger-zone": "危険地帯", "start-mark": "開始線", "common-safe-zone": "共通の安全地帯", "free-zone": "フリーゾーン", platform: "畳の台", "technical-table": "係員席", "centre-tape": "中央のテープ", "kata-judges": "審判員席（正面側）", "coach-chair": "コーチ席", "kata-entry": "入退場口（正面の反対側）", arena: "アリーナの床", "competition-area": "試合場", "boundary-band": "境界の帯", "start-mat": "開始位置のマット", judge: "副審", "between-areas": "試合場の間", "centre-cross": "中央の×印", "kaishi-sen": "開始線", "outer-boundary": "場外の余地", dohyo: "土俵", ring: "土俵の円", tawara: "俵", tokudawara: "徳俵", "shikiri-sen": "仕切り線", "jano-me": "蛇の目", shajo: "射場", "shooting-position": "射位", honza: "本座", yamichi: "矢道", "yatori-michi": "矢取道", azuchi: "安土", mato: "的", kamiza: "上座", shimoza: "下座", shinzen: "神棚", dais: "上座の台", banner: "垂れ幕", entrance: "入口", window: "窓", tatami: "畳", wall: "壁", "inner-lane": "インレーン", "outer-lane": "アウトレーン", "crossing-straight": "交差ストレート", "warm-up-lane": "ウォームアップレーン", padding: "防護マット", infield: "インフィールド", "coaches-area": "コーチエリア", blocks: "ブロック", "track-line": "トラックのライン", "start-lines": "スタートライン", ice: "氷面", "technical-panel": "テクニカルパネル", referee: "レフェリー", "kiss-and-cry": "キス・アンド・クライ", judges: "ジャッジ席", runway: "助走路", "take-off-board": "踏切板", "landing-area": "砂場", "throwing-circle": "投てきサークル", sector: "着地場所", "stop-board": "足留材", cage: "囲い", "throwing-arc": "スターティング・ライン", crossbar: "バー", "landing-mat": "着地マット", "run-up": "助走路", "zero-line": "ゼロライン", box: "ボックス",
                 "finish-line": "フィニッシュライン", kerb: "縁石", "lane-lines": "レーンライン", bend: "曲走路", straight: "直走路", "infield-pitch": "サッカーのピッチ", "start-line": "スタートライン", breakline: "ブレイクライン", "water-jump": "水濠", "exchange-zone": "テークオーバーゾーン",
                 "seven-metre-line": "7mスローライン", "four-metre-line": "4mライン", "throw-off-area": "スローオフエリア", "restraining-line": "リストレイニングライン", "wing-line": "ウイングライン", "marking-area": "マーキングエリア", "two-point-arc": "2ポイントアーク",
                 "lane-rope": "レーンロープ", "lane-line": "床面のレーンライン", "lane-end-cross": "クロスライン", "fifteen-metre-mark": "15mマーク", "touch-pad": "タッチ板", "starting-block": "スタート台", "backstroke-flags": "背泳ぎ用フラッグ", "false-start-rope": "フォルススタートロープ", gutter: "ガター",
@@ -968,7 +968,7 @@ export const KYOGIJO_STRINGS = {
             announce: "{name}の視点", announceAngle: "向きは{yaw}度、見下ろす角度は{pitch}度です。",
             flat: "このブラウザーでは3D表示ができないため、平面の図を表示しています。",
             standing: "3D表示で立って見えるもの：{list}。", item: "{name} {h}", itemSag: "{name} 支柱の位置で{h}（中央は{low}）",
-            parts: { 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": "畳の厚み" },
+            parts: { 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: "審判席と記録台" },
         },
         rules: {
             "defensive-zone": "ディフェンディングゾーン",

package/dist/turn-entry.d.ts

@@ -1,4 +1,4 @@
-export { mountKyogijoTurn, turnSupported } from "./turn.dom.ts";
+export { mountKyogijoTurn, mountTurn, turnSupported } from "./turn.dom.ts";
 export type { KyogijoTurn } from "./turn.dom.ts";
 export { buildTurn, floorOptions, openingView } from "./turn.model.ts";
 export type { TurnModel, TurnSettings } from "./turn.model.ts";

package/dist/turn-entry.js

@@ -1,5 +1,5 @@
 // The 3D view: a surface as a floor that turns, with a net, a basket, a goal or a pair of posts standing on it.
-export { mountKyogijoTurn, turnSupported } from "./turn.dom.js";
+export { mountKyogijoTurn, mountTurn, turnSupported } from "./turn.dom.js";
 export { buildTurn, floorOptions, openingView } from "./turn.model.js";
 export { layoutOf, planeMarkup, planeMatrix, turnMarkup, turnMarkupOf } from "./turn.markup.js";
 export { KYOGIJO_TURN_STYLE } from "./turn.style.js";

package/dist/turn.camera.d.ts

@@ -25,8 +25,10 @@ export declare const NET_PRESETS: Readonly<Record<TurnPreset, TurnView>>;
  * stay nearly square on to it, and the end view looks along it.
  */
 export declare const CURLING_PRESETS: Readonly<Record<TurnPreset, TurnView>>;
-/** The four viewpoints of a sport. */
-export declare const presetsFor: (sport?: string) => Readonly<Record<TurnPreset, TurnView>>;
+/** The four viewpoints as a table. */
+export type PresetTable = Readonly<Record<TurnPreset, TurnView>>;
+/** The four viewpoints of a sport, or the table itself when it is given one (a tournament layout has its own). */
+export declare const presetsFor: (sport?: string | PresetTable) => PresetTable;
 /** The view a mount opens on. */
 export declare const TURN_DEFAULT: TurnPreset;
 export declare const PITCH_MAX = 84;
@@ -39,9 +41,9 @@ export declare function clampView(view: TurnView, fallback?: TurnView): TurnView
 /** The angle equal to `to` that is nearest to `from`, so that a change of view turns the short way round. */
 export declare const nearest: (from: number, to: number) => number;
 /** The view a viewpoint name stands for in a sport, or `undefined` for a name that is not one. */
-export declare const presetView: (name: string | undefined, sport?: string) => TurnView | undefined;
+export declare const presetView: (name: string | undefined, sport?: string | PresetTable) => TurnView | undefined;
 /** The name of the viewpoint a view is in a sport, or `undefined` when it is none of them (it has been turned by hand). */
-export declare function presetOf(view: TurnView, sport?: string): TurnPreset | undefined;
+export declare function presetOf(view: TurnView, sport?: string | PresetTable): TurnPreset | undefined;
 /** The steps of the keys and the buttons, in degrees, and the factor of a zoom step. A held Shift takes the larger. */
 export declare const STEP: {
     readonly yaw: 6;

package/dist/turn.camera.js

@@ -41,8 +41,8 @@ export const CURLING_PRESETS = {
 };
 /** The sports whose net runs across the court and whose viewpoints are `NET_PRESETS`. */
 const NET_SPORTS = ["tennis", "volleyball", "badminton", "pickleball", "tabletennis", "padel", "sepaktakraw", "teqball"];
-/** The four viewpoints of a sport. */
-export const presetsFor = (sport) => (sport === "curling" ? CURLING_PRESETS : sport !== undefined && NET_SPORTS.includes(sport) ? NET_PRESETS : sport !== undefined && LONG_SPORTS.includes(sport) ? LONG_PRESETS : TURN_PRESETS);
+/** The four viewpoints of a sport, or the table itself when it is given one (a tournament layout has its own). */
+export const presetsFor = (sport) => typeof sport === "object" ? sport : (sport === "curling" ? CURLING_PRESETS : sport !== undefined && NET_SPORTS.includes(sport) ? NET_PRESETS : sport !== undefined && LONG_SPORTS.includes(sport) ? LONG_PRESETS : TURN_PRESETS);
 /** The view a mount opens on. */
 export const TURN_DEFAULT = "corner";
 export const PITCH_MAX = 84;

package/dist/turn.dom.d.ts

@@ -1,8 +1,8 @@
 import { type TurnPreset, type TurnView } from "./turn.camera.ts";
-import { type TurnSettings } from "./turn.model.ts";
+import { type TurnModel, type TurnSettings } from "./turn.model.ts";
 import type { ScoreOptions, SurfaceOptions } from "./types.ts";
-/** What `mountKyogijoTurn` gives back. */
-export interface KyogijoTurn {
+/** What `mountKyogijoTurn` gives back. `O` is what `update` takes: the options of a drawing, or (for `mountMultiTurn`) of a tournament layout. */
+export interface KyogijoTurn<O = SurfaceOptions | ScoreOptions> {
     /** `3d`, or `flat` where the browser cannot draw the 3D view (or there is nothing to turn): the flat drawing is shown and the rest of this does nothing. */
     readonly mode: "3d" | "flat";
     /** The view now: where it is going if it is gliding. */
@@ -14,7 +14,7 @@ export interface KyogijoTurn {
     /** Back to the opening view. */
     reset(): void;
     /** Draw again with new options (a score that moved, a look that changed), keeping the view. */
-    update(options: SurfaceOptions | ScoreOptions): void;
+    update(options: O): void;
     /** Whether the auto-turn is running. */
     readonly playing: boolean;
     /** Start the auto-turn, a slow turn of the whole view. It gives whether it is running (a surface that cannot turn gives `false`). Nothing turns by itself until this, the Play button or Space starts it, unless `autoPlay` asked. */
@@ -46,3 +46,8 @@ export declare function turnSupported(win?: {
  * ```
  */
 export declare function mountKyogijoTurn(host: HTMLElement, options: SurfaceOptions | ScoreOptions, settings?: TurnSettings): KyogijoTurn;
+/**
+ * Mount any 3D model (`mountKyogijoTurn` is this with the model of one surface; `mountMultiTurn` with a tournament layout's): `build` makes the model from what `update` is given, and the rest, the controls, the pointer, the keys
+ * and the auto-turn, is the same.
+ */
+export declare function mountTurn<O>(host: HTMLElement, options: O, settings: TurnSettings, build: (options: O, settings: TurnSettings) => TurnModel): KyogijoTurn<O>;