@johnmorrisdotca/kyogijo-stadiums 0.60.1 → 0.62.0

package/dist/sound.synth.js

@@ -0,0 +1,303 @@
+/** A seeded generator of numbers from 0 to 1 (mulberry32): the noise is the same every time. */
+export function seeded(seed) {
+    let a = seed >>> 0;
+    return () => {
+        a = (a + 0x6d2b79f5) >>> 0;
+        let t = a;
+        t = Math.imul(t ^ (t >>> 15), t | 1);
+        t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}
+/** Samples of noise of a colour, from a seed, between -1 and 1. */
+export function noiseSamples(length, seed, colour = "white") {
+    const random = seeded(seed);
+    const out = new Float32Array(length);
+    // Paul Kellet's economy filter for pink; a leaky sum for brown.
+    let b0 = 0;
+    let b1 = 0;
+    let b2 = 0;
+    let last = 0;
+    for (let i = 0; i < length; i++) {
+        const white = random() * 2 - 1;
+        if (colour === "pink") {
+            b0 = 0.99765 * b0 + white * 0.099046;
+            b1 = 0.963 * b1 + white * 0.2965164;
+            b2 = 0.57 * b2 + white * 1.0526913;
+            out[i] = (b0 + b1 + b2 + white * 0.1848) * 0.2;
+        }
+        else if (colour === "brown") {
+            last = (last + 0.02 * white) / 1.02;
+            out[i] = last * 3.5;
+        }
+        else
+            out[i] = white;
+    }
+    return out;
+}
+/** Samples of hands clapping: many short bursts of noise at random moments, `density` claps a second, for `length` samples at `rate`. */
+export function applauseSamples(length, rate, seed, density = 220) {
+    const random = seeded(seed);
+    const out = new Float32Array(length);
+    const claps = Math.round((length / rate) * density);
+    const clap = Math.round(rate * 0.012);
+    for (let c = 0; c < claps; c++) {
+        const at = Math.floor(random() * length);
+        const loud = 0.25 + random() * 0.75;
+        for (let i = 0; i < clap; i++) {
+            // A loop: a clap near the end goes on at the start, so the loop has no seam.
+            const j = (at + i) % length;
+            out[j] += (random() * 2 - 1) * loud * Math.exp((-6 * i) / clap);
+        }
+    }
+    let peak = 0;
+    for (const s of out)
+        peak = Math.max(peak, Math.abs(s));
+    if (peak > 0)
+        for (let i = 0; i < length; i++)
+            out[i] /= peak;
+    return out;
+}
+/** Samples of people talking: noise whose level rises and falls with syllables, about four a second from each of many voices, summed. */
+export function murmurSamples(length, rate, seed, voices = 24) {
+    const random = seeded(seed);
+    const noise = noiseSamples(length, seed + 1, "pink");
+    const envelope = new Float32Array(length);
+    for (let v = 0; v < voices; v++) {
+        let at = Math.floor(random() * rate * 0.3);
+        while (at < length) {
+            const syllable = Math.round(rate * (0.12 + random() * 0.16));
+            const loud = 0.3 + random() * 0.7;
+            for (let i = 0; i < syllable; i++)
+                envelope[(at + i) % length] += loud * Math.sin((Math.PI * i) / syllable);
+            at += syllable + Math.round(rate * random() * (random() < 0.15 ? 0.9 : 0.12));
+        }
+    }
+    let peak = 0;
+    for (let i = 0; i < length; i++) {
+        noise[i] *= envelope[i];
+        peak = Math.max(peak, Math.abs(noise[i]));
+    }
+    if (peak > 0)
+        for (let i = 0; i < length; i++)
+            noise[i] /= peak;
+    return noise;
+}
+/** A room's echo as an impulse response: noise falling 60 dB over `decay` seconds, two channels a little apart. */
+export function impulseSamples(decay, rate, seed) {
+    const length = Math.max(1, Math.round(Math.min(4, Math.max(0.2, decay)) * rate));
+    const left = noiseSamples(length, seed, "white");
+    const right = noiseSamples(length, seed + 7, "white");
+    for (let i = 0; i < length; i++) {
+        const fall = Math.exp((-6.9 * i) / length);
+        left[i] *= fall;
+        right[i] *= fall;
+    }
+    return [left, right];
+}
+/** A buffer of the context from samples (one channel, or two). */
+export function bufferOf(context, channels) {
+    const buffer = context.createBuffer(channels.length, channels[0].length, context.sampleRate);
+    channels.forEach((samples, i) => buffer.getChannelData(i).set(samples));
+    return buffer;
+}
+/** How many seconds each made layer loops for: long enough that the loop is not heard. */
+export const LAYER_SECONDS = 6;
+/**
+ * How much each made layer is turned down or up so that, through its filter, it is as loud as the demo's recordings are made (an RMS of -20 dBFS; the pool's water -22, and the building's air
+ * a quiet -30): measured once in a browser by rendering each layer offline.
+ */
+export const LAYER_TRIM = { room: 0.22, water: 0.45, murmur: 1.58, applause: 1.41, roar: 1.12 };
+/** The buffer a layer loops when it has no recording. */
+export function layerBuffer(context, layer) {
+    const rate = context.sampleRate;
+    const length = Math.round(LAYER_SECONDS * rate);
+    const seed = { room: 11, water: 23, murmur: 37, applause: 41, roar: 53 }[layer];
+    const colour = layer === "room" ? "brown" : layer === "water" ? "white" : "pink";
+    const make = (s) => (layer === "murmur" ? murmurSamples(length, rate, s) : layer === "applause" ? applauseSamples(length, rate, s) : noiseSamples(length, s, colour));
+    const channels = [make(seed), make(seed + 100)];
+    for (const samples of channels)
+        for (let i = 0; i < samples.length; i++)
+            samples[i] *= LAYER_TRIM[layer];
+    return bufferOf(context, channels);
+}
+/** The filter that shapes a made layer: the building's low air, water's hiss, talk's middle, a crowd's voice. */
+export function layerFilter(context, layer) {
+    const filter = context.createBiquadFilter();
+    const shape = {
+        room: ["lowpass", 260, 0.7],
+        water: ["bandpass", 2400, 0.6],
+        murmur: ["bandpass", 700, 0.55],
+        applause: ["highpass", 900, 0.7],
+        roar: ["bandpass", 620, 0.9],
+    };
+    const [type, frequency, q] = shape[layer];
+    filter.type = type;
+    filter.frequency.value = frequency;
+    filter.Q.value = q;
+    return filter;
+}
+/** An envelope on a gain: up in `attack`, held, then down in `release`, from `when`. */
+function envelope(gain, when, peak, attack, hold, release) {
+    gain.setValueAtTime(0, when);
+    gain.linearRampToValueAtTime(peak, when + attack);
+    gain.setValueAtTime(peak, when + attack + hold);
+    gain.linearRampToValueAtTime(0, when + attack + hold + release);
+    return when + attack + hold + release;
+}
+/** An oscillator from `when` to `until`, into `into`. */
+function tone(context, into, type, frequency, when, until) {
+    const osc = context.createOscillator();
+    osc.type = type;
+    osc.frequency.value = frequency;
+    osc.connect(into);
+    osc.start(when);
+    osc.stop(until);
+    return osc;
+}
+/** A burst of noise from a buffer, from `when` to `until`, into `into`. */
+function burst(context, into, noise, when, until) {
+    const source = context.createBufferSource();
+    source.buffer = noise;
+    source.loop = true;
+    source.connect(into);
+    source.start(when);
+    source.stop(until);
+    return source;
+}
+/** One blast of a pea whistle: a high tone with a fast trill, and a little breath. */
+function whistleBlast(context, out, noise, when, length) {
+    const amp = context.createGain();
+    amp.connect(out);
+    const until = envelope(amp.gain, when, 0.35, 0.015, length, 0.06);
+    const osc = tone(context, amp, "sine", 2900, when, until);
+    const trill = context.createOscillator();
+    trill.frequency.value = 28;
+    const depth = context.createGain();
+    depth.gain.value = 140;
+    trill.connect(depth);
+    depth.connect(osc.frequency);
+    trill.start(when);
+    trill.stop(until);
+    const breath = context.createBiquadFilter();
+    breath.type = "bandpass";
+    breath.frequency.value = 2900;
+    breath.Q.value = 4;
+    const breathGain = context.createGain();
+    breathGain.gain.value = 0.25;
+    breath.connect(breathGain);
+    breathGain.connect(amp);
+    burst(context, breath, noise, when, until);
+    return until;
+}
+/** One strike of a ring's bell: three partials that ring down. */
+function bellStrike(context, out, when) {
+    const until = when + 1.4;
+    for (const [frequency, loud] of [[830, 0.3], [1490, 0.18], [2210, 0.12]]) {
+        const amp = context.createGain();
+        amp.gain.setValueAtTime(loud, when);
+        amp.gain.exponentialRampToValueAtTime(0.0001, until);
+        amp.connect(out);
+        tone(context, amp, "sine", frequency, when, until);
+    }
+    return until;
+}
+/** A crowd's vowel: noise through a filter that opens from `from` to `to` hertz, swelling and falling away. */
+function vowel(context, out, noise, when, from, to, peak, attack, release) {
+    const filter = context.createBiquadFilter();
+    filter.type = "bandpass";
+    filter.Q.value = 1.2;
+    filter.frequency.setValueAtTime(from, when);
+    filter.frequency.linearRampToValueAtTime(to, when + attack);
+    const amp = context.createGain();
+    filter.connect(amp);
+    amp.connect(out);
+    const until = envelope(amp.gain, when, peak, attack, 0.1, release);
+    burst(context, filter, noise, when, until);
+    return until;
+}
+/**
+ * Make a voice in the browser at `when` on the context's clock, into `out`, from the noise of `noise` (a pink loop). Returns when it ends. The horn is one chord held, never a tune; the
+ * swell is not here, as it moves the bed's roar (the engine does it).
+ */
+export function makeVoice(context, voice, out, buffers, when) {
+    const noise = buffers.noise();
+    switch (voice) {
+        case "whistle":
+            return whistleBlast(context, out, noise, when, 0.45);
+        case "whistle-end": {
+            const second = whistleBlast(context, out, noise, when, 0.22) + 0.12;
+            const third = whistleBlast(context, out, noise, second, 0.22) + 0.12;
+            return whistleBlast(context, out, noise, third, 1.3);
+        }
+        case "horn": {
+            const filter = context.createBiquadFilter();
+            filter.type = "lowpass";
+            filter.frequency.value = 1100;
+            filter.Q.value = 1;
+            const amp = context.createGain();
+            filter.connect(amp);
+            amp.connect(out);
+            const until = envelope(amp.gain, when, 0.22, 0.06, 2.6, 0.6);
+            for (const frequency of [98, 98.6, 123.5, 146.8])
+                tone(context, filter, "sawtooth", frequency, when, until);
+            return until;
+        }
+        case "buzzer": {
+            const filter = context.createBiquadFilter();
+            filter.type = "lowpass";
+            filter.frequency.value = 2200;
+            const amp = context.createGain();
+            filter.connect(amp);
+            amp.connect(out);
+            const until = envelope(amp.gain, when, 0.16, 0.01, 1.3, 0.04);
+            tone(context, filter, "square", 196, when, until);
+            tone(context, filter, "sawtooth", 392, when, until);
+            return until;
+        }
+        case "bell":
+            return [0, 0.3, 0.6].reduce((end, at) => Math.max(end, bellStrike(context, out, when + at)), when);
+        case "gun": {
+            const filter = context.createBiquadFilter();
+            filter.type = "highpass";
+            filter.frequency.value = 700;
+            const amp = context.createGain();
+            filter.connect(amp);
+            amp.connect(out);
+            amp.gain.setValueAtTime(0.9, when);
+            amp.gain.exponentialRampToValueAtTime(0.0001, when + 0.35);
+            burst(context, filter, noise, when, when + 0.35);
+            const thump = context.createGain();
+            thump.gain.setValueAtTime(0.6, when);
+            thump.gain.exponentialRampToValueAtTime(0.0001, when + 0.25);
+            thump.connect(out);
+            tone(context, thump, "sine", 85, when, when + 0.25);
+            return when + 0.35;
+        }
+        case "beep": {
+            const amp = context.createGain();
+            amp.connect(out);
+            const until = envelope(amp.gain, when, 0.18, 0.005, 0.45, 0.02);
+            tone(context, amp, "square", 1000, when, until);
+            return until;
+        }
+        case "ooh":
+            return vowel(context, out, noise, when, 360, 640, 1.2, 0.35, 1.5);
+        case "cheer":
+            return vowel(context, out, noise, when, 700, 1100, 1, 0.08, 1.2);
+        case "applause": {
+            const amp = context.createGain();
+            amp.connect(out);
+            const until = envelope(amp.gain, when, 0.6, 0.25, 1.8, 1.6);
+            const source = context.createBufferSource();
+            source.buffer = buffers.applause();
+            source.loop = true;
+            const filter = layerFilter(context, "applause");
+            source.connect(filter);
+            filter.connect(amp);
+            source.start(when);
+            source.stop(until);
+            return until;
+        }
+    }
+}

package/dist/sound.words.d.ts

@@ -0,0 +1,16 @@
+import type { SoundBedId, SoundLevel } from "./sound.sets.ts";
+/** The words of the sound in a language. */
+export interface SoundWords {
+    /** The sound's toggle and its tip. */
+    sound: string;
+    soundTip: string;
+    volume: string;
+    /** The group of the crowd's levels. */
+    crowdLevel: string;
+    /** The level that follows the game. */
+    auto: string;
+    levels: Readonly<Record<SoundLevel, string>>;
+    beds: Readonly<Record<SoundBedId, string>>;
+}
+/** The sound's words, by language. */
+export declare const SOUND_WORDS: Readonly<Record<"en" | "ja", SoundWords>>;

package/dist/sound.words.js

@@ -0,0 +1,21 @@
+/** The sound's words, by language. */
+export const SOUND_WORDS = {
+    en: {
+        sound: "Sound",
+        soundTip: "The crowd and the game's sounds, made in your browser. Off until you turn it on.",
+        volume: "Volume",
+        crowdLevel: "Crowd",
+        auto: "Follow the game",
+        levels: { quiet: "Quiet", murmur: "Murmur", engaged: "Engaged", loud: "Loud", roar: "Roar" },
+        beds: { arena: "Arena", stadium: "Open stadium", ballpark: "Ballpark", hall: "Court hall", pool: "Pool", dojo: "Dojo", ring: "Ring", track: "Track" },
+    },
+    ja: {
+        sound: "サウンド",
+        soundTip: "観客と試合の音をブラウザーの中で作ります。オンにするまで鳴りません。",
+        volume: "音量",
+        crowdLevel: "観客",
+        auto: "試合に合わせる",
+        levels: { quiet: "静か", murmur: "ざわめき", engaged: "盛り上がり", loud: "歓声", roar: "大歓声" },
+        beds: { arena: "アリーナ", stadium: "屋外スタジアム", ballpark: "野球場", hall: "体育館", pool: "プール", dojo: "道場", ring: "リング", track: "陸上競技場" },
+    },
+};

package/dist/strings.core.d.ts

@@ -978,6 +978,7 @@ export interface KyogijoWords {
         shot: string;
         goal: string;
         whistle: string;
+        faceoff: string;
         /** What is said when an event goes by: {what}, {team} and {time}. */
         announce: string;
         announceTeam: string;

package/dist/strings.en.js

@@ -439,7 +439,7 @@ export const WORDS_EN = {
     grid: { title: "A grid of drawings ({n})", drawings: "Drawings ({n}): {list}.", key: "Key: {list}.", cell: "Drawing {n} of {total}", listSep: "; " },
     replay: {
         title: "Replay, {time}", objects: "{n} tracked objects", objectsOne: "{n} tracked object", events: "{n} events", eventsOne: "{n} event", players: "Players", others: "Ball, puck and officials", trail: "Trail of the last {s} seconds", numbers: "Shirt numbers", eventLines: "Passes and shots",
-        home: "home", away: "away", ball: "ball", puck: "puck", official: "official", pass: "Pass", shot: "Shot", goal: "Goal", whistle: "Whistle",
+        home: "home", away: "away", ball: "ball", puck: "puck", official: "official", pass: "Pass", shot: "Shot", goal: "Goal", whistle: "Whistle", faceoff: "Face-off",
         announce: "{what}, {time}", announceTeam: "{what}, {team}, {time}",
         group: "Replay controls", play: "Play", pause: "Pause", back: "Previous frame", forward: "Next frame", stepBack: "Back", stepForward: "Forward", speed: "Speed", loop: "Loop", position: "Position", time: "Time", event: "Event", spokenSeconds: "0:{ss}", spokenMinutes: "{m}:{ss}", spokenHours: "{h}:{mm}:{ss}", positionValue: "{t} of {total}",
         keys: "Replay of the play. Space plays or pauses, the left and right arrow keys step by a frame, Shift with an arrow key moves 5 seconds, and Home and End go to the ends.",

package/dist/strings.ja.js

@@ -464,7 +464,7 @@ export const WORDS_JA = {
     grid: { title: "図のグリッド（{n}枚）", drawings: "図（{n}枚）：{list}。", key: "凡例：{list}。", cell: "{total}枚中{n}枚目の図", listSep: "；" },
     replay: {
         title: "リプレイ（再生時間{time}）", objects: "追跡対象は{n}個", objectsOne: "追跡対象は{n}個", events: "イベント{n}件", eventsOne: "イベント{n}件", players: "選手", others: "ボール・パック・審判", trail: "直近{s}秒の軌跡", numbers: "背番号", eventLines: "パスとシュート",
-        home: "ホーム", away: "アウェイ", ball: "ボール", puck: "パック", official: "審判", pass: "パス", shot: "シュート", goal: "ゴール", whistle: "ホイッスル",
+        home: "ホーム", away: "アウェイ", ball: "ボール", puck: "パック", official: "審判", pass: "パス", shot: "シュート", goal: "ゴール", whistle: "ホイッスル", faceoff: "フェイスオフ",
         announce: "{what}、{time}", announceTeam: "{team}の{what}、{time}",
         group: "リプレイの操作", play: "再生", pause: "一時停止", back: "前のコマ", forward: "次のコマ", stepBack: "前へ", stepForward: "次へ", speed: "再生速度", loop: "繰り返し", position: "再生位置", time: "時間", event: "イベント", spokenSeconds: "{s}秒", spokenMinutes: "{m}分{s}秒", spokenHours: "{h}時間{m}分{s}秒", positionValue: "{total}中{t}",
         keys: "プレーのリプレイです。スペースキーで再生と一時停止、左右の矢印キーで1コマずつ前後に移動、Shiftキーを押しながら矢印キーで5秒ずつ移動、Homeキーで最初、Endキーで最後に移動します。",

package/dist/turn.replay.board.d.ts

@@ -7,7 +7,7 @@ import { type HungBoard } from "./venue.boards.ts";
 export declare const hungBoards: (model: Pick<TurnModel, "uprights">) => HungBoard[];
 /** The planes of a hung scoreboard with the replay's board on it: the same planes (the same ids, in the same places), the faces drawn with the score, the period and the clock. */
 export declare function hungBoardPlanes(hung: HungBoard, state: ReplayBoardState): Plane[];
-/** What is written on a board, as one string: it changes when, and only when, the score, the period or the clock does. */
+/** What is written on a board, as one string: it changes when, and only when, the score, the period, the clock or a penalty's clock does. */
 export declare const boardKey: (state: ReplayBoardState) => string;
 /** The longest the game clock goes without a write while the replay plays, in milliseconds. */
 export declare const CLOCK_EVERY = 1000;

package/dist/turn.replay.board.js

@@ -7,11 +7,20 @@ export const hungBoards = (model) => model.uprights.items.flatMap((item) => (ite
 /** The planes of a hung scoreboard with the replay's board on it: the same planes (the same ids, in the same places), the faces drawn with the score, the period and the clock. */
 export function hungBoardPlanes(hung, state) {
     const clock = safeClock(state.clock);
-    const live = clock === "" ? undefined : { clock, ...(state.period === undefined ? {} : { period: state.period }) };
+    const live = clock === "" ? undefined : { clock, ...(state.period === undefined ? {} : { period: state.period }), ...powerPlay(state) };
     return centreBoard(hung.id, hung.box, hung.lift, { ...hung.look, score: state.score, ...(live === undefined ? {} : { live }) });
 }
-/** What is written on a board, as one string: it changes when, and only when, the score, the period or the clock does. */
-export const boardKey = (state) => `${state.score[0]}-${state.score[1]} ${state.period ?? ""} ${state.clock}`;
+/** A power play on the board: the clocks of each side's penalties that make it play short, and which side has more skaters. Nothing when no side plays short. */
+function powerPlay(state) {
+    const short = (state.penalties ?? []).filter((p) => p.short);
+    if (short.length === 0 || state.strength === undefined)
+        return {};
+    const [home, away] = state.strength;
+    const pp = home > away ? "home" : away > home ? "away" : undefined;
+    return { penalties: { home: short.filter((p) => p.team === "home").map((p) => p.left), away: short.filter((p) => p.team === "away").map((p) => p.left), ...(pp === undefined ? {} : { pp }) } };
+}
+/** What is written on a board, as one string: it changes when, and only when, the score, the period, the clock or a penalty's clock does. */
+export const boardKey = (state) => `${state.score[0]}-${state.score[1]} ${state.period ?? ""} ${state.clock}${state.strength === undefined ? "" : ` ${state.strength.join("-")} ${(state.penalties ?? []).map((p) => `${p.team}${p.left}${p.short ? "" : "x"}`).join(",")}`}`;
 /** The longest the game clock goes without a write while the replay plays, in milliseconds. */
 export const CLOCK_EVERY = 1000;
 const FACE = /-(south|north|east|west)$/;
@@ -29,6 +38,14 @@ export function boardFollower(timeline, now) {
             one.face.dataset.score = `${s.score[0]}-${s.score[1]}`;
             one.face.dataset.period = s.period === undefined ? "" : String(s.period);
             one.face.dataset.clock = s.clock;
+            if (s.strength === undefined) {
+                delete one.face.dataset.strength;
+                delete one.face.dataset.penalties;
+            }
+            else {
+                one.face.dataset.strength = s.strength.join("-");
+                one.face.dataset.penalties = (s.penalties ?? []).map((p) => `${p.team} ${p.left}`).join(", ");
+            }
         }
     };
     return {

package/dist/venue.boards.d.ts

@@ -20,6 +20,12 @@ export interface BoardLive {
     period?: number;
     /** The clock as it is written, `19:20`: digits and one colon. */
     clock: string;
+    /** A power play: each side's penalty clocks (`1:42`, the soonest first, two at most are drawn) in its block of colour, and `PP` in the block of the side with more skaters. */
+    penalties?: {
+        home: string[];
+        away: string[];
+        pp?: "home" | "away";
+    };
 }
 /** The scoreboard hung over a surface, with what it is made from: a replay draws its faces again with the score and the clock of the time it is at. */
 export interface HungBoard {

package/dist/venue.boards.js

@@ -136,6 +136,8 @@ export function boardSize(w, h) {
 export const hangsOver = (sport) => sport !== "mlb";
 /** The segments of a seven-segment digit, a to g, that are lit for each digit. */
 const SEGMENTS = ["abcdef", "bc", "abged", "abgcd", "fgbc", "afgcd", "afgedc", "abc", "abcdefg", "abcdfg"];
+/** The letters a seven-segment board writes for a power play. */
+const LETTERS = { P: "abefg" };
 /** How wide a colon is, as a share of the height of the digits beside it. */
 const COLON = 0.3;
 /** A text of digits and colons in seven segments, `high` feet tall, from (x, y) at its top left: the path and the width it takes. */
@@ -165,7 +167,7 @@ function segments(text, x, y, high) {
             at += cw;
             return;
         }
-        for (const seg of SEGMENTS[Number(ch)] ?? "") {
+        for (const seg of LETTERS[ch] ?? SEGMENTS[Number(ch)] ?? "") {
             const [rx, ry, rw, rh] = rects[seg];
             d += `M${n(at + rx)} ${n(y + ry)}h${n(rw)}v${n(rh)}h${n(-rw)}z`;
         }
@@ -220,6 +222,23 @@ function boardFace(w, h, look) {
     svg += `<path class="u-led" fill="${c2}" d="${h0.d}${a0.d}M${n(x0 + home.width + gap)} ${n(y0 + high / 2 - high * 0.065)}h${n(high * dash)}v${n(high * 0.13)}h${n(-high * dash)}z"/>`;
     if (live !== undefined)
         svg += liveRow(w, h, room, live, c2);
+    // A power play: in each side's block of colour, its penalty clocks (one or two, stacked), or PP for the side with more skaters, dark on the colour.
+    if (live?.penalties !== undefined) {
+        const pen = live.penalties;
+        for (const [side, x] of [["home", edge * 2], ["away", w - edge * 2 - block]]) {
+            const lines = (pen.pp === side ? ["PP"] : pen[side].filter((one) => safeClock(one) !== "").slice(0, 2));
+            if (lines.length === 0)
+                continue;
+            const rows = lines.length;
+            const high2 = Math.min((hb * 0.8) / rows / 1.15, block / ((lines[0].length - (lines[0].includes(":") ? 1 : 0)) * 0.69 + 0.4));
+            let d = "";
+            lines.forEach((text, i) => {
+                const width = segments(text, 0, 0, high2).width;
+                d += segments(text, x + (block - width) / 2, yb + (hb - rows * high2 * 1.15) / 2 + i * high2 * 1.15, high2).d;
+            });
+            svg += `<path class="u-led-bed" d="${d}"/>`;
+        }
+    }
     return svg;
 }
 /**

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.60.1";
+export declare const VERSION = "0.62.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.60.1";
+export const VERSION = "0.62.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@johnmorrisdotca/kyogijo-stadiums",
-  "version": "0.60.1",
+  "version": "0.62.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",
@@ -239,6 +239,11 @@
       "import": "./dist/replay-entry.js",
       "default": "./dist/replay-entry.js"
     },
+    "./sound": {
+      "types": "./dist/sound-entry.d.ts",
+      "import": "./dist/sound-entry.js",
+      "default": "./dist/sound-entry.js"
+    },
     "./scene": {
       "types": "./dist/scene-entry.d.ts",
       "import": "./dist/scene-entry.js",
@@ -371,6 +376,8 @@
     "cityctx:fetch": "node scripts/fetch-cityctx.mjs",
     "cityctx:vox": "python3.13 -I scripts/cityctx_vox.py",
     "walk:fetch": "node scripts/fetch-walk.mjs",
+    "sounds": "node scripts/make-sounds.mjs",
+    "sounds:fetch": "node scripts/fetch-sounds.mjs",
     "outside:cost": "node scripts/outside-cost.mjs",
     "plateau": "node scripts/build-plateau.mjs",
     "plateau:fetch": "node scripts/fetch-plateau.mjs",