@johnmorrisdotca/kyogijo-stadiums 0.19.0 → 0.21.0

package/dist/uprights.cage.js

@@ -0,0 +1,91 @@
+import { box, flat, mesh, n, pole, shy, threads, wall } from "./turn.kit.js";
+const K = 1 / 0.3048;
+/** The mesh of the fence: a cell of 5 cm (a diamond of chain link, drawn as a square grid, ours). */
+const CELL = 0.05 * K;
+/** The planes of the platform: its four sides from the floor of the building up to the canvas, and a top that is the floor's own drawing in the platform's rectangle. */
+function deckPlanes(plan, at, h) {
+    const b = plan.mma.platform;
+    const corners = [at(b.x0, b.y0), at(b.x1, b.y0), at(b.x1, b.y1), at(b.x0, b.y1)];
+    const planes = [];
+    corners.forEach((a, i) => {
+        const c = corners[(i + 1) % 4];
+        planes.push(wall(`deck-${i + 1}`, "wall", a[0], a[1], c[0], c[1], 0, h, `<rect width="${n(Math.hypot(c[0] - a[0], c[1] - a[1]))}" height="${n(h)}" class="u-deck-side"/>`));
+    });
+    planes.push({ ...flat("deck-top", "platform", corners[0][0], corners[0][1], corners[2][0], corners[2][1], h, ""), crop: true });
+    return planes;
+}
+/** The mesh of a fence panel w by h feet. */
+const meshOf = (w, h) => `<rect width="${n(w)}" height="${n(h)}" class="u-netfill"/>${threads(mesh(w, h, CELL), CELL)}`;
+/** What stands on a cage: the platform, the posts, the fence with its gates, and the steps. */
+export function cageUprights(plan, at, thin) {
+    const L = plan.mma;
+    if (L === undefined)
+        return [];
+    const fig = plan.figures;
+    const h0 = L.height * K;
+    const top = h0 + L.fence * K;
+    const centre = at(L.centre[0], L.centre[1]);
+    const items = [];
+    items.push({ id: "deck", kind: "deck", at: centre, height: h0, planes: deckPlanes(plan, at, h0) });
+    // The steps: each tread a block as high as the treads below it and itself, the lowest the farthest from the platform.
+    if (L.steps.length > 0) {
+        const s = fig.platform.steps;
+        const planes = [];
+        for (const b of L.steps) {
+            const north = b.y1 <= 0.0001;
+            for (let t = 0; t < s.treads; t += 1) {
+                // The tread t from the ground: its depth lies further in as t grows.
+                const y0 = north ? b.y0 + t * s.tread : b.y0;
+                const y1 = north ? b.y1 : b.y1 - t * s.tread;
+                const [x0, ya] = at(b.x0, y0);
+                const [x1, yb] = at(b.x1, y1);
+                planes.push(...box(`step-${north ? "north" : "south"}-${t + 1}`, "platform", { x0, y0: ya, x1, y1: yb }, (h0 * (t + 1)) / s.treads, "u-step"));
+            }
+        }
+        items.push({ id: "steps", kind: "deck", at: centre, height: h0, planes });
+    }
+    // The posts: padded, from the platform up a hand's breadth over the fence; solid, so two crossed strips as wide as the pad.
+    const padW = fig.post.pad * K;
+    const postTop = top + 0.15 * K;
+    const posts = L.posts.flatMap(([x, y], i) => {
+        const [px, py] = at(x, y);
+        return pole(`post-${i + 1}`, "post", px, py, h0, postTop, padW, "u-cagepad");
+    });
+    // The fence: one panel on each flat, in mesh, with a pad along the top and one along the foot. The panels give way to an eye that has them between it and the cage.
+    const rail = fig.post.rail * K;
+    const planes = [];
+    const doorH = fig.gates.height * K;
+    L.posts.forEach((p, i) => {
+        const q = L.posts[(i + 1) % L.posts.length];
+        const [ax, ay] = at(p[0], p[1]);
+        const [bx, by] = at(q[0], q[1]);
+        const len = Math.hypot(bx - ax, by - ay);
+        const gate = L.gates.find((g) => g.flat === i);
+        const wallOf = (id, x0, y0, x1, y1, z0, z1, svg, kind = "wall") => ({ ...shy(wall(id, kind, x0, y0, x1, y1, z0, z1, svg), centre), fadeTo: 0.3, fadeAt: 0.2 });
+        if (gate === undefined) {
+            planes.push(wallOf(`fence-${i + 1}`, ax, ay, bx, by, h0 + rail, top - rail, meshOf(len, top - rail - (h0 + rail)), "net"));
+        }
+        else {
+            const [fx, fy] = at(gate.from[0], gate.from[1]);
+            const [tx, ty] = at(gate.to[0], gate.to[1]);
+            const left = Math.hypot(fx - ax, fy - ay);
+            const open = Math.hypot(tx - fx, ty - fy);
+            const right = Math.hypot(bx - tx, by - ty);
+            planes.push(wallOf(`fence-${i + 1}a`, ax, ay, fx, fy, h0 + rail, top - rail, meshOf(left, top - rail - (h0 + rail)), "net"));
+            planes.push(wallOf(`fence-${i + 1}b`, tx, ty, bx, by, h0 + rail, top - rail, meshOf(right, top - rail - (h0 + rail)), "net"));
+            // Over the door: mesh from the door's head to the top pad. The door itself is a frame of padded rails round mesh, closed.
+            planes.push(wallOf(`fence-${i + 1}-over`, fx, fy, tx, ty, h0 + doorH, top - rail, meshOf(open, top - rail - (h0 + doorH)), "net"));
+            const leafH = doorH - rail;
+            const frame = `<rect x="${n(rail / 2)}" y="${n(rail / 2)}" width="${n(open - rail)}" height="${n(leafH - rail)}" class="u-gateframe" fill="none" stroke-width="${n(rail)}"/>`;
+            planes.push(wallOf(`gate-${gate.side}`, fx, fy, tx, ty, h0 + rail, h0 + doorH, `<rect width="${n(open)}" height="${n(doorH - rail)}" class="u-netfill"/>${threads(mesh(open, doorH - rail, CELL), CELL)}${frame}`, "wall"));
+        }
+        // The pads: along the top (the whole flat), and along the foot (except across a gate).
+        planes.push(wallOf(`fence-top-${i + 1}`, ax, ay, bx, by, top - rail, top, `<rect width="${n(len)}" height="${n(rail)}" class="u-cagepad"/>`, "rail"));
+        if (gate === undefined)
+            planes.push(wallOf(`fence-foot-${i + 1}`, ax, ay, bx, by, h0, h0 + rail, `<rect width="${n(len)}" height="${n(rail)}" class="u-cagepad"/>`, "rail"));
+    });
+    items.push({ id: "fence", kind: "cage-fence", at: centre, height: top - h0, planes });
+    items.push({ id: "posts", kind: "cage-posts", at: centre, height: postTop - h0, planes: posts });
+    void thin;
+    return items;
+}

