@johnmorrisdotca/kyogijo-stadiums 0.40.2 → 0.44.0

package/dist/district.turn.js

@@ -2,8 +2,11 @@
 // (`buildTurn`: the stands, the walls and the roof, the goals and posts of its field), its planes are turned about the middle of its surface and moved to where the plan puts it, and the floor is the district's flat
 // plan drawn with each venue's building only. The model it makes is a `TurnModel`, so the camera, the controls, the pointer, the auto-turn and the steady fit of every other 3D view are this one's; its
 // buildings are stacked building by building (`Plane.group`), the far one first, so that a roof never shows through a nearer building.
-import { describeDistrict, districtId, drawDistrict, drawMember, planDistrict, surfaceCentre } from "./district.js";
-import { n, plane } from "./turn.kit.js";
+import { describeDistrict, districtId, drawDistrict, drawMember, nestedDrawing, planDistrict, surfaceCentre } from "./district.js";
+import { blockPlanes, contextUprights, shellBlock, slabPlanes } from "./context.js";
+import { dojo } from "./budo/dojo.api.js";
+import { KODOKAN_FLOORS, KODOKAN_GALLERY_LEVEL } from "./kodokan.js";
+import { APART, n, plane } from "./turn.kit.js";
 import { TURN_PRESETS, wrap } from "./turn.camera.js";
 import { mountTurn } from "./turn.dom.js";
 import { turnMarkupOf } from "./turn.markup.js";
@@ -11,6 +14,7 @@ import { buildTurn, lightingOf, openingView, sceneBox, WORLD_PX } from "./turn.m
 import { planesOf } from "./uprights.js";
 import { FEET_PER_METRE } from "./geometry.js";
 import { hullOf } from "./venues.geo.js";
