asterism-games 0.20.0 → 0.21.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0a35db1346246e5d20505026e701fef357536cc75fa53f22bf47878398fb01c3
-  data.tar.gz: 79c4c46763e2104c3e4d03ba521327e9ceb5fa77fc74521cec6041eb3ca48b89
+  metadata.gz: e2b83742bc350a97c81593529368c69fd2143887ac42293d62c9459c28c47b91
+  data.tar.gz: d608f964a2f5356ebe84485ed7042558f66c150e530b34aa787a113a431f64fb
 SHA512:
-  metadata.gz: 2b31fdedf12d610dca0c8cbd4f1ae060b5b42eeab54dee46d62f0ced96d8895468b48e84db2eae2904489448329a19ef5888cf9cb2a514684c2610d4e0937d87
-  data.tar.gz: 9908df82204210223cecd09b651da9d12e3a27ee832433d0e57b74d4d895a7a9753c83c20b75cadfeff88ef94eb91f6564290be193b1e501a37ce209124b67d3
+  metadata.gz: d50462655686680b282f50e3e68ceccbc0f761c9b9515013877f4e06e8c6828233ff5795c14c9c008e7bb5fa5b663ff39aea08d2dc96741616fee5f5bc6ca7e6
+  data.tar.gz: fbb3bbeee07f77a11c01e7d685b8a7f0a239b0ef17f8f8782b0f8e4adbf466fade43708eb6b5e1daa1389c8de93abccf5f39e2afee5e2a20c338ab411ce14aaa

data/CHANGELOG.md

@@ -3,6 +3,35 @@
 Versions before 0.11.1 are noted in the README where each feature is
 described ("games 0.10.0" and the like).
 
+## 0.21.0
+
+- **The commentary's sound** (README "The sound"): the page of
+  `commentate mahjong` plays Family mruby's mahjong app's BGM and effects,
+  the same sounds at the same moments as the app. The BGM follows the
+  app's scenes (the lobby, the game, the tense part, none at the end),
+  starts low (the app's levels: off, low, mid, high, **B** or the bar's
+  button) and goes down to half while the voice speaks. The effects (a
+  round's start, the jingles of the calls, riichi and the wins, the
+  winner's points, the draws, a discard, the fanfare at the end; as for
+  the app's spectator, no draw or turn sound) play beside the voice, sharing the APU's channels as in the
+  app; **E** turns them off and on; the page remembers both. Which sound
+  when is a pure function of two views (`commentate/mahjong_sounds.rb`);
+  each `state` event now carries `bgm` and `sounds`.
+- The files are in the gem (`commentate/assets/sounds/`, 3.6 MB: WAVs for
+  the effects, MP3s for the three tunes, `sounds.json`), made with Family
+  mruby's own APU emulator by fmruby-core's `tools/mahjong_sounds.rb`.
+  The effects are MIT here; the BGM is shiru8bit's under CC BY 3.0,
+  unchanged (`SOUNDS_LICENSE.txt`), credited in the page's corner. The
+  web server serves `/sounds/` (those files only) and
+  `/SOUNDS_LICENSE.txt`.
+
+## 0.20.1
+
+- `play mahjong`: an owner's command queued with `--commands` (`watch`,
+  `start`, `cpu` ...) while someone else holds the owner's role now says
+  so (「卓の主ではありません。卓の主の役が回ってくるのを待っています」)
+  instead of asking for a seat: since 0.20.0 an owner may be unseated.
+
 ## 0.20.0
 
 - **Watch games** (README "Watch games"): the owner of a mahjong table

data/README.md

@@ -92,7 +92,7 @@ nothing else (othello, the drawing board), `bin/asterism-games` (with
 `play`, the terminal clients of othello and mahjong: a mahjong table needs
 riichi_engine, its client does not; and `commentate`, a mahjong table watched
 in the browser with commentary, with the tile sheets of Family mruby's
-mahjong app). It depends on
+mahjong app and its sound: the effects and the BGM, "The sound"). It depends on
 the asterism gem only (0.7.1 or later in
 0.x; what came after 0.7.1, such as `@status` and `on_app_join`, is used
 when there). Not in it: mahjong (`app/`, it needs the riichi_engine fork
@@ -1568,7 +1568,8 @@ when it is taken), prints the address and opens it in the browser (macOS
   each, the newest at the bottom. Two seats to a row in a wide window, one
   in a narrow one (a phone). Keys: **Space** pauses (what comes meanwhile
   is held and shown when it goes on), **M** turns the voice off and on,
-  **H** hides the hands on that page (backs instead of the tiles, and the
+  **B** steps the BGM (off, low, mid, high), **E** turns the effects off
+  and on, **H** hides the hands on that page (backs instead of the tiles, and the
   lines that tell a hand left out). A table that several hosts put is
   chosen in the bar.
 - **The AI's one-liners.** Claude's short lines at the big moments,
@@ -1583,6 +1584,9 @@ when it is taken), prints the address and opens it in the browser (macOS
   Japanese voice when it has one (the bar says which voice, or that it has
   none). Browsers play sound only after the page has been clicked once:
   the page says so until then. "The voice" below.
+- **The sound.** The BGM and the effects of Family mruby's mahjong app,
+  at the moments the app plays them, the BGM low by default and lower
+  while the voice speaks. "The sound" below.
 - **The commentary.** Made by rules from the difference between one view
   and the one before (pure functions, `commentate/mahjong_events.rb` and
   `mahjong_phrases.rb`, so the host can take them over later), each event
@@ -1601,9 +1605,10 @@ when it is taken), prints the address and opens it in the browser (macOS
   game goes on as before. The delay of the table is the host's
   ("Spectators"); the page shows it and adds none.
 - **The web server.** HTTP by hand on the standard library's `socket`
-  (no gem): the page, its script and style, the two tile sheets and
-  `/events`, a stream of Server-Sent Events (`status`, `state`, `line`)
-  that pushes the table and the commentary. It listens on `127.0.0.1`
+  (no gem): the page, its script and style, the two tile sheets, the
+  sounds (`/sounds/`, the files of `assets/sounds/` only) and `/events`,
+  a stream of Server-Sent Events (`status`, `state`, `line`) that pushes
+  the table and the commentary. It listens on `127.0.0.1`
   only, answers GET (and HEAD) on those paths only, and refuses a request
   whose Host is not `127.0.0.1` or `localhost`. The page loads nothing from
   elsewhere.
@@ -1714,8 +1719,61 @@ your character before you publish anything; they can change):
   description too** (the page shows it in its corner).
 - Whoever you give generated voices to must follow the same terms, so
   they cannot be mixed into an MIT package. That is why this gem ships no
-  sound: each user makes the files with their own VOICEVOX, and they stay
-  on that machine.
+  voice: each user makes the files with their own VOICEVOX, and they stay
+  on that machine. (The sounds it does ship are the mahjong app's effects
+  and BGM, "The sound".)
+
+### The sound
+
+(games 0.21.0) The page plays the sound of Family mruby's mahjong app:
+its BGM for the scene and its effects and jingles for what happens, the
+same sounds at the same moments as the app. They are files in the gem
+(`lib/asterism_games/commentate/assets/sounds/`), made beforehand with
+Family mruby's own APU emulator from the app's notes and its NSF tunes
+(not played again by ear), and the page plays them with Web Audio after
+the first click (the browser's autoplay rule).
+
+- **The BGM** follows the app's scenes: the lobby (a table waiting, or no
+  table yet) "After The Rain", the game and its results "Spring Thing",
+  the tense part (a riichi on the table, or 10 tiles or fewer left)
+  "Encounter", nothing at the end of a game (the fanfare plays alone). A
+  tune starts from its beginning and repeats its loop without a seam.
+  **B** (or the bar's button) steps it off, low, mid, high: the app's
+  levels (low is 30 % of the tune's full level, mid 55 %, high 100 %, the
+  effects always at theirs), **low by default**.
+- **Ducking.** While the voice speaks (VOICEVOX or the browser's), the BGM
+  goes down to half its level, and back up a moment after the voice stops
+  (not between two lines). The effects are not lowered.
+- **The effects** come with each new view of the table, beside the voice
+  (never waiting in its queue): a round's start, the jingles of a call
+  (チー, ポン, カン), of a riichi, of a win (ロン, ツモ) followed by the
+  winner's points, a draw of the round and the abortive draws, a discard
+  (the app's sound for another player's discard, whoever made it), and
+  the fanfare at the end of the game (the app's spectator's: the
+  winner's). As for the app's spectator, a move sounds its discard only:
+  the player's own sounds (a draw, the turn coming) are not played. They
+  share the APU's four channels as in the app: a sound of a higher
+  priority still sounding keeps its channels, otherwise the newest wins.
+  A voice that would start on top of a jingle waits for most of it (at
+  most 0.6 s). **E** turns the effects off and on. The page remembers
+  both switches (the browser's local storage).
+- **Which sound, when** is a pure function of two views
+  (`commentate/mahjong_sounds.rb`), and each `state` event carries the
+  BGM's scene (`bgm`) and the effects (`sounds`, `[name, delay ms]`).
+- **The files.** The effects are WAVs (mono, 16-bit, the APU's 15720 Hz,
+  under 40 KB each); the three tunes are MP3s (24 kHz mono, 64 kbit/s,
+  about 1 MB each: the tune from its start through one pass of its loop,
+  115 to 154 s). `sounds.json` lists each with its SHA-256, the loop
+  points, the app's levels and scenes. They are made by fmruby-core's
+  `tools/mahjong_sounds.rb` (`ruby tools/mahjong_sounds.rb <dir>`;
+  `--check <dir>` makes them again elsewhere and says whether any differs).
+- **Their licenses** (`assets/SOUNDS_LICENSE.txt`): the effects are the
+  app's author's and are under the MIT License in this gem, by his
+  decision (fmruby-core keeps them under GPL-3.0). **The BGM is not MIT**:
+  the tunes are by shiru8bit under CC BY 3.0, unchanged (only played from
+  their NSF files and saved as MP3). The page shows
+  「BGM: shiru8bit (CC BY 3.0)」 in its corner while the BGM is on, beside
+  the voice's credit; put it in a stream's description too.
 
 ### The AI's one-liners
 

data/VERSION

@@ -1 +1 @@
-0.20.0
+0.21.0

data/lib/asterism_games/commentate/assets/SOUNDS_LICENSE.txt

@@ -0,0 +1,63 @@
+The sounds in sounds/
+
+These are the sound of Family mruby's mahjong app (fmruby-core,
+flash/app/game/mahjong/mahjong_sound.rb), which the commentary page plays:
+the effects and jingles, and the BGM of its scenes. They were not played
+again by ear: fmruby-core's tools/mahjong_sounds.rb plays the app's notes
+and tunes with Family mruby's own APU emulator (components/apu_emu) and
+writes the files; sounds/sounds.json lists each file with its SHA-256 and
+what it was made from.
+
+1. The effects and jingles (sounds/*.wav)
+
+   discard, discard_other, draw, turn, round, yaku, points, riichi, pon,
+   chi, kan, ron, tsumo, kyuushu, ryuukyoku, fanfare1, fanfare2, fanfare3,
+   fanfare4
+
+   Written by Katsuhiko Kageyama, the author of Family mruby and of this
+   gem, as notes for the APU. In this gem they are under the MIT License,
+   the license of the gem (LICENSE), by the author's decision. In
+   fmruby-core they stay under that repository's license (GPL-3.0).
+
+   MIT License
+
+   Copyright (c) 2026 Katsuhiko Kageyama
+
+   Permission is hereby granted, free of charge, to any person obtaining a copy
+   of this software and associated documentation files (the "Software"), to deal
+   in the Software without restriction, including without limitation the rights
+   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+   copies of the Software, and to permit persons to whom the Software is
+   furnished to do so, subject to the following conditions:
+
+   The above copyright notice and this permission notice shall be included in all
+   copies or substantial portions of the Software.
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+   SOFTWARE.
+
+2. The BGM (sounds/*.mp3): music by shiru8bit, CC BY 3.0
+
+   NOT under the MIT License. These three tunes are by shiru8bit and are
+   licensed under the Creative Commons Attribution 3.0 Unported license
+   (CC BY 3.0, https://creativecommons.org/licenses/by/3.0/), as the NSF
+   files Family mruby ships (fmruby-core, flash/usr/share/sounds/nsf/).
+
+     after_the_rain.mp3  "8-bit Chiptune - After The Rain" by shiru8bit
+                         https://opengameart.org/content/8-bit-chiptune-after-the-rain
+     spring_thing.mp3    "8-bit Chiptune - Spring Thing" by shiru8bit
+                         https://opengameart.org/content/8-bit-chiptune-spring-thing
+     encounter.mp3       "8-bit Chiptune - Encounter" by shiru8bit
+                         https://opengameart.org/node/100497
+
+   The music is not changed. Each file is the original NSF played by
+   Family mruby's APU emulator and saved as MP3: from the start of the tune
+   through one pass of its loop (and a second more); the page repeats the
+   loop as the NSF does. Whoever passes these files on, or plays them in a
+   stream or a recording, gives the same credit, for example
+   "BGM: shiru8bit (CC BY 3.0)" (the page shows it in its corner).

data/lib/asterism_games/commentate/assets/commentate.css

@@ -80,19 +80,24 @@ body.obs #captions { max-height: none; background: rgba(0, 0, 0, 0.55); }
 .cap.ai span { color: var(--ai); font-style: italic; }
 .cap.ai.old span { color: var(--dim); }
 #keys { padding: 0 12px 8px; color: var(--dim); font-size: 12px; }
-/* The voice's credit (VOICEVOX:<character>), in the corner, on a stream too. */
-#credit {
+/* The credits (VOICEVOX:<character>, the BGM's), in the corner, on a stream too. */
+#credits {
   position: fixed;
   right: 8px;
   bottom: 6px;
+  display: flex;
+  gap: 6px;
+  pointer-events: none;
+}
+#credits span {
   padding: 1px 6px;
   font-size: 12px;
   color: var(--dim);
   background: rgba(0, 0, 0, 0.45);
   border-radius: 3px;
-  pointer-events: none;
 }
-#credit[hidden] { display: none; }
+#credits span[hidden] { display: none; }
+#bar .btn { cursor: pointer; user-select: none; }
 @media (max-width: 600px) {
   #captions { font-size: 16px; }
   .cap.p3 span { font-size: 18px; }

data/lib/asterism_games/commentate/assets/commentate.js

@@ -8,8 +8,14 @@
 // the browser's speech synthesis.
 // The AI's one-liners (l.ai) come after the fixed lines, marked "AI" in
 // the captions, and are the first to go when the voice falls behind.
-// Keys: Space pause, M voice, H hide the hands. URL parameters: table=<id>,
-// hands=0 (hidden), voice=0, obs=1 (no bar, a transparent background).
+// The sound of Family mruby's mahjong app (README "The sound"): its BGM
+// for the scene ("state"'s bgm) and its effects for each step ("state"'s
+// sounds), files made with the app's own APU (/sounds/, sounds.json),
+// played with Web Audio beside the voice; the BGM goes down while the
+// voice speaks.
+// Keys: Space pause, M voice, B BGM (off, low, mid, high), E effects,
+// H hide the hands. URL parameters: table=<id>, hands=0 (hidden), voice=0,
+// obs=1 (no bar, a transparent background).
 "use strict";
 
 (function () {
@@ -29,7 +35,7 @@
     voiceOn: params.get("voice") !== "0",
     unlocked: false,      // the page was clicked: the browser lets it speak
     paused: false,
-    held: { view: null, lines: [] },
+    held: { view: null, lines: [], bgm: null },
     connected: false,
     sheets: null,
   };
@@ -399,7 +405,7 @@
     const e = { t: Date.now(), kind: kind, id: item ? item.line.id : null, prio: item ? item.prio : null, src: src };
     played.push(e);
     if (played.length > 500) played.shift();
-    if (window.console) console.log("voice", kind, e.id, src);
+    if (window.console) console.log("voice", kind, e.id, src, e.t);
   }
 
   // Queues the line's voice; false when nothing is said (the caption then
@@ -468,16 +474,20 @@
     if (!item) return;
     speech.speaking = true;
     speech.current = item;
+    sound.duck();
     showLine(item.line);
     sayItem(item).then(() => {
       if (speech.current !== item) return;   // cut off (M, H)
       speech.current = null;
       speech.speaking = false;
+      sound.duck();
       setTimeout(next, 120);
     });
   }
 
   async function sayItem(item) {
+    await sound.afterJingle();
+    if (speech.current !== item) return;
     if (item.clips || item.blob) {
       for (const c of item.clips || []) {
         if (speech.current !== item) return;
@@ -536,6 +546,7 @@
     drop(() => true, "cut");
     speech.current = null;
     speech.speaking = false;
+    sound.duck();
   }
 
   function showVoice() {
@@ -559,17 +570,20 @@
     if (st.unlocked) return;
     st.unlocked = true;
     $("hint").hidden = true;
+    sound.start();
     // A first sound inside the gesture opens the way on some browsers.
     const v = vv();
     if (st.voiceOn && canSpeak()) {
       const item = { line: { id: 0 }, prio: 1, at: Date.now() };
       speech.speaking = true;
       speech.current = item;
+      sound.duck();
       const p = v && v.start ? (log("clip", item, v.start), playUrl(v.start)) : speak(item, "実況を始めます");
       p.then(() => {
         if (speech.current !== item) return;
         speech.current = null;
         speech.speaking = false;
+        sound.duck();
         next();
       });
     }
@@ -596,6 +610,270 @@
     }
   }
 
+  // ------------------------------------------------------------ the app's sound
+
+  // The BGM and the effects of Family mruby's mahjong app, as files made
+  // with its APU (sounds.json lists them: the effects' priorities and
+  // channels, the tunes' loops, the app's BGM levels and scenes). Web Audio,
+  // after the first click (the browser's autoplay rule): the BGM is the
+  // scene's tune from its start, its loop repeated without a seam; the
+  // levels are the app's (off, low, mid, high: low by default, as the
+  // app's), and while the voice speaks the BGM is at DUCK of its level
+  // (the effects stay as they are). An effect plays at once, beside the
+  // voice (not in its queue), and claims the APU channels it uses as the
+  // app's do: one of a higher priority still sounding on them keeps them
+  // (the new one is left out when it gets none), otherwise the older
+  // sounds on them stop. A voice that would start on top of a jingle
+  // waits for most of it (at most JINGLE_WAIT_MS). B and E switch, and the
+  // page remembers both (localStorage).
+  const sound = {
+    ctx: null,
+    manifest: null,
+    buffers: {},          // file => AudioBuffer (or a Promise of one)
+    bgmLevel: null,
+    seOn: true,
+    scene: "lobby",
+    bgm: null,            // {key, src, gain} playing
+    bgmGain: null,
+    seGain: null,
+    ducked: false,
+    duckTimer: null,
+    holders: [null, null, null, null],   // per APU channel: {pri, until, src}
+    jingleUntil: 0,
+    paused: false,
+    log: [],
+    DUCK: 0.5,
+    JINGLE_WAIT_MS: 600,
+    STORE: "asterism-games.commentate.",
+  };
+
+  sound.note = function (kind, name) {
+    const e = { t: Date.now(), kind: kind, name: name };
+    sound.log.push(e);
+    if (sound.log.length > 500) sound.log.shift();
+    if (window.console) console.log("sound", kind, name, e.t);
+  };
+
+  function stored(key) {
+    try { return window.localStorage.getItem(sound.STORE + key); } catch (e) { return null; }
+  }
+  function store(key, value) {
+    try { window.localStorage.setItem(sound.STORE + key, String(value)); } catch (e) { /* not kept */ }
+  }
+
+  sound.levels = function () { return (sound.manifest && sound.manifest.bgm_levels) || [0, 0.3, 0.55, 1]; };
+  sound.names = function () { return (sound.manifest && sound.manifest.bgm_names) || ["切", "小", "中", "大"]; };
+
+  sound.load = function () {
+    const lv = parseInt(stored("bgm"), 10);
+    sound.bgmLevel = lv >= 0 && lv <= 3 ? lv : null;
+    sound.seOn = stored("se") !== "0";
+    fetch("/sounds/sounds.json").then((r) => (r.ok ? r.json() : Promise.reject(new Error("HTTP " + r.status))))
+      .then((m) => {
+        sound.manifest = m;
+        if (sound.bgmLevel === null || sound.bgmLevel >= m.bgm_levels.length) sound.bgmLevel = m.bgm_default;
+        sound.show();
+        if (sound.ctx) { sound.preload(); sound.applyBgm(); }
+      })
+      .catch(() => { sound.manifest = null; sound.show(); });
+    sound.show();
+  };
+
+  // The first click: the context, the two volumes, the effects' files.
+  sound.start = function () {
+    if (sound.ctx) return;
+    const AC = window.AudioContext || window.webkitAudioContext;
+    if (!AC) { sound.show(); return; }
+    // 24 kHz is plenty for the APU's sound (15.72 kHz) and halves what the
+    // decoded tunes take; a browser that will not have it gets its own rate.
+    try { sound.ctx = new AC({ sampleRate: 24000 }); } catch (e) { sound.ctx = new AC(); }
+    sound.bgmGain = sound.ctx.createGain();
+    sound.bgmGain.gain.value = sound.bgmVolume();
+    sound.bgmGain.connect(sound.ctx.destination);
+    sound.seGain = sound.ctx.createGain();
+    sound.seGain.connect(sound.ctx.destination);
+    if (sound.ctx.state === "suspended") sound.ctx.resume().catch(() => {});
+    if (sound.manifest) { sound.preload(); sound.applyBgm(); }
+    sound.show();
+  };
+
+  sound.buffer = function (file) {
+    const b = sound.buffers[file];
+    if (b) return b instanceof Promise ? b : Promise.resolve(b);
+    const p = fetch("/sounds/" + file)
+      .then((r) => (r.ok ? r.arrayBuffer() : Promise.reject(new Error("HTTP " + r.status))))
+      .then((data) => new Promise((resolve, reject) => sound.ctx.decodeAudioData(data, resolve, reject)))
+      .then((buf) => { sound.buffers[file] = buf; return buf; })
+      .catch((e) => { delete sound.buffers[file]; sound.note("failed", file); throw e; });
+    sound.buffers[file] = p;
+    return p;
+  };
+
+  sound.preload = function () {
+    Object.keys(sound.manifest.effects).forEach((n) => sound.buffer(sound.manifest.effects[n].file).catch(() => {}));
+  };
+
+  sound.bgmVolume = function () {
+    const v = sound.levels()[sound.bgmLevel || 0] || 0;
+    return sound.ducked ? v * sound.DUCK : v;
+  };
+
+  sound.setScene = function (scene) {
+    if (scene === sound.scene) return;
+    sound.scene = scene;
+    sound.applyBgm();
+  };
+
+  // The tune of the scene, or none (off, the end of a game, paused).
+  sound.applyBgm = function () {
+    const m = sound.manifest;
+    if (!sound.ctx || !m) return;
+    let key = m.scenes[sound.scene] || null;
+    if (!key && sound.scene === "tense") key = m.scenes.play || null;
+    if (!sound.bgmLevel || sound.paused) key = null;
+    const cur = sound.bgm;
+    if (cur && cur.key === key) return;
+    if (cur) {
+      const t = sound.ctx.currentTime;
+      cur.gain.gain.setTargetAtTime(0, t, 0.03);
+      cur.src.stop(t + 0.2);
+      sound.bgm = null;
+    }
+    if (!key) return;
+    const tune = m.tunes[key];
+    const want = { key: key, src: null, gain: null };
+    sound.bgm = want;
+    sound.buffer(tune.file).then((buf) => {
+      if (sound.bgm !== want) return;
+      const src = sound.ctx.createBufferSource();
+      src.buffer = buf;
+      src.loop = true;
+      src.loopStart = tune.loop_start;
+      src.loopEnd = tune.loop_start + tune.loop_s;
+      const g = sound.ctx.createGain();
+      src.connect(g);
+      g.connect(sound.bgmGain);
+      src.start();
+      want.src = src;
+      want.gain = g;
+      sound.note("bgm", key);
+    }).catch(() => { if (sound.bgm === want) sound.bgm = null; });
+  };
+
+  // An effect of the app (name: sounds.json's effects), delay ms from now.
+  sound.effect = function (name, delay) {
+    if (!sound.ctx || !sound.seOn || sound.paused || !sound.manifest) return;
+    const e = sound.manifest.effects[name];
+    if (!e) return;
+    const go = () => {
+      if (!sound.seOn || sound.paused) return;
+      sound.buffer(e.file).then((buf) => sound.play(name, e, buf)).catch(() => {});
+    };
+    if (delay > 0) setTimeout(go, delay); else go();
+  };
+
+  sound.play = function (name, e, buf) {
+    const now = Date.now();
+    const free = e.channels.filter((ch) => {
+      const h = sound.holders[ch];
+      return !h || h.until <= now || e.priority >= h.pri;
+    });
+    if (!free.length) { sound.note("left out", name); return; }
+    const src = sound.ctx.createBufferSource();
+    src.buffer = buf;
+    src.connect(sound.seGain);
+    const until = now + buf.duration * 1000;
+    free.forEach((ch) => {
+      const h = sound.holders[ch];
+      if (h && h.until > now && h.src !== src) {
+        try { h.src.stop(); } catch (x) { /* ended */ }
+      }
+      sound.holders[ch] = { pri: e.priority, until: until, src: src };
+    });
+    src.start();
+    if (e.priority >= 3) sound.jingleUntil = Math.max(sound.jingleUntil, until);
+    sound.note("sfx", name);
+  };
+
+  // Resolves when a voice may start: after most of a sounding jingle.
+  sound.afterJingle = function () {
+    const wait = Math.min(sound.JINGLE_WAIT_MS, sound.jingleUntil - Date.now() - 120);
+    return wait > 0 ? new Promise((resolve) => setTimeout(resolve, wait)) : Promise.resolve();
+  };
+
+  // The BGM down while the voice speaks; up again a moment after it stops
+  // (not between two lines).
+  sound.duck = function () {
+    const on = speech.speaking;
+    if (on) {
+      if (sound.duckTimer) { clearTimeout(sound.duckTimer); sound.duckTimer = null; }
+      if (!sound.ducked) { sound.ducked = true; sound.volume(0.05); sound.note("duck", "down"); }
+    } else if (sound.ducked && !sound.duckTimer) {
+      sound.duckTimer = setTimeout(() => {
+        sound.duckTimer = null;
+        if (speech.speaking) return;
+        sound.ducked = false;
+        sound.volume(0.25);
+        sound.note("duck", "up");
+      }, 600);
+    }
+  };
+
+  sound.volume = function (tc) {
+    if (!sound.bgmGain) return;
+    const t = sound.ctx.currentTime;
+    sound.bgmGain.gain.cancelScheduledValues(t);
+    sound.bgmGain.gain.setTargetAtTime(sound.bgmVolume(), t, tc || 0.05);
+  };
+
+  sound.cycleBgm = function () {
+    const n = sound.levels().length;
+    sound.bgmLevel = ((sound.bgmLevel || 0) + 1) % n;
+    store("bgm", sound.bgmLevel);
+    sound.volume(0.05);
+    sound.applyBgm();
+    sound.show();
+  };
+
+  sound.toggleSe = function () {
+    sound.seOn = !sound.seOn;
+    store("se", sound.seOn ? 1 : 0);
+    if (!sound.seOn) {
+      sound.holders.forEach((h) => { if (h) { try { h.src.stop(); } catch (x) { /* ended */ } } });
+      sound.holders = [null, null, null, null];
+    }
+    sound.show();
+  };
+
+  sound.pause = function (p) {
+    sound.paused = p;
+    if (!sound.ctx) return;
+    if (p) sound.ctx.suspend().catch(() => {});
+    else sound.ctx.resume().catch(() => {});
+  };
+
+  sound.show = function () {
+    const b = $("bgm");
+    const e = $("se");
+    const credit = $("bgmcredit");
+    if (!sound.manifest) {
+      b.textContent = "BGM: なし";
+      b.className = "item";
+      e.textContent = "";
+      credit.hidden = true;
+      return;
+    }
+    const lv = sound.bgmLevel || 0;
+    const wait = st.unlocked ? "" : " (クリック待ち)";
+    b.textContent = "BGM " + sound.names()[lv] + " [B]" + (lv ? wait : "");
+    b.className = "item btn" + (lv ? " on" : "");
+    e.textContent = "効果音 " + (sound.seOn ? "入" : "切") + " [E]";
+    e.className = "item btn" + (sound.seOn ? " on" : "");
+    credit.hidden = !lv;
+  };
+  $("bgm").addEventListener("click", () => sound.cycleBgm());
+  $("se").addEventListener("click", () => sound.toggleSe());
+
   // ------------------------------------------------------------ the bar
 
   function showBar() {
@@ -627,6 +905,7 @@
     $("conn").className = "item warn";
     showVoice();
     showAI();
+    sound.show();
   }
 
   $("tables").addEventListener("change", (e) => {
@@ -644,6 +923,7 @@
 
   document.addEventListener("keydown", (e) => {
     if (e.target && e.target.tagName === "SELECT") return;
+    if (e.ctrlKey || e.metaKey || e.altKey) return;
     if (e.key === " ") {
       e.preventDefault();
       setPaused(!st.paused);
@@ -652,6 +932,12 @@
       if (!st.voiceOn) cut();
       unlock();
       showVoice();
+    } else if (e.key === "b" || e.key === "B") {
+      sound.cycleBgm();
+      unlock();
+    } else if (e.key === "e" || e.key === "E") {
+      sound.toggleSe();
+      unlock();
     } else if (e.key === "h" || e.key === "H") {
       st.hide = !st.hide;
       cut();
@@ -670,10 +956,12 @@
     st.paused = p;
     if (synth) { if (p) synth.pause(); else synth.resume(); }
     if (speech.audio) { if (p) speech.audio.pause(); else speech.audio.play().catch(() => {}); }
+    sound.pause(p);
     if (!p) {
       if (st.held.view) st.view = st.held.view;
+      if (st.held.bgm) sound.setScene(st.held.bgm);
       const held = st.held.lines;
-      st.held = { view: null, lines: [] };
+      st.held = { view: null, lines: [], bgm: null };
       const big = held.filter((l) => (l.prio || 0) >= 3).pop();
       held.forEach((l) => { st.lines.push(l); if (l !== big) addCaption(l); });
       if (big && !say(big)) addCaption(big);
@@ -707,8 +995,10 @@
       const d = JSON.parse(e.data);
       if (st.table && d.table !== st.table) return;
       if (!st.table) st.table = d.table;
-      if (st.paused) { st.held.view = d.view; return; }
+      if (st.paused) { st.held.view = d.view; st.held.bgm = d.bgm; return; }
       st.view = d.view;
+      sound.setScene(d.bgm || "lobby");
+      (d.sounds || []).forEach((x) => sound.effect(x[0], x[1]));
       draw();
       showBar();
     });
@@ -730,6 +1020,7 @@
   draw();
   showBar();
   connect();
+  sound.load();
   // For a test or a tool driving the page.
-  window.commentate = { state: st, played: played, speech: speech };
+  window.commentate = { state: st, played: played, speech: speech, sound: sound };
 })();