package/dist/uprights.js

@@ -23,7 +23,7 @@ import { isPoolSport, poolPlan, feet as poolFeet } from "./pool.js";
 import { poolUprights } from "./uprights.pools.js";
 import { athleticsUprights, skatingUprights } from "./uprights.track.js";
 import { budoUprights } from "./uprights.budo.js";
-import { isBudoSport } from "./budo/plan.js";
+import { isBudoSport, isMatSport } from "./budo/plan.js";
 import { courtUprights, rinkUprights } from "./uprights.rinks.js";
 import { convertLength } from "./units.js";
 import { sheetFor } from "./sheet.js";
@@ -32,7 +32,7 @@ import { NO_VENUE, standsVenue } from "./venue.js";
 /** All the planes of all the things. */
 export const planesOf = (u) => u.items.flatMap((item) => item.planes);
 /** The unit each sport's rulebook gives its heights in, when the options name none. */
-const RULEBOOK_UNIT = { volleyball: "m", badminton: "m", tabletennis: "m", padel: "m", squash: "m", athletics: "m", skating: "m", judo: "m", karate: "m", kendo: "m", sumo: "m", kyudo: "m", dojo: "m", swimming: "m", waterpolo: "m", diving: "m", artisticswimming: "m", sepaktakraw: "m", teqball: "m", roundnet: "m", netball: "m", soccer: "m", handball: "m", fieldhockey: "m", rugby: "m", afl: "m", gaelic: "m" };
+const RULEBOOK_UNIT = { volleyball: "m", badminton: "m", tabletennis: "m", padel: "m", squash: "m", athletics: "m", skating: "m", judo: "m", karate: "m", kendo: "m", sumo: "m", kyudo: "m", dojo: "m", mma: "ft", swimming: "m", waterpolo: "m", diving: "m", artisticswimming: "m", sepaktakraw: "m", teqball: "m", roundnet: "m", netball: "m", soccer: "m", handball: "m", fieldhockey: "m", rugby: "m", afl: "m", gaelic: "m" };
 /** What stands on the surface the options draw: nothing on a curling sheet, which is flat. */
 export function uprightsFor(o, settings = {}) {
     const { sport, league } = chooseLeague(o);
@@ -107,7 +107,7 @@ export function uprightsFor(o, settings = {}) {
         thin = thinnest(area.x1, area.y1);
         items = skatingUprights({ ...o, sport }, thin).items;
     }
-    else if (isBudoSport(sport)) {
+    else if (isMatSport(sport)) {
         const built = budoUprights({ ...o, sport }, 0.3);
         area = built.area;
         thin = thinnest(area.x1, area.y1);

package/dist/uprights.ring.d.ts

@@ -0,0 +1,12 @@
+import type { BudoPlan } from "./budo/plan.ts";
+import type { RingLayout } from "./budo/ring.ts";
+import { type Plane, type Upright } from "./turn.kit.ts";
+/** The platform of a ring as a solid block: its four sides and its top, which is the drawing's own canvas in the platform's rectangle. */
+export declare function platformPlanes(b: {
+    x0: number;
+    y0: number;
+    x1: number;
+    y1: number;
+}, at: (x: number, y: number) => readonly [number, number], h: number): Plane[];
+/** What stands on a ring: the platform, its steps, the posts, the ropes and their ties. */
+export declare function ringUprights(plan: BudoPlan, L: RingLayout, at: (x: number, y: number) => readonly [number, number]): Upright[];

package/dist/uprights.ring.js

@@ -0,0 +1,76 @@
+import { box, flat, n, pole, bar, wall } from "./turn.kit.js";
+const K = 1 / 0.3048;
+/** The platform of a ring as a solid block: its four sides and its top, which is the drawing's own canvas in the platform's rectangle. */
+export function platformPlanes(b, at, h) {
+    const corners = [at(b.x0, b.y0), at(b.x1, b.y0), at(b.x1, b.y1), at(b.x0, b.y1)];
+    const planes = [];
+    corners.forEach((a, i) => {
+        const c = corners[(i + 1) % 4];
+        planes.push(wall(`deck-${i + 1}`, "wall", a[0], a[1], c[0], c[1], 0, h, `<rect width="${n(Math.hypot(c[0] - a[0], c[1] - a[1]))}" height="${n(h)}" class="u-deck-side"/>`));
+    });
+    planes.push({ ...flat("deck-top", "platform", corners[0][0], corners[0][1], corners[2][0], corners[2][1], h, ""), crop: true });
+    return planes;
+}
+/** What stands on a ring: the platform, its steps, the posts, the ropes and their ties. */
+export function ringUprights(plan, L, at) {
+    const fig = plan.figures;
+    const h0 = L.height * K;
+    const centre = at(L.centre[0], L.centre[1]);
+    const items = [{ id: "deck", kind: "deck", at: centre, height: h0, planes: platformPlanes(L.platform, at, h0) }];
+    if (L.steps.length > 0) {
+        const s = fig.platform.steps;
+        const planes = [];
+        for (const st of L.steps) {
+            const north = st.edge === "north";
+            for (let t = 0; t < s.treads; t += 1) {
+                const y0 = north ? st.box.y0 + t * s.tread : st.box.y0;
+                const y1 = north ? st.box.y1 : st.box.y1 - t * s.tread;
+                const [x0, ya] = at(st.box.x0, y0);
+                const [x1, yb] = at(st.box.x1, y1);
+                planes.push(...box(`step-${st.corner}-${t + 1}`, "platform", { x0, y0: ya, x1, y1: yb }, (h0 * (t + 1)) / s.treads, "u-step"));
+            }
+        }
+        items.push({ id: "steps", kind: "deck", at: centre, height: h0, planes });
+    }
+    // The posts: solid, two crossed strips as wide as the pad, in the corner's colour, from the platform to the height the rules give over the ring floor.
+    const top = h0 + fig.post.height * K;
+    const padW = fig.post.pad * K;
+    const posts = L.corners.flatMap((c) => {
+        const [px, py] = at(c.post[0], c.post[1]);
+        return pole(`post-${c.index + 1}`, "post", px, py, h0, top, padW, `u-corner-${c.colour}`);
+    });
+    // The ropes: along each side between the corners of the rope square, and at each corner out to the post by the extension.
+    const ropeW = Math.max(fig.ropes.diameter.drawn, 0.03) * K;
+    const ropes = [];
+    fig.ropes.heights.forEach((rh, level) => {
+        const z = h0 + rh * K;
+        const sq = L.corners.map((c) => at(c.rope[0], c.rope[1]));
+        for (let i = 0; i < 4; i += 1) {
+            const a = sq[i];
+            const b = sq[(i + 1) % 4];
+            ropes.push(...bar(`rope-${level + 1}-${i + 1}`, "rail", [a[0], a[1], z], [b[0], b[1], z], ropeW, "u-rope"));
+        }
+        L.corners.forEach((c, i) => {
+            const a = at(c.rope[0], c.rope[1]);
+            const p = at(c.post[0], c.post[1]);
+            ropes.push(...bar(`rope-${level + 1}-ext-${i + 1}`, "rail", [a[0], a[1], z], [p[0], p[1], z], ropeW, "u-rope"));
+        });
+    });
+    // Two ties on each side, a strip joining the ropes where they are a third and two thirds along, as the rules ask (spacers).
+    const lo = h0 + fig.ropes.heights[0] * K;
+    const hi = h0 + fig.ropes.heights[fig.ropes.heights.length - 1] * K;
+    const ties = [];
+    const sq = L.corners.map((c) => at(c.rope[0], c.rope[1]));
+    for (let i = 0; i < 4; i += 1) {
+        const a = sq[i];
+        const b = sq[(i + 1) % 4];
+        for (const t of [1 / 3, 2 / 3]) {
+            const x = a[0] + (b[0] - a[0]) * t;
+            const y = a[1] + (b[1] - a[1]) * t;
+            ties.push(...pole(`tie-${i + 1}-${t < 0.5 ? 1 : 2}`, "rail", x, y, lo, hi, 0.1 * K, "u-rope-tie"));
+        }
+    }
+    items.push({ id: "posts", kind: "ring-posts", at: centre, height: top - h0, planes: posts });
+    items.push({ id: "ropes", kind: "ring-ropes", at: centre, height: hi - h0, planes: [...ropes, ...ties] });
+    return items;
+}

package/dist/version.d.ts

@@ -1,2 +1,2 @@
 /** The package's version: the same as package.json's, and a test holds them to each other. */
-export declare const VERSION = "0.19.0";
+export declare const VERSION = "0.21.0";

package/dist/version.js

@@ -1,2 +1,2 @@
 /** The package's version: the same as package.json's, and a test holds them to each other. */
-export const VERSION = "0.19.0";
+export const VERSION = "0.21.0";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@johnmorrisdotca/kyogijo-stadiums",
-  "version": "0.19.0",
-  "description": "Kyogijo Stadiums 競技場, 39 sports' surfaces as SVG, drawn to scale from the rulebooks: NFL, CFL and IFAF football fields, an NHL rink, an NBA court, MLB ballparks, soccer pitches, curling sheets, athletics stadiums, speed skating, short track and figure skating rinks, swimming pools, water polo fields, diving wells, artistic swimming areas, and the courts and fields of tennis, volleyball (indoor, beach and sitting), badminton, pickleball, table tennis, padel, squash, racquetball, sepak takraw, teqball, roundnet, netball, lacrosse, rugby, Australian football, Gaelic games, cricket, field hockey and handball, and the budo of judo, karate, kendo, sumo and kyudo with a dojo of tatami laid as real units, with each team's name and logo on its side and the score in the middle, stands and a crowd, a pageant of flags, and a 3D view. Light and dark, accessible, a compact badge for lists, a helper for React and a custom element. Zero dependencies.",
+  "version": "0.21.0",
+  "description": "Kyogijo Stadiums 競技場, 40 sports' surfaces as SVG, drawn to scale from the rulebooks: NFL, CFL and IFAF football fields, an NHL rink, an NBA court, MLB ballparks, soccer pitches, curling sheets, athletics stadiums, speed skating, short track and figure skating rinks, swimming pools, water polo fields, diving wells, artistic swimming areas, and the courts and fields of tennis, volleyball (indoor, beach and sitting), badminton, pickleball, table tennis, padel, squash, racquetball, sepak takraw, teqball, roundnet, netball, lacrosse, rugby, Australian football, Gaelic games, cricket, field hockey and handball, and the budo of judo, karate, kendo, sumo and kyudo with a dojo of tatami laid as real units, the MMA cage, with each team's name and logo on its side and the score in the middle, stands and a crowd, a pageant of flags, and a 3D view. Light and dark, accessible, a compact badge for lists, a helper for React and a custom element. Zero dependencies.",
   "keywords": [
     "sports",
     "scoreboard",
@@ -50,7 +50,9 @@
     "sumo",
     "kyudo",
     "dojo",
-    "tatami"
+    "tatami",
+    "mma",
+    "cage"
   ],
   "homepage": "https://johnmorrisdotca.github.io/kyogijo-stadiums/",
   "repository": {