+import { hasOutside, outsideCrowd, outsideLevelOf } from "./outside.js";
 /** The four viewpoints of a district, turned with the map: the main camera looks from the south over the district (north at the top of the page), the end-on view from the west and the low corner from the south-west. */
 export function districtPresets(plan) {
     const turn = plan.turn;
@@ -27,7 +31,7 @@ const rot = ([x, y], degrees) => {
     return [x * Math.cos(a) - y * Math.sin(a), x * Math.sin(a) + y * Math.cos(a)];
 };
 /** A plane of a venue's own frame (its surface's middle at `centre`) put in the district's: turned by the venue's angle about that middle and moved to where the plan puts it. */
-function placeInDistrict(p, placed, centre, prefix, group) {
+function placeInDistrict(p, placed, centre, prefix, group, lift = 0) {
     const at = (x, y) => {
         const [rx, ry] = rot([x - centre[0], y - centre[1]], placed.angle);
         return [rx + placed.at[0], ry + placed.at[1]];
@@ -36,7 +40,7 @@ function placeInDistrict(p, placed, centre, prefix, group) {
     const [ox, oy] = at(p.o[0], p.o[1]);
     const [ux, uy] = dir(p.u[0], p.u[1]);
     const [vx, vy] = dir(p.v[0], p.v[1]);
-    const moved = { ...p, id: `${prefix}${p.id}`, o: [ox, oy, p.o[2]], u: [ux, uy, p.u[2]], v: [vx, vy, p.v[2]], group };
+    const moved = { ...p, id: `${prefix}${p.id}`, o: [ox, oy, p.o[2] + lift], u: [ux, uy, p.u[2]], v: [vx, vy, p.v[2]], group };
     if (p.shy !== undefined)
         moved.shy = dir(p.shy[0], p.shy[1]);
     if (p.crop === true) {
@@ -72,24 +76,88 @@ export function buildDistrictTurn(options, settings = {}) {
     let crowdStyle = "";
     plan.members.forEach((placed, i) => {
         const member = placed.member;
-        const memberId = `${id}-m${i}`;
-        // Each venue is built as its own 3D view is, with the crowd drawn without its seats on its floor and the stands raised.
-        const model = buildTurn({ ...member.options, language, ...(options.theme === undefined ? {} : { theme: options.theme }), id: `${base}-m${i}` }, { ...settings, id: memberId, venue: { roof: true, ...(typeof settings.venue === "object" ? settings.venue : {}) }, preset: undefined, view: undefined });
-        const centre = surfaceCentre(member.options);
         const prefix = `m${i}-`;
-        for (const item of model.uprights.items) {
-            const planes = item.planes.filter((p) => p.kind !== "ground").map((p) => placeInDistrict(p, placed, centre, prefix, i));
-            if (planes.length > 0) {
-                const [ax, ay] = item.at;
-                const [rx, ry] = rot([ax - centre[0], ay - centre[1]], placed.angle);
-                items.push({ ...item, id: `${prefix}${item.id}`, at: [rx + placed.at[0], ry + placed.at[1]], planes });
+        // A venue may have several surfaces (the rooms of a floor): each is built as its own 3D view is, with the crowd drawn without its seats on its floor and the stands raised, and put where the plan puts it, in the venue's one group.
+        placed.parts.forEach((pp, j) => {
+            const part = pp.part;
+            const tag = j === 0 ? "" : `p${j}`;
+            const memberId = `${id}-m${i}${tag}`;
+            const model = buildTurn({ ...part.options, language, ...(options.theme === undefined ? {} : { theme: options.theme }), id: `${base}-m${i}${tag}` }, { ...settings, id: memberId, venue: { roof: true, ...(typeof settings.venue === "object" ? settings.venue : {}) }, preset: undefined, view: undefined });
+            const centre = surfaceCentre(part.options);
+            const pfx = `m${i}${tag}-`;
+            // A surface on an upper floor (the Kodokan's dojos) stands that high over the ground, on a floor drawn in the air; the ground under it is left bare.
+            const lift = part.elevation ?? 0;
+            // Which part of a room is drawn: what stands below the gallery's level, or what stands above it.
+            const lowest = (p) => Math.min(p.o[2], p.o[2] + p.u[2], p.o[2] + p.v[2], p.o[2] + p.u[2] + p.v[2]);
+            const shown = (p) => part.show === undefined || (part.show === "gallery") === (lowest(p) >= KODOKAN_GALLERY_LEVEL - 1e-6);
+            for (const item of model.uprights.items) {
+                const planes = item.planes.filter((p) => p.kind !== "ground" && shown(p)).map((p) => placeInDistrict(p, pp, centre, pfx, i, lift));
+                if (planes.length > 0) {
+                    const [ax, ay] = item.at;
+                    const [rx, ry] = rot([ax - centre[0], ay - centre[1]], pp.angle);
+                    items.push({ ...item, id: `${pfx}${item.id}`, at: [rx + pp.at[0], ry + pp.at[1]], height: item.height + lift, planes });
+                }
             }
+            if (lift > 0 && part.show !== "gallery") {
+                const { markup, box, styles } = nestedDrawing(drawMember(member, { ...options, id: base }, i, base, { floor: true }, j));
+                for (const block of styles)
+                    if (!defs.includes(block))
+                        defs.push(block);
+                const floor = plane("floor", "floor", [box.x, box.y, 0], [box.w, 0, 0], [0, box.h, 0], `<g transform="translate(${n(-box.x)} ${n(-box.y)})">${markup}</g>`);
+                items.push({ id: `${pfx}floor`, kind: "deck", at: pp.at, height: lift, planes: [placeInDistrict(floor, pp, centre, pfx, i, lift)] });
+                // The room's floor is a slab too, with an edge all round (the building's own floors do that for a chosen floor): its mats' rectangle and a hand's width more.
+                const spec = part.options.dojo;
+                if (member.plate === undefined && spec !== undefined && member.slabThickness !== undefined) {
+                    const room = dojo(spec);
+                    const m = 0.12 * FEET_PER_METRE;
+                    const [w, l] = [room.width * FEET_PER_METRE, room.length * FEET_PER_METRE];
+                    const corners = [[-m, -m], [w + m, -m], [w + m, l + m], [-m, l + m]].map(([x, y]) => {
+                        const [rx, ry] = rot([x - centre[0], y - centre[1]], pp.angle);
+                        return [rx + pp.at[0], ry + pp.at[1]];
+                    });
+                    const pixels = 1000 / Math.max(plan.view.w, plan.view.h);
+                    const thick = Math.min(Math.max(member.slabThickness * FEET_PER_METRE, 10 / pixels), ((member.shell?.height ?? 60) / (member.shell?.storeys ?? 8)) * 0.5);
+                    items.push({ id: `${pfx}slab`, kind: "deck", at: pp.at, height: lift, planes: slabPlanes(corners, lift, thick, { top: `${pfx}slab-top`, side: `${pfx}slab-s` }, "plain").map((p) => ({ ...p, group: i })) });
+                }
+            }
+            if (model.defs !== "")
+                defs.push(model.defs);
+            if (crowdStyle === "" && model.crowdStyle !== "")
+                crowdStyle = model.crowdStyle;
+        });
+        // The building it stands in: see-through (its walls give way to the eye) or solid, in the venue's group so that it is stacked with it.
+        if (member.shell !== undefined && options.building !== "none") {
+            // What is seen through its walls: the middle of the rooms in it (the building's own middle where a floor has none).
+            const inside = placed.parts.length === 0 ? placed.at : [placed.parts.reduce((s, q) => s + q.at[0], 0) / placed.parts.length, placed.parts.reduce((s, q) => s + q.at[1], 0) / placed.parts.length];
+            const block = shellBlock(member.key, placed.footprint, member.shell.height, options.building === "solid" ? undefined : inside);
+            const planes = blockPlanes(block, `${prefix}shell-`).map((p) => ({ ...p, group: i }));
+            items.push({ id: `${prefix}shell`, kind: "blocks", at: placed.at, height: member.shell.height, planes });
+        }
+        // The floors of the building as slabs with an edge: the one chosen is picked out (its plate, with its name over it), the others are faint. A slab is as thick as the venue says and never thinner than ten pixels at the page's own size.
+        if (member.slabs !== undefined && options.building !== "none") {
+            const pixels = 1000 / Math.max(plan.view.w, plan.view.h);
+            const thick = Math.min(Math.max((member.slabThickness ?? 0.6) * FEET_PER_METRE, 10 / pixels), ((member.shell?.height ?? 60) / (member.shell?.storeys ?? 8)) * 0.5);
+            for (const slab of member.slabs) {
+                const chosen = member.plate?.floor === slab.floor;
+                // The great dojo's floor, seen with every floor, has its own slab; and a solid building hides what is in it.
+                if (!chosen && ((member.plate === undefined && slab.floor === 7) || options.building === "solid"))
+                    continue;
+                const ids = chosen ? { top: `${prefix}plate`, side: `${prefix}plate-s` } : { top: `${prefix}plate-f${slab.floor}-top`, side: `${prefix}plate-f${slab.floor}-s` };
+                const planes = slabPlanes(placed.footprint, slab.level, thick, ids, chosen ? "chosen" : "faint").map((p) => ({ ...p, group: i }));
+                items.push({ id: ids.top, kind: "deck", at: placed.at, height: slab.level, planes });
+            }
+        }
+        if (member.plate !== undefined) {
+            const { floor, level } = member.plate;
+            const label = KODOKAN_FLOORS.find((f) => f.floor === floor)?.label[language] ?? String(floor);
+            const size = Math.max(plan.view.w, plan.view.h) * 0.018;
+            items.push({ id: `${prefix}plate-name`, kind: "scoreboard", at: placed.at, height: level + size * 1.7, planes: [sign(`${prefix}plate-name`, label, placed.at, level + size * 0.4, size, i)] });
         }
-        if (model.defs !== "")
-            defs.push(model.defs);
-        if (crowdStyle === "" && model.crowdStyle !== "")
-            crowdStyle = model.crowdStyle;
     });
+    // The buildings round the venues stand apart from them: each block's planes are of no venue's group.
+    if (plan.context !== undefined)
+        for (const item of contextUprights(plan.context))
+            items.push({ ...item, planes: item.planes.map((p) => ({ ...p, group: APART })) });
     if (labels) {
         const size = Math.max(plan.view.w, plan.view.h) * (plan.mode === "city" ? 0.016 : 0.022);
         plan.members.forEach((placed, i) => {
@@ -106,7 +174,7 @@ export function buildDistrictTurn(options, settings = {}) {
     const planes = planesOf(uprights);
     const box = sceneBox(planes, area, 0, centre, scale);
     // (The floor has no names: the 3D view's own signs, which face the eye, carry them.)
-    const floor = drawDistrict({ ...options, id: base, labels: false }, plan, (member, i) => drawMember(member, { ...options, id: base }, i, base, { floor: true }));
+    const floor = drawDistrict({ ...options, id: base, labels: false }, plan, (member, i, part) => drawMember(member, { ...options, id: base }, i, base, { floor: true }, part));
     const { title, description } = describeDistrict(options, plan);
     const presets = districtPresets(plan);
     const surfaceLike = { sport: "soccer", language, ...(options.theme === undefined ? {} : { theme: options.theme }), ...(options.style === undefined ? {} : { style: options.style }) };
@@ -136,6 +204,8 @@ export function buildDistrictTurn(options, settings = {}) {
         lens: 12,
         flat: drawDistrict(options, plan),
         groups: plan.members.map((p) => ({ hull: hullOf(p.footprint) })),
+        // The crowd outside, when the district asks for one and has a mask to put it on: the mount paints it on a canvas on the floor.
+        ...(options.outside !== undefined && hasOutside(plan) ? { outside: { level: outsideLevelOf(options), crowd: () => outsideCrowd(plan), viewBox: { x: view.x, y: view.y, w: view.w, h: view.h } } } : {}),
     };
 }
 /**

package/dist/gates.d.ts

@@ -0,0 +1,56 @@
+import { type LonLat } from "./venues.geo.ts";
+/** How a gate is known: `documented` is what a source cited with it says; `plausible` is ours. */
+export type GateBasis = "documented" | "plausible";
+/** What is said of a venue's gate: the way it faces, and what is read from where. */
+export interface GateFact {
+    /** A key that is the same on every run: `south`, `south-west-corner`. */
+    id: string;
+    /** The bearing of the gate's outward normal, degrees clockwise from north, 0 to under 360. */
+    bearing: number;
+    /** The name where a source gives one (`Gate G`); a plain description of where it is otherwise. */
+    name?: {
+        en: string;
+        ja: string;
+    };
+    basis: GateBasis;
+    read: string;
+}
+/** A gate, placed on a venue's outline. */
+export interface Gate {
+    /** `bc-place:south`: the venue's id and the gate's. */
+    key: string;
+    venue: string;
+    id: string;
+    name: {
+        en: string;
+        ja: string;
+    };
+    /** Where it stands on the outline, `[longitude, latitude]`. */
+    at: LonLat;
+    /** The bearing of its outward normal, degrees clockwise from north: the way a queue at it runs. */
+    bearing: number;
+    basis: GateBasis;
+    read: string;
+}
+/**
+ * The facts of each venue's gates. BC Place: the English Wikipedia article (revision 1372065649) says a tear in the old roof was "close to Gate G on the south side where the roof meets the top of the concrete bowl", so there is a
+ * Gate G on the south side (documented); the other seven are ours, one to each side of the building, on the street sides the brief names (Pacific Boulevard to the south, Robson and Beatty Streets). Rogers Arena: the brief's corner
+ * entrance plazas on the Pat Quinn Way side, the south front and the two south corners, and one at the north-west, all ours.
+ */
+export declare const GATE_FACTS: Readonly<Record<string, readonly GateFact[]>>;
+/** The ids of the venues that have gates. */
+export declare const GATE_VENUES: readonly string[];
+/** The name of a gate in a language: the source's where there is one, else its side (`South-west gate`). */
+export declare function gateName(fact: GateFact, language: "en" | "ja"): string;
+/**
+ * The gates of a venue (`bc-place`, `rogers-arena`), each on the building's outline where a ray from the middle of the surface at its bearing meets it; empty for a venue with none. A gate whose ray misses the outline is left out
+ * (none does for the venues here: a test holds it).
+ * @example
+ * ```ts
+ * import { venueGates } from "@johnmorrisdotca/kyogijo-stadiums/district";
+ * const gates = venueGates("bc-place");
+ * console.log(gates.length, gates.filter((g) => g.basis === "documented").map((g) => g.name.en).join(", "));
+ * // 8 Gate G
+ * ```
+ */
+export declare function venueGates(id: string): Gate[];

package/dist/gates.js

@@ -0,0 +1,95 @@
+// The gates of a real venue: where the crowd goes in. A gate is a point on the building's outline (OpenStreetMap's, ODbL 1.0) with the way it faces (the bearing of its outward normal, degrees clockwise from north), a name in English
+// and Japanese, and how it is known: `documented` where a source cited with it says it, `plausible` where it is ours (a gate on each street side, put where a ray from the middle of the surface at the bearing meets the outline).
+// The data is the gates' list of facts (`GATE_FACTS`, with what each cites); the positions are worked out from the outline, so a venue whose outline changes keeps its gates on it. This is the data the crowd's timelapse will use
+// for queues and entrances: where people stand in a line, which way the line runs (away from the gate along its bearing) and where the walkable ground starts. Pure: ids in, gates out.
+import { stadiumById } from "./stadiums.js";
+import { venueById } from "./venues.js";
+import { lonLatFrom, metresFrom } from "./venues.geo.js";
+const WIND = [
+    { en: "north", ja: "北" },
+    { en: "north-east", ja: "北東" },
+    { en: "east", ja: "東" },
+    { en: "south-east", ja: "南東" },
+    { en: "south", ja: "南" },
+    { en: "south-west", ja: "南西" },
+    { en: "west", ja: "西" },
+    { en: "north-west", ja: "北西" },
+];
+const ours = (reason) => `ours: ${reason}`;
+/** A gate on each of the eight sides of a building: ours, the sources say that a stadium has gates and not where each is. */
+const SIDES = (venue) => WIND.map((_, i) => ({ id: WIND[i].en, bearing: i * 45, basis: "plausible", read: ours(`one gate on each of the eight sides of ${venue}'s building: the sources say that it has gates round the bowl and not where each is`) }));
+/**
+ * The facts of each venue's gates. BC Place: the English Wikipedia article (revision 1372065649) says a tear in the old roof was "close to Gate G on the south side where the roof meets the top of the concrete bowl", so there is a
+ * Gate G on the south side (documented); the other seven are ours, one to each side of the building, on the street sides the brief names (Pacific Boulevard to the south, Robson and Beatty Streets). Rogers Arena: the brief's corner
+ * entrance plazas on the Pat Quinn Way side, the south front and the two south corners, and one at the north-west, all ours.
+ */
+export const GATE_FACTS = Object.freeze({
+    "bc-place": SIDES("BC Place").map((g) => (g.id === "south" ? { ...g, name: { en: "Gate G", ja: "ゲートG" }, basis: "documented", read: "the English Wikipedia article on BC Place, revision 1372065649: a tear in the old roof 'close to Gate G on the south side'; where on the south side is ours" } : g)),
+    "rogers-arena": [
+        { id: "south", bearing: 180, basis: "plausible", read: ours("the main front of the building faces Pat Quinn Way to the south, as the brief says") },
+        { id: "south-west", bearing: 225, basis: "plausible", read: ours("a corner entrance plaza on the Pat Quinn Way side, as the brief says") },
+        { id: "south-east", bearing: 135, basis: "plausible", read: ours("a corner entrance plaza on the Pat Quinn Way side, as the brief says") },
+        { id: "north-west", bearing: 315, basis: "plausible", read: ours("a gate on the side of the Georgia Viaduct and the towers, one of those the brief asks for at the corners") },
+    ],
+});
+/** The ids of the venues that have gates. */
+export const GATE_VENUES = Object.freeze(Object.keys(GATE_FACTS));
+/** The point where a ray from the origin at a compass bearing first meets a ring (both in metres east and north of the origin), or `undefined`. */
+function hit(ring, bearing) {
+    const a = (bearing * Math.PI) / 180;
+    const [dx, dy] = [Math.sin(a), Math.cos(a)];
+    let best;
+    ring.forEach(([ax, ay], i) => {
+        const [bx, by] = ring[(i + 1) % ring.length];
+        const [ex, ey] = [bx - ax, by - ay];
+        const den = dx * ey - dy * ex;
+        if (Math.abs(den) < 1e-12)
+            return;
+        const t = (ax * ey - ay * ex) / den;
+        const u = (ax * dy - ay * dx) / den;
+        if (t > 1e-6 && u >= 0 && u <= 1 && (best === undefined || t < best))
+            best = t;
+    });
+    return best === undefined ? undefined : [dx * best, dy * best];
+}
+/** The outline and the middle of a venue's surface that its gates are placed from, `[longitude, latitude]`: an arena's, or a stadium's. */
+function outlineOf(id) {
+    const venue = venueById(id);
+    if (venue !== undefined)
+        return { ring: venue.osm.ring, centre: venue.osm.axis.centre };
+    const stadium = stadiumById(id);
+    return stadium === undefined ? undefined : { ring: stadium.osm.ring, centre: stadium.osm.axis.centre };
+}
+/** The name of a gate in a language: the source's where there is one, else its side (`South-west gate`). */
+export function gateName(fact, language) {
+    if (fact.name !== undefined)
+        return fact.name[language];
+    const side = WIND.find((w) => w.en === fact.id.replace(/-corner$/, ""));
+    return language === "ja" ? `${side?.ja ?? fact.id}ゲート` : `${(side?.en ?? fact.id).replace(/^./, (c) => c.toUpperCase())} gate`;
+}
+/**
+ * The gates of a venue (`bc-place`, `rogers-arena`), each on the building's outline where a ray from the middle of the surface at its bearing meets it; empty for a venue with none. A gate whose ray misses the outline is left out
+ * (none does for the venues here: a test holds it).
+ * @example
+ * ```ts
+ * import { venueGates } from "@johnmorrisdotca/kyogijo-stadiums/district";
+ * const gates = venueGates("bc-place");
+ * console.log(gates.length, gates.filter((g) => g.basis === "documented").map((g) => g.name.en).join(", "));
+ * // 8 Gate G
+ * ```
+ */
+export function venueGates(id) {
+    const facts = GATE_FACTS[id];
+    const outline = outlineOf(id);
+    if (facts === undefined || outline === undefined)
+        return [];
+    const ring = metresFrom(outline.centre, outline.ring);
+    const gates = [];
+    for (const fact of facts) {
+        const p = hit(ring, fact.bearing);
+        if (p === undefined)
+            continue;
+        gates.push({ key: `${id}:${fact.id}`, venue: id, id: fact.id, name: { en: gateName(fact, "en"), ja: gateName(fact, "ja") }, at: lonLatFrom(outline.centre, p).map((x) => Math.round(x * 1e6) / 1e6), bearing: fact.bearing, basis: fact.basis, read: fact.read });
+    }
+    return gates;
+}

package/dist/halls.d.ts

@@ -61,5 +61,7 @@ export interface Hall {
         ja: string;
     };
 }
+/** The Kodokan's main dojo as drawn: a square floor of 420 jō's area, four contest areas, the seat of honour, the banner, the wood and the gallery, in the two looks the owner's photographs show. The years of both are unknown. */
+export declare const KODOKAN_MAIN: DojoSpec;
 /** The halls, in the order of their surfaces' fame: the Kodokan, the Budokan, the Kokugikan, the Butokuden and the Budokwai. */
 export declare const HALLS: readonly Hall[];

package/dist/halls.js

@@ -1,5 +1,5 @@
 /** The Kodokan's main dojo as drawn: a square floor of 420 jō's area, four contest areas, the seat of honour, the banner, the wood and the gallery, in the two looks the owner's photographs show. The years of both are unknown. */
-const KODOKAN_MAIN = {
+export const KODOKAN_MAIN = {
     mats: { width: 26.4, length: 26.4 },
     surround: 4,
     areas: { across: 2, down: 2 },

package/dist/kodokan.d.ts

@@ -0,0 +1,116 @@
+import type { DistrictMember } from "./district.ts";
+import type { DojoSpec, Language } from "./types.ts";
+/** The main dojo as the district draws it: the atlas's floor and fittings, with no wood round the mats (the 4 metres the atlas draws would not stand inside the real building). */
+export declare const KODOKAN_DOJO: DojoSpec;
+/** How high the room stands, floor to the top of its lid, in metres: the 3D build's own figure (walls of 4.5 metres, the gallery level with their tops, the lid over it), two storeys of the building. Ours. */
+export declare const KODOKAN_ROOM_HEIGHT = 11.2;
+/** The height of the main dojo's floor above the ground, in metres: the 7th floor, six storeys up at the building's own storey height (its height over its storeys, 5.4 metres), and no higher than leaves the room under the roof. */
+export declare const KODOKAN_FLOOR_HEIGHT: number;
+/** Where the Kodokan's building stands and what it is: for tests and pages that say it. */
+export declare const KODOKAN: {
+    readonly floorHeight: number;
+    readonly roomHeight: 11.2;
+    readonly mats: 420;
+    readonly seats: 900;
+    readonly source: "bldg_ec4aa7a9-f8cb-4abb-af0c-a2cef6d06dd8";
+    readonly read: "2026-10-22";
+    readonly ring: readonly [readonly [139.753281, 35.707485], readonly [139.753287, 35.707464], readonly [139.753659, 35.707456], readonly [139.753548, 35.707846], readonly [139.753502, 35.707837], readonly [139.753496, 35.707859], readonly [139.753195, 35.707801], readonly [139.753268, 35.707546], readonly [139.753193, 35.707532], readonly [139.75321, 35.707472]];
+    readonly height: 43.1;
+    readonly storeys: 8;
+    readonly room: {
+        readonly centre: readonly [139.75342, 35.707654];
+        readonly heading: 77;
+        readonly side: 31.8;
+        readonly clearance: 0.18;
+    };
+    readonly floors: {
+        readonly "5": {
+            readonly heading: 167;
+            readonly clearance: 2.59;
+            readonly rooms: readonly [{
+                readonly id: "womens";
+                readonly jo: 240;
+                readonly w: 27.3;
+                readonly l: 14.56;
+                readonly centre: readonly [139.753353, 35.707641];
+            }, {
+                readonly id: "boys";
+                readonly jo: 114;
+                readonly w: 17.29;
+                readonly l: 10.92;
+                readonly centre: readonly [139.75352, 35.707624];
+            }, {
+                readonly id: "special";
+                readonly jo: 40;
+                readonly w: 9.1;
+                readonly l: 7.28;
+                readonly centre: readonly [139.753483, 35.707752];
+            }];
+        };
+        readonly "6": {
+            readonly heading: 77;
+            readonly clearance: 2.43;
+            readonly rooms: readonly [{
+                readonly id: "school";
+                readonly jo: 240;
+                readonly w: 27.3;
+                readonly l: 14.56;
+                readonly centre: readonly [139.7534, 35.707724];
+            }, {
+                readonly id: "international";
+                readonly jo: 192;
+                readonly w: 21.84;
+                readonly l: 14.56;
+                readonly centre: readonly [139.75344, 35.707583];
+            }];
+        };
+    };
+};
+/** A room of a floor of the Kodokan: what the Kodokan's floor guide calls it, its count of jō where the guide gives one, and whether the room is drawn from that count or is ours. */
+export interface KodokanRoom {
+    id: string;
+    name: {
+        en: string;
+        ja: string;
+    };
+    /** Mats, in jō: the guide's count; `null` where it gives none (the special dojo: drawn at 40 jō, ours). */
+    mats: number | null;
+    /** The count the room is drawn at: the guide's, or ours where it gives none. */
+    drawn: number;
+}
+/** A floor of the Kodokan International Judo Center, the new building: its label, what the Kodokan's own floor guide lists on it, what is drawn there, and where the words come from. */
+export interface KodokanFloor {
+    /** 0 is the basement, 1 to 8 the floors above the ground. */
+    floor: number;
+    label: {
+        en: string;
+        ja: string;
+    };
+    /** What the floor guide lists on it, in each language (a floor with no entry of its own says what a second source says, `else`). */
+    lists: {
+        en: string;
+        ja: string;
+    };
+    rooms: KodokanRoom[];
+    /** What the view draws: the `rooms` the guide counts, the `great-dojo`, its `gallery`, only the floor's `plate` (nothing is published of its rooms), or `none` (under the ground). */
+    drawn: "rooms" | "great-dojo" | "gallery" | "plate" | "none";
+    /** Where the floor's words come from: the Kodokan's floor guide, and English Wikipedia where the guide says nothing. */
+    source: "kodokan" | "wikipedia";
+}
+/** The floors, from the basement up. The Kodokan's floor guide (施設のご案内, `docs/district.md`) lists 8F to B1; its 1F entry is empty, so the 1st floor is English Wikipedia's. */
+export declare const KODOKAN_FLOORS: readonly KodokanFloor[];
+/** The floors a district can be asked for: 0 (the basement) to 8. */
+export declare const KODOKAN_FLOOR_IDS: readonly number[];
+/** The height of a floor's level above the ground, in metres: the building's height over its storeys, for each floor under it (ours: the storeys are not all one height). */
+export declare const kodokanLevel: (floor: number) => number;
+/** How thick a floor of the building is drawn, in metres: its slab and its beams. Ours: a reinforced-concrete floor with its beams is some 0.4 to 0.8 metres of structure; the figure is a plausible one, and a floor is drawn no thinner than 10 pixels at the page's own size (`kodokanSlab`). */
+export declare const KODOKAN_SLAB = 0.6;
+/** The level of a floor's slab, in metres: the building's own storeys, except that the 7th is the great dojo's floor and the 8th the gallery's level over it. */
+export declare const kodokanSlabLevel: (floor: number) => number;
+/** The height of the gallery's level over the main dojo's floor, in feet: the room's walls, 4.5 metres. A plane that begins above it is the 8th floor's. */
+export declare const KODOKAN_GALLERY_LEVEL: number;
+/**
+ * The Kodokan as a member of a district. With a `floor`, it is that floor of the building: the 7th is the great dojo, the 8th its gallery, the 5th and 6th their dojos as the floor guide counts them (laid out by us), the others plain floor plates;
+ * the basement is under the ground and draws nothing. Throws for a floor that is not 0 to 8.
+ */
+export declare function kodokanMember(language: Language, floor?: number): DistrictMember;

package/dist/kodokan.data.d.ts

@@ -0,0 +1,61 @@
+/** The Kodokan's building and the place of its main dojo in it. */
+export declare const KODOKAN_BUILDING: {
+    /** The building's id in PLATEAU's file (bldg:Building gml:id). */
+    readonly source: "bldg_ec4aa7a9-f8cb-4abb-af0c-a2cef6d06dd8";
+    readonly read: "2026-10-22";
+    /** The roof-edge outline, `[longitude, latitude]`. */
+    readonly ring: readonly [readonly [139.753281, 35.707485], readonly [139.753287, 35.707464], readonly [139.753659, 35.707456], readonly [139.753548, 35.707846], readonly [139.753502, 35.707837], readonly [139.753496, 35.707859], readonly [139.753195, 35.707801], readonly [139.753268, 35.707546], readonly [139.753193, 35.707532], readonly [139.75321, 35.707472]];
+    /** The height of the building's top above its ground, in metres, and its storeys above ground. */
+    readonly height: 43.1;
+    readonly storeys: 8;
+    /** The middle of the main dojo's room, `[longitude, latitude]`, the compass heading of its x axis (0 to under 180) and the length of its side in metres, walls and gallery included. */
+    readonly room: {
+        readonly centre: readonly [139.75342, 35.707654];
+        readonly heading: 77;
+        readonly side: 31.8;
+        readonly clearance: 0.18;
+    };
+    /** The rooms of the 5th and 6th floors: each floor's heading (of its rooms' x axis), and for each room its count in jo, its size in metres (the dojo builder's shape for the count) and the middle of it, `[longitude, latitude]`. Ours but the counts. */
+    readonly floors: {
+        readonly "5": {
+            readonly heading: 167;
+            readonly clearance: 2.59;
+            readonly rooms: readonly [{
+                readonly id: "womens";
+                readonly jo: 240;
+                readonly w: 27.3;
+                readonly l: 14.56;
+                readonly centre: readonly [139.753353, 35.707641];
+            }, {
+                readonly id: "boys";
+                readonly jo: 114;
+                readonly w: 17.29;
+                readonly l: 10.92;
+                readonly centre: readonly [139.75352, 35.707624];
+            }, {
+                readonly id: "special";
+                readonly jo: 40;
+                readonly w: 9.1;
+                readonly l: 7.28;
+                readonly centre: readonly [139.753483, 35.707752];
+            }];
+        };
+        readonly "6": {
+            readonly heading: 77;
+            readonly clearance: 2.43;
+            readonly rooms: readonly [{
+                readonly id: "school";
+                readonly jo: 240;
+                readonly w: 27.3;
+                readonly l: 14.56;
+                readonly centre: readonly [139.7534, 35.707724];
+            }, {
+                readonly id: "international";
+                readonly jo: 192;
+                readonly w: 21.84;
+                readonly l: 14.56;
+                readonly centre: readonly [139.75344, 35.707583];
+            }];
+        };
+    };
+};

package/dist/kodokan.data.js

@@ -0,0 +1,20 @@
+// Made by scripts/build-plateau.mjs from data-sources/plateau/2026-10-22/: do not edit by hand.
+//
+// THIS FILE IS DATA FROM PROJECT PLATEAU, edited: the Kodokan's building (its roof-edge outline simplified to 0.3 metres, its height and its storeys, from MLIT's 3D city model of Bunkyo ward, 2025 edition) and where the main dojo's
+// room is put in it (worked out here from the outline, ours). The credit is `PLATEAU_ATTRIBUTION` (plateau.credit.ts), the terms the PLATEAU Site Policy's (free, commercial use included, compatible with CC BY 4.0). Apart from the
+// OpenStreetMap data (ODbL 1.0); nothing is copied from one to the other. The raw extract is in data-sources/plateau/.
+/** The Kodokan's building and the place of its main dojo in it. */
+export const KODOKAN_BUILDING = {
+    /** The building's id in PLATEAU's file (bldg:Building gml:id). */
+    "source": "bldg_ec4aa7a9-f8cb-4abb-af0c-a2cef6d06dd8",
+    "read": "2026-10-22",
+    /** The roof-edge outline, `[longitude, latitude]`. */
+    "ring": [[139.753281, 35.707485], [139.753287, 35.707464], [139.753659, 35.707456], [139.753548, 35.707846], [139.753502, 35.707837], [139.753496, 35.707859], [139.753195, 35.707801], [139.753268, 35.707546], [139.753193, 35.707532], [139.75321, 35.707472]],
+    /** The height of the building's top above its ground, in metres, and its storeys above ground. */
+    "height": 43.1,
+    "storeys": 8,
+    /** The middle of the main dojo's room, `[longitude, latitude]`, the compass heading of its x axis (0 to under 180) and the length of its side in metres, walls and gallery included. */
+    "room": { "centre": [139.75342, 35.707654], "heading": 77, "side": 31.8, "clearance": 0.18 },
+    /** The rooms of the 5th and 6th floors: each floor's heading (of its rooms' x axis), and for each room its count in jo, its size in metres (the dojo builder's shape for the count) and the middle of it, `[longitude, latitude]`. Ours but the counts. */
+    "floors": { "5": { "heading": 167, "clearance": 2.59, "rooms": [{ "id": "womens", "jo": 240, "w": 27.3, "l": 14.56, "centre": [139.753353, 35.707641] }, { "id": "boys", "jo": 114, "w": 17.29, "l": 10.92, "centre": [139.75352, 35.707624] }, { "id": "special", "jo": 40, "w": 9.1, "l": 7.28, "centre": [139.753483, 35.707752] }] }, "6": { "heading": 77, "clearance": 2.43, "rooms": [{ "id": "school", "jo": 240, "w": 27.3, "l": 14.56, "centre": [139.7534, 35.707724] }, { "id": "international", "jo": 192, "w": 21.84, "l": 14.56, "centre": [139.75344, 35.707583] }] } },
+};

package/dist/kodokan.js

@@ -0,0 +1,92 @@
+// The Kodokan (講道館) as a venue of a district: its building, from Project PLATEAU, and its main dojo (大道場), the room on the 7th floor with its gallery on the 8th, drawn in the air on its real floor over the building's own outline.
+// The facts that are documented are the count (420 jō of mats, four contest areas at once), the floor (the 7th), the gallery (the 8th, about 900) and the building (8 floors and a basement; PLATEAU: 8 storeys above ground, 43.1 metres): the Kodokan's own page, English
+// Wikipedia and the IJF say the first four (`docs/district.md`, "The Kodokan"). Ours: the shape of the floor (no source gives it: a square of 26.4 metres, the area of 420 jō, on which four areas of 8 metres fit, as `halls.ts` draws it), the room's place in the
+// building (the square that stands farthest from its walls, `scripts/build-plateau.mjs`), the wood round the mats (none, so that the room fits the real outline) and the height of the 7th floor (six storeys of the building's own). Pure data and a few sums.
+import { FEET_PER_METRE } from "./geometry.js";
+import { KODOKAN_MAIN } from "./halls.js";
+import { KODOKAN_BUILDING as BUILDING } from "./kodokan.data.js";
+import { PLATEAU_ATTRIBUTION } from "./plateau.credit.js";
+/** The main dojo as the district draws it: the atlas's floor and fittings, with no wood round the mats (the 4 metres the atlas draws would not stand inside the real building). */
+export const KODOKAN_DOJO = { ...KODOKAN_MAIN, surround: 0 };
+/** How high the room stands, floor to the top of its lid, in metres: the 3D build's own figure (walls of 4.5 metres, the gallery level with their tops, the lid over it), two storeys of the building. Ours. */
+export const KODOKAN_ROOM_HEIGHT = 11.2;
+/** The height of the main dojo's floor above the ground, in metres: the 7th floor, six storeys up at the building's own storey height (its height over its storeys, 5.4 metres), and no higher than leaves the room under the roof. */
+export const KODOKAN_FLOOR_HEIGHT = Math.min((6 * BUILDING.height) / BUILDING.storeys, BUILDING.height - KODOKAN_ROOM_HEIGHT);
+/** Where the Kodokan's building stands and what it is: for tests and pages that say it. */
+export const KODOKAN = { ...BUILDING, floorHeight: KODOKAN_FLOOR_HEIGHT, roomHeight: KODOKAN_ROOM_HEIGHT, mats: 420, seats: 900 };
+/** The floors, from the basement up. The Kodokan's floor guide (施設のご案内, `docs/district.md`) lists 8F to B1; its 1F entry is empty, so the 1st floor is English Wikipedia's. */
+export const KODOKAN_FLOORS = [
+    { floor: 0, label: { en: "B1", ja: "地下1階" }, lists: { en: "dining hall, training room, disaster-prevention centre", ja: "食堂、トレーニングルーム、防災センター" }, rooms: [], drawn: "none", source: "kodokan" },
+    { floor: 1, label: { en: "1F", ja: "1階" }, lists: { en: "parking, a bank and a store (the floor guide lists nothing here)", ja: "駐車場、銀行、売店（いずれも公式の案内には記載なし）" }, rooms: [], drawn: "plate", source: "wikipedia" },
+    { floor: 2, label: { en: "2F", ja: "2階" }, lists: { en: "museum and library, classroom, meeting rooms 3 and 4", ja: "資料館・図書館、教室、第3会議室、第4会議室" }, rooms: [], drawn: "plate", source: "kodokan" },
+    { floor: 3, label: { en: "3F", ja: "3階" }, lists: { en: "accommodation", ja: "宿泊施設" }, rooms: [], drawn: "plate", source: "kodokan" },
+    { floor: 4, label: { en: "4F", ja: "4階" }, lists: { en: "dojo guidance office, dojo reception, changing rooms", ja: "道場指導部、道場受付、更衣室（ロッカールーム）" }, rooms: [], drawn: "plate", source: "kodokan" },
+    {
+        floor: 5,
+        label: { en: "5F", ja: "5階" },
+        lists: { en: "women's dojo (240 jō), boys' dojo (114 jō), special dojo (no count given)", ja: "女子部道場（240畳）、少年部道場（114畳）、特別道場（畳数の記載なし）" },
+        rooms: [
+            { id: "womens", name: { en: "Women's dojo", ja: "女子部道場" }, mats: 240, drawn: 240 },
+            { id: "boys", name: { en: "Boys' dojo", ja: "少年部道場" }, mats: 114, drawn: 114 },
+            { id: "special", name: { en: "Special dojo", ja: "特別道場" }, mats: null, drawn: 40 },
+        ],
+        drawn: "rooms",
+        source: "kodokan",
+    },
+    {
+        floor: 6,
+        label: { en: "6F", ja: "6階" },
+        lists: { en: "school dojo (240 jō), international dojo (192 jō)", ja: "学校道場（240畳）、国際部道場（192畳）" },
+        rooms: [
+            { id: "school", name: { en: "School dojo", ja: "学校道場" }, mats: 240, drawn: 240 },
+            { id: "international", name: { en: "International dojo", ja: "国際部道場" }, mats: 192, drawn: 192 },
+        ],
+        drawn: "rooms",
+        source: "kodokan",
+    },
+    { floor: 7, label: { en: "7F", ja: "7階" }, lists: { en: "main dojo (420 jō)", ja: "大道場（420畳）" }, rooms: [{ id: "main", name: { en: "Main dojo", ja: "大道場" }, mats: 420, drawn: 420 }], drawn: "great-dojo", source: "kodokan" },
+    { floor: 8, label: { en: "8F", ja: "8階" }, lists: { en: "spectators' gallery (about 900 seats)", ja: "見学席（約900席）" }, rooms: [], drawn: "gallery", source: "kodokan" },
+];
+/** The floors a district can be asked for: 0 (the basement) to 8. */
+export const KODOKAN_FLOOR_IDS = KODOKAN_FLOORS.map((f) => f.floor);
+/** The height of a floor's level above the ground, in metres: the building's height over its storeys, for each floor under it (ours: the storeys are not all one height). */
+export const kodokanLevel = (floor) => ((floor - 1) * BUILDING.height) / BUILDING.storeys;
+/** How thick a floor of the building is drawn, in metres: its slab and its beams. Ours: a reinforced-concrete floor with its beams is some 0.4 to 0.8 metres of structure; the figure is a plausible one, and a floor is drawn no thinner than 10 pixels at the page's own size (`kodokanSlab`). */
+export const KODOKAN_SLAB = 0.6;
+/** The level of a floor's slab, in metres: the building's own storeys, except that the 7th is the great dojo's floor and the 8th the gallery's level over it. */
+export const kodokanSlabLevel = (floor) => (floor === 7 ? KODOKAN_FLOOR_HEIGHT : floor === 8 ? KODOKAN_FLOOR_HEIGHT + KODOKAN_GALLERY_LEVEL / FEET_PER_METRE : kodokanLevel(floor));
+/** The height of the gallery's level over the main dojo's floor, in feet: the room's walls, 4.5 metres. A plane that begins above it is the 8th floor's. */
+export const KODOKAN_GALLERY_LEVEL = 4.4 * FEET_PER_METRE;
+const roomOptions = (jo, language) => ({ sport: "dojo", dojo: { mats: jo, surround: 0, kamiza: "north" }, crowd: false, language });
+/**
+ * The Kodokan as a member of a district. With a `floor`, it is that floor of the building: the 7th is the great dojo, the 8th its gallery, the 5th and 6th their dojos as the floor guide counts them (laid out by us), the others plain floor plates;
+ * the basement is under the ground and draws nothing. Throws for a floor that is not 0 to 8.
+ */
+export function kodokanMember(language, floor) {
+    const base = {
+        key: "kodokan",
+        id: "kodokan",
+        kind: "hall",
+        name: { en: "Kodokan", ja: "講道館" },
+        ring: BUILDING.ring,
+        centre: BUILDING.room.centre,
+        heading: BUILDING.room.heading,
+        basis: "building",
+        seats: KODOKAN.seats,
+        options: { sport: "dojo", dojo: KODOKAN_DOJO, crowd: { real: true }, language },
+        elevation: KODOKAN_FLOOR_HEIGHT * FEET_PER_METRE,
+        shell: { height: BUILDING.height * FEET_PER_METRE, storeys: BUILDING.storeys },
+        attribution: PLATEAU_ATTRIBUTION,
+        slabs: KODOKAN_FLOORS.filter((f) => f.floor >= 1).map((f) => ({ floor: f.floor, level: kodokanSlabLevel(f.floor) * FEET_PER_METRE })),
+        slabThickness: KODOKAN_SLAB,
+    };
+    if (floor === undefined)
+        return base;
+    if (!Number.isInteger(floor) || !KODOKAN_FLOOR_IDS.includes(floor))
+        throw new Error(`the Kodokan has floors ${KODOKAN_FLOOR_IDS.join(", ")} (0 is the basement), not ${String(floor)}`);
+    const main = (show) => ({ key: "main", options: base.options, centre: base.centre, heading: base.heading, elevation: base.elevation, show });
+    const rooms = BUILDING.floors[String(floor)];
+    const parts = floor === 7 ? [main("room")] : floor === 8 ? [main("gallery")] : rooms === undefined ? [] : rooms.rooms.map((r) => ({ key: r.id, options: roomOptions(r.jo, language), centre: r.centre, heading: rooms.heading, elevation: kodokanLevel(floor) * FEET_PER_METRE }));
+    // The great dojo's own floor is the 7th's (a little under its storey height, so that the room stays under the roof), and the gallery's level is the room's wall height over it.
+    return { ...base, parts, ...(floor >= 1 ? { plate: { floor, level: kodokanSlabLevel(floor) * FEET_PER_METRE } } : {}) };
+}