sci2-ts 0.9.0 → 0.10.0

package/packages/sci/src/audio/write.ts

@@ -1,5 +1,5 @@
 import type { MidiEvent } from "./midi.ts";
-import { SolFlag } from "./sol.ts";
+import { DPCM16, SolFlag } from "./sol.ts";
 
 /**
  * Writers for sound: sound resources (music, in the layout parseSound reads), SOL clips, and
@@ -69,20 +69,109 @@ export function writeSound(spec: SoundSpec): Uint8Array {
   return Uint8Array.from([...header, ...table, ...body]);
 }
 
-/** A SOL clip: 16-bit samples at `rate`, uncompressed. */
-export function writeSol(samples: Int16Array, rate: number): Uint8Array {
-  const out = new Uint8Array(13 + samples.length * 2);
+/**
+ * A SOL clip of 16-bit samples at `rate`: uncompressed, or compressed with SOL's 16-bit DPCM
+ * (one byte a sample, half the size; what speech uses).
+ */
+export function writeSol(samples: Int16Array, rate: number, compressed = false): Uint8Array {
+  const data = compressed ? encodeDpcm16(samples) : new Uint8Array(samples.buffer, samples.byteOffset, samples.byteLength);
+  const out = new Uint8Array(13 + data.length);
   const v = new DataView(out.buffer);
   out[0] = 0x8d; // audio
   out[1] = 11; // header bytes after these two
   out.set([0x53, 0x4f, 0x4c, 0], 2); // "SOL\0"
   v.setUint16(6, rate, true);
-  out[8] = SolFlag.Bits16 | SolFlag.Signed;
-  v.setUint32(9, samples.length * 2, true);
-  samples.forEach((s, i) => v.setInt16(13 + i * 2, s, true));
+  out[8] = compressed ? SolFlag.Compressed | SolFlag.Bits16 : SolFlag.Bits16 | SolFlag.Signed;
+  v.setUint32(9, data.length, true);
+  if (compressed) out.set(data, 13);
+  else samples.forEach((s, i) => v.setInt16(13 + i * 2, s, true));
+  return out;
+}
+
+/**
+ * SOL's 16-bit DPCM: each byte steps from the last sample by DPCM16[byte & 0x7f], down if
+ * bit 7 is set. Each step is the one that lands nearest the sample, never past the 16-bit
+ * range (the decoder would wrap around).
+ */
+export function encodeDpcm16(samples: Int16Array): Uint8Array {
+  const out = new Uint8Array(samples.length);
+  let last = 0;
+  for (let i = 0; i < samples.length; i++) {
+    const want = samples[i]! - last, size = Math.abs(want);
+    let lo = 0, hi = DPCM16.length - 1;
+    while (lo < hi) {
+      const mid = (lo + hi) >> 1;
+      if (DPCM16[mid]! < size) lo = mid + 1;
+      else hi = mid;
+    }
+    // lo is the first step at least as big; the one below may be nearer.
+    if (lo > 0 && size - DPCM16[lo - 1]! < DPCM16[lo]! - size) lo--;
+    const down = want < 0;
+    const land = (k: number) => last + (down ? -DPCM16[k]! : DPCM16[k]!);
+    while (lo > 0 && (land(lo) > 32767 || land(lo) < -32768)) lo--;
+    out[i] = (down ? 0x80 : 0) | lo;
+    last = land(lo);
+  }
   return out;
 }
 
+export interface SpeechClip {
+  /** The message file (room) the line is in, and its key there. */
+  module: number;
+  noun: number;
+  verb: number;
+  cond: number;
+  seq: number;
+  sol: Uint8Array;
+}
+
+/**
+ * RESOURCE.AUD (SOL clips one after another, by module and key) and a map per module, in the
+ * layout AudioIndex reads: u32 offset of the module's first clip, then per clip u32
+ * big-endian noun<<24|verb<<16|cond<<8|seq and a u24 delta from the previous clip;
+ * 0xFFFFFFFF ends it.
+ *
+ * The index takes a clip's length from where the next one starts, so the last map also has
+ * an entry at the end of the file, under 0 0 0 0, which no message has (nouns and seqs
+ * start at 1); without it the last clip's length would be a guess.
+ */
+export function writeSpeech(clips: readonly SpeechClip[]): { aud: Uint8Array; maps: { module: number; data: Uint8Array }[] } {
+  const key = (c: SpeechClip) => ((c.noun << 24) | (c.verb << 16) | (c.cond << 8) | c.seq) >>> 0;
+  const sorted = [...clips].sort((a, b) => a.module - b.module || key(a) - key(b));
+  const aud = new Uint8Array(sorted.reduce((n, c) => n + c.sol.length, 0));
+  const modules = [...new Set(sorted.map((c) => c.module))];
+  let at = 0;
+  const maps = modules.map((module, m) => {
+    const mine = sorted.filter((c) => c.module === module);
+    const last = m === modules.length - 1;
+    const data = new Uint8Array(4 + (mine.length + (last ? 1 : 0)) * 7 + 4);
+    const v = new DataView(data.buffer);
+    v.setUint32(0, at, true);
+    let prev = at, p = 4;
+    const entry = (k: number) => {
+      const delta = at - prev;
+      if (delta > 0xffffff) throw new Error("speech clip too large (16 MB at most)");
+      v.setUint32(p, k, false);
+      data.set([delta & 0xff, (delta >> 8) & 0xff, delta >> 16], p + 4);
+      p += 7;
+      prev = at;
+    };
+    mine.forEach((c, i) => {
+      const where = `${c.module} ${c.noun} ${c.verb} ${c.cond} ${c.seq}`;
+      for (const [n, max] of [[c.noun, 255], [c.verb, 255], [c.cond, 255]] as const) if (n < 0 || n > max) throw new Error(`speech for ${where}: noun, verb and cond are 0-255`);
+      if (c.seq < 1 || c.seq > 63) throw new Error(`speech for ${where}: seq is 1-63`);
+      if (i && key(c) === key(mine[i - 1]!)) throw new Error(`speech for ${where} is there twice`);
+      entry(key(c));
+      aud.set(c.sol, at);
+      at += c.sol.length;
+    });
+    if (last) entry(0);
+    v.setUint32(p, 0xffffffff, false);
+    return { module, data };
+  });
+  return { aud, maps };
+}
+
 /**
  * RESOURCE.SFX (the SOL clips, one after another) and its index, map 65535: per clip, u16
  * sound number and u24 offset from the previous clip; 0xFFFF ends it.

package/packages/sci/src/vm/kernels/audio.js

@@ -223,7 +223,7 @@ export const audioKernels = {
                 return pos === undefined ? NOT_PLAYING : pos & 0xffff;
             }
             case 8: return 0; // volume
-            case 9: return 1; // capability: audio present
+            case 9: return a.index.speech.size ? 1 : 0; // the game has speech
             case 10: return 16; // bit depth
             case 12: return 1; // mixing
             case 13: return 2; // channels

package/packages/sci/src/vm/kernels/audio.ts

@@ -232,7 +232,7 @@ export const audioKernels: Record<string, KernelFn> = {
         return pos === undefined ? NOT_PLAYING : pos & 0xffff;
       }
       case 8: return 0; // volume
-      case 9: return 1; // capability: audio present
+      case 9: return a.index.speech.size ? 1 : 0; // the game has speech
       case 10: return 16; // bit depth
       case 12: return 1; // mixing
       case 13: return 2; // channels

package/tools/cli.js

@@ -7,6 +7,9 @@
  *   sci-ts edit [dir] [--port <n>]      build it, then serve the live editor for its rooms
  *   sci-ts site [dir] [--out <dir>]     a static site: the game's README and docs, and the game
  *                                       in the player (in <dir>/out/site)
+ *   sci-ts lines tag [dir]              give every spoken line in rooms/*.yarn a #line: id
+ *   sci-ts lines script [dir]           write voices/lines.json, the script for recording, and
+ *                                       say what's recorded and what's still to do
  *   sci-ts art check|build <art.json> [out]   check or build editor-made art (tools/art.ts)
  */
 import { spawn } from "node:child_process";
@@ -14,13 +17,17 @@ import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { basename, join, relative, resolve } from "node:path";
 import { writeResourceArchive } from "../packages/sci/src/index.js";
 import { GameBuildError, buildGame } from "./game/build.js";
+import { tagGameLines } from "./game/lines.js";
+import { readLineScript } from "./game/voices.js";
 import { newGame } from "./game/new.js";
 import { buildSite } from "./site/build.js";
 const VIEWER = resolve(import.meta.dirname, "../apps/viewer");
 const usage = `usage: sci-ts new <dir>
        sci-ts build|play|edit|site [dir] [--out <dir>] [--port <n>]
+       sci-ts lines tag|script [dir]
        sci-ts art check|build <art.json> [out]`;
 const [command, ...rest] = process.argv.slice(2);
+const sub = command === "lines" ? rest.shift() : undefined;
 const option = (name) => {
     const i = rest.indexOf(`--${name}`);
     return i >= 0 ? rest.splice(i, 2)[1] : undefined;
@@ -52,7 +59,7 @@ async function serve(to, page) {
     console.log(`${basename(dir)}: ${url}${page}`);
 }
 try {
-    if (["build", "play", "edit", "site"].includes(command ?? "") && !existsSync(join(dir, "scripts"))) {
+    if (["build", "play", "edit", "site", "lines"].includes(command ?? "") && !existsSync(join(dir, "scripts"))) {
         throw new GameBuildError(`${shown(dir)}: no game here (no scripts/ folder); sci-ts new <dir> starts one`);
     }
     switch (command) {
@@ -80,6 +87,34 @@ try {
             console.log(`${shown(to)}: ${site.pages} pages, the game in play/play.html${site.soundFont ? "" : " (no SoundFont: music is silent)"}`);
             break;
         }
+        case "lines": {
+            if (sub === "tag") {
+                const tagged = tagGameLines(dir);
+                for (const { file, added } of tagged)
+                    console.log(`${shown(file)}: ${added.length} line${added.length > 1 ? "s" : ""} tagged (${added[0]} to ${added.at(-1)})`);
+                if (!tagged.length)
+                    console.log(`${shown(dir)}: every spoken line has an id`);
+            }
+            else if (sub === "script") {
+                // The build writes the script once there's a voices/ folder.
+                mkdirSync(join(dir, "voices"), { recursive: true });
+                const game = await buildGame(dir);
+                const lines = [...readLineScript(dir).values()];
+                const untagged = [...game.lines.values()].flat().filter((l) => l.id === undefined).length;
+                console.log(`${shown(join(dir, "voices/lines.json"))}: ${lines.length} lines${untagged ? ` (and ${untagged} with no id: sci-ts lines tag)` : ""}`);
+                const speakers = [...new Set(lines.map((l) => l.speaker))];
+                for (const who of speakers) {
+                    const theirs = lines.filter((l) => l.speaker === who);
+                    const count = (r) => theirs.filter((l) => l.recording === r).length;
+                    console.log(`  ${who}: ${theirs.length} lines, ${count("recorded")} recorded, ${count("changed")} changed since, ${count("missing")} to record`);
+                }
+                for (const l of lines.filter((x) => x.recording === "changed"))
+                    console.log(`  changed: ${l.id} (${l.where}) "${l.text}"`);
+            }
+            else
+                throw new GameBuildError(usage);
+            break;
+        }
         case "art": {
             // The art tool keeps its own command line; run it with this process's loader (tsx).
             const art = spawn(process.execPath, [...process.execArgv, join(import.meta.dirname, "art.ts"), ...rest], { stdio: "inherit" });

package/tools/cli.ts

@@ -7,6 +7,9 @@
  *   sci-ts edit [dir] [--port <n>]      build it, then serve the live editor for its rooms
  *   sci-ts site [dir] [--out <dir>]     a static site: the game's README and docs, and the game
  *                                       in the player (in <dir>/out/site)
+ *   sci-ts lines tag [dir]              give every spoken line in rooms/*.yarn a #line: id
+ *   sci-ts lines script [dir]           write voices/lines.json, the script for recording, and
+ *                                       say what's recorded and what's still to do
  *   sci-ts art check|build <art.json> [out]   check or build editor-made art (tools/art.ts)
  */
 import { spawn } from "node:child_process";
@@ -14,15 +17,19 @@ import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { basename, join, relative, resolve } from "node:path";
 import { writeResourceArchive } from "../packages/sci/src/index.ts";
 import { GameBuildError, buildGame } from "./game/build.ts";
+import { tagGameLines } from "./game/lines.ts";
+import { readLineScript } from "./game/voices.ts";
 import { newGame } from "./game/new.ts";
 import { buildSite } from "./site/build.ts";
 
 const VIEWER = resolve(import.meta.dirname, "../apps/viewer");
 const usage = `usage: sci-ts new <dir>
        sci-ts build|play|edit|site [dir] [--out <dir>] [--port <n>]
+       sci-ts lines tag|script [dir]
        sci-ts art check|build <art.json> [out]`;
 
 const [command, ...rest] = process.argv.slice(2);
+const sub = command === "lines" ? rest.shift() : undefined;
 const option = (name: string) => {
   const i = rest.indexOf(`--${name}`);
   return i >= 0 ? rest.splice(i, 2)[1] : undefined;
@@ -55,7 +62,7 @@ async function serve(to: string, page: string) {
 }
 
 try {
-  if (["build", "play", "edit", "site"].includes(command ?? "") && !existsSync(join(dir, "scripts"))) {
+  if (["build", "play", "edit", "site", "lines"].includes(command ?? "") && !existsSync(join(dir, "scripts"))) {
     throw new GameBuildError(`${shown(dir)}: no game here (no scripts/ folder); sci-ts new <dir> starts one`);
   }
   switch (command) {
@@ -82,6 +89,28 @@ try {
       console.log(`${shown(to)}: ${site.pages} pages, the game in play/play.html${site.soundFont ? "" : " (no SoundFont: music is silent)"}`);
       break;
     }
+    case "lines": {
+      if (sub === "tag") {
+        const tagged = tagGameLines(dir);
+        for (const { file, added } of tagged) console.log(`${shown(file)}: ${added.length} line${added.length > 1 ? "s" : ""} tagged (${added[0]} to ${added.at(-1)})`);
+        if (!tagged.length) console.log(`${shown(dir)}: every spoken line has an id`);
+      } else if (sub === "script") {
+        // The build writes the script once there's a voices/ folder.
+        mkdirSync(join(dir, "voices"), { recursive: true });
+        const game = await buildGame(dir);
+        const lines = [...readLineScript(dir).values()];
+        const untagged = [...game.lines.values()].flat().filter((l) => l.id === undefined).length;
+        console.log(`${shown(join(dir, "voices/lines.json"))}: ${lines.length} lines${untagged ? ` (and ${untagged} with no id: sci-ts lines tag)` : ""}`);
+        const speakers = [...new Set(lines.map((l) => l.speaker))];
+        for (const who of speakers) {
+          const theirs = lines.filter((l) => l.speaker === who);
+          const count = (r: string) => theirs.filter((l) => l.recording === r).length;
+          console.log(`  ${who}: ${theirs.length} lines, ${count("recorded")} recorded, ${count("changed")} changed since, ${count("missing")} to record`);
+        }
+        for (const l of lines.filter((x) => x.recording === "changed")) console.log(`  changed: ${l.id} (${l.where}) "${l.text}"`);
+      } else throw new GameBuildError(usage);
+      break;
+    }
     case "art": {
       // The art tool keeps its own command line; run it with this process's loader (tsx).
       const art = spawn(process.execPath, [...process.execArgv, join(import.meta.dirname, "art.ts"), ...rest], { stdio: "inherit" });

package/tools/game/audio.d.ts

@@ -17,3 +17,17 @@ export declare function readWav(data: Uint8Array): {
     samples: Int16Array;
     rate: number;
 };
+/** The rate speech is stored at: plenty for a voice, and one byte a sample with DPCM. */
+export declare const SPEECH_RATE = 11025;
+/**
+ * A recorded line made ready for the game: resampled to SPEECH_RATE, the silence before and
+ * after it trimmed (a little is kept, so it doesn't start or end abruptly), and brought to
+ * the same peak as every other line.
+ */
+export declare function prepareSpeech(samples: Int16Array, rate: number): Int16Array;
+/**
+ * Band-limited resampling: each output sample is a Blackman-windowed sinc over the input,
+ * cut off below the lower rate's Nyquist frequency so nothing above it folds back. The
+ * kernel is tabulated at PHASES fractional positions between input samples.
+ */
+export declare function resample(x: Float32Array, from: number, to: number): Float32Array;

package/tools/game/audio.js

@@ -141,3 +141,65 @@ export function readWav(data) {
     }
     throw new AudioFileError("WAV file without data");
 }
+/** The rate speech is stored at: plenty for a voice, and one byte a sample with DPCM. */
+export const SPEECH_RATE = 11025;
+/**
+ * A recorded line made ready for the game: resampled to SPEECH_RATE, the silence before and
+ * after it trimmed (a little is kept, so it doesn't start or end abruptly), and brought to
+ * the same peak as every other line.
+ */
+export function prepareSpeech(samples, rate) {
+    const x = resample(Float32Array.from(samples, (s) => s / 32768), rate, SPEECH_RATE);
+    let peak = 0;
+    for (const s of x)
+        peak = Math.max(peak, Math.abs(s));
+    if (peak === 0)
+        return new Int16Array(0);
+    // Quieter than 1/32 of the peak (-30 dB) is silence; keep 60 ms of it either side.
+    const quiet = peak / 32, pad = Math.round(SPEECH_RATE * 0.06);
+    let first = x.findIndex((s) => Math.abs(s) > quiet), last = x.length - 1;
+    while (last > first && Math.abs(x[last]) <= quiet)
+        last--;
+    first = Math.max(0, first - pad);
+    last = Math.min(x.length - 1, last + pad);
+    const gain = 0.9 / peak; // -1 dB
+    return Int16Array.from(x.subarray(first, last + 1), (s) => Math.round(Math.max(-1, Math.min(1, s * gain)) * 32767));
+}
+/**
+ * Band-limited resampling: each output sample is a Blackman-windowed sinc over the input,
+ * cut off below the lower rate's Nyquist frequency so nothing above it folds back. The
+ * kernel is tabulated at PHASES fractional positions between input samples.
+ */
+export function resample(x, from, to) {
+    if (from === to)
+        return x.slice();
+    const PHASES = 256;
+    const n = Math.max(1, Math.round((x.length * to) / from));
+    const cutoff = 0.95 * Math.min(1, to / from); // of the input's Nyquist frequency
+    const half = Math.ceil(16 / cutoff); // input samples either side: 16 zero crossings
+    const taps = 2 * half;
+    // table[p][k]: the weight of input sample floor(centre) - half + 1 + k, for a centre p/PHASES past it.
+    const table = new Float32Array((PHASES + 1) * taps);
+    for (let p = 0; p <= PHASES; p++) {
+        let sum = 0;
+        for (let k = 0; k < taps; k++) {
+            const t = k - half + 1 - p / PHASES;
+            const sinc = t === 0 ? 1 : Math.sin(Math.PI * cutoff * t) / (Math.PI * cutoff * t);
+            const w = Math.abs(t) >= half ? 0 : 0.42 + 0.5 * Math.cos((Math.PI * t) / half) + 0.08 * Math.cos((2 * Math.PI * t) / half);
+            sum += table[p * taps + k] = sinc * w;
+        }
+        for (let k = 0; k < taps; k++)
+            table[p * taps + k] /= sum;
+    }
+    const out = new Float32Array(n);
+    for (let i = 0; i < n; i++) {
+        const centre = (i * from) / to, base = Math.floor(centre);
+        const row = Math.round((centre - base) * PHASES) * taps;
+        let sum = 0;
+        for (let k = 0, j = base - half + 1; k < taps; k++, j++)
+            if (j >= 0 && j < x.length)
+                sum += x[j] * table[row + k];
+        out[i] = sum;
+    }
+    return out;
+}

package/tools/game/audio.ts

@@ -128,3 +128,61 @@ export function readWav(data: Uint8Array): { samples: Int16Array; rate: number }
   }
   throw new AudioFileError("WAV file without data");
 }
+
+/** The rate speech is stored at: plenty for a voice, and one byte a sample with DPCM. */
+export const SPEECH_RATE = 11025;
+
+/**
+ * A recorded line made ready for the game: resampled to SPEECH_RATE, the silence before and
+ * after it trimmed (a little is kept, so it doesn't start or end abruptly), and brought to
+ * the same peak as every other line.
+ */
+export function prepareSpeech(samples: Int16Array, rate: number): Int16Array {
+  const x = resample(Float32Array.from(samples, (s) => s / 32768), rate, SPEECH_RATE);
+  let peak = 0;
+  for (const s of x) peak = Math.max(peak, Math.abs(s));
+  if (peak === 0) return new Int16Array(0);
+  // Quieter than 1/32 of the peak (-30 dB) is silence; keep 60 ms of it either side.
+  const quiet = peak / 32, pad = Math.round(SPEECH_RATE * 0.06);
+  let first = x.findIndex((s) => Math.abs(s) > quiet), last = x.length - 1;
+  while (last > first && Math.abs(x[last]!) <= quiet) last--;
+  first = Math.max(0, first - pad);
+  last = Math.min(x.length - 1, last + pad);
+  const gain = 0.9 / peak; // -1 dB
+  return Int16Array.from(x.subarray(first, last + 1), (s) => Math.round(Math.max(-1, Math.min(1, s * gain)) * 32767));
+}
+
+/**
+ * Band-limited resampling: each output sample is a Blackman-windowed sinc over the input,
+ * cut off below the lower rate's Nyquist frequency so nothing above it folds back. The
+ * kernel is tabulated at PHASES fractional positions between input samples.
+ */
+export function resample(x: Float32Array, from: number, to: number): Float32Array {
+  if (from === to) return x.slice();
+  const PHASES = 256;
+  const n = Math.max(1, Math.round((x.length * to) / from));
+  const cutoff = 0.95 * Math.min(1, to / from); // of the input's Nyquist frequency
+  const half = Math.ceil(16 / cutoff); // input samples either side: 16 zero crossings
+  const taps = 2 * half;
+  // table[p][k]: the weight of input sample floor(centre) - half + 1 + k, for a centre p/PHASES past it.
+  const table = new Float32Array((PHASES + 1) * taps);
+  for (let p = 0; p <= PHASES; p++) {
+    let sum = 0;
+    for (let k = 0; k < taps; k++) {
+      const t = k - half + 1 - p / PHASES;
+      const sinc = t === 0 ? 1 : Math.sin(Math.PI * cutoff * t) / (Math.PI * cutoff * t);
+      const w = Math.abs(t) >= half ? 0 : 0.42 + 0.5 * Math.cos((Math.PI * t) / half) + 0.08 * Math.cos((2 * Math.PI * t) / half);
+      sum += table[p * taps + k] = sinc * w;
+    }
+    for (let k = 0; k < taps; k++) table[p * taps + k]! /= sum;
+  }
+  const out = new Float32Array(n);
+  for (let i = 0; i < n; i++) {
+    const centre = (i * from) / to, base = Math.floor(centre);
+    const row = Math.round((centre - base) * PHASES) * taps;
+    let sum = 0;
+    for (let k = 0, j = base - half + 1; k < taps; k++, j++) if (j >= 0 && j < x.length) sum += x[j]! * table[row + k]!;
+    out[i] = sum;
+  }
+  return out;
+}

package/tools/game/build.d.ts

@@ -1,4 +1,5 @@
 import { type ResourceData } from "../../packages/sci/src/index.ts";
+import { type SpokenLine } from "../../packages/content/src/index.ts";
 /**
  * Builds a game from its sources, needing nothing from any other game:
  *
@@ -14,6 +15,9 @@ import { type ResourceData } from "../../packages/sci/src/index.ts";
  *                                  the item itself, made in script ITEMS_SCRIPT (<<get lens>>)
  *   games/<name>/music/<n>.mid     music: sound n, from a Standard MIDI File (General MIDI)
  *   games/<name>/sounds/<n>.wav    digital effects: sound n plays this instead of music
+ *   games/<name>/voices/<id>.wav   speech: the line tagged #line:<id> in a room's Yarn
+ *                                  (RESOURCE.AUD, and a map per room); the build keeps
+ *                                  voices/lines.json, the script, up to date
  *   games/<name>/resources.ts      optional: `export default () => ResourceData[]` for art,
  *                                  music and anything else made by code
  *   games/<name>/game.json         optional: { "library": false } to build without lib/
@@ -35,7 +39,9 @@ export interface BuiltGame {
     globals: string[];
     /** The message text compiled from each YAML room's Yarn, by room. */
     roomMessages: Map<number, string>;
-    /** Files that go next to RESOURCE.MAP and RESOURCE.000 (RESOURCE.SFX, the effects). */
+    /** Each YAML room's spoken lines, by room: their #line: ids and message keys today. */
+    lines: Map<number, SpokenLine[]>;
+    /** Files that go next to RESOURCE.MAP and RESOURCE.000 (RESOURCE.SFX, the effects; RESOURCE.AUD, speech). */
     files: Record<string, Uint8Array>;
     /** Likely mistakes that still built, as file:line: message. */
     warnings: string[];

package/tools/game/build.js

@@ -10,10 +10,11 @@ import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { basename, dirname, join, relative, resolve } from "node:path";
 import { pathToFileURL } from "node:url";
 import { parse as parseYaml } from "yaml";
-import { AsmError, CompileError, GLOBAL_NAMES_VOCAB, OBJECT_HEADER, ResourceType, assemble, compileScripts, kernelNames, messagesFromText, parseScript, resourceKey, writeClassTable, writeEffects, writeMessages, writeSelectorNames, writeSol, writeSound, } from "../../packages/sci/src/index.js";
+import { AsmError, CompileError, GLOBAL_NAMES_VOCAB, OBJECT_HEADER, ResourceType, assemble, compileScripts, kernelNames, messagesFromText, parseScript, resourceKey, writeClassTable, writeEffects, writeMessages, writeSelectorNames, writeSol, writeSound, writeSpeech, } from "../../packages/sci/src/index.js";
 import { ContentError, compileRoom } from "../../packages/content/src/index.js";
 import { modFlags } from "../mod-build.js";
-import { AudioFileError, readMidiFile, readWav } from "./audio.js";
+import { AudioFileError, SPEECH_RATE, prepareSpeech, readMidiFile, readWav } from "./audio.js";
+import { lineScript, writeLineScript } from "./voices.js";
 import { defaultResources } from "./defaults.js";
 import { ITEMS_SCRIPT, libraryTarget } from "./target.js";
 const HEADER = OBJECT_HEADER;
@@ -113,6 +114,7 @@ export async function buildGame(dir, options = {}) {
     // Rooms as YAML and Yarn: compiled once script 0 is (the target needs its globals).
     const roomMessages = [];
     const roomMessageText = new Map();
+    const roomLines = new Map();
     const compileRooms = () => {
         const roomsDir = join(dir, "rooms");
         if (!existsSync(roomsDir))
@@ -136,6 +138,7 @@ export async function buildGame(dir, options = {}) {
             }
             generated.set(n, room.sca);
             roomMessageText.set(n, room.msg);
+            roomLines.set(n, room.lines);
             roomMessages.push({ type: ResourceType.Message, number: n, data: writeMessages(messagesFromText(room.msg).file) });
             out.push({ file: relative(process.cwd(), file), text: room.sca });
         }
@@ -236,6 +239,59 @@ export async function buildGame(dir, options = {}) {
             resources.push({ type: ResourceType.Map, number: 65535, data: map });
         }
     }
+    // Line ids are the game's, not just a room's: recordings are filed under them.
+    const ids = new Map();
+    for (const line of [...roomLines.values()].flat()) {
+        if (line.id === undefined)
+            continue;
+        const first = ids.get(line.id);
+        if (first)
+            throw new GameBuildError(`${line.where}: #line:${line.id} is already the id of ${first}`);
+        ids.set(line.id, line.where);
+    }
+    if (existsSync(join(dir, "voices"))) {
+        const untagged = [...roomLines.values()].flat().filter((l) => l.id === undefined);
+        if (untagged.length)
+            warnings.push(`${untagged[0].where}: ${untagged.length} spoken line${untagged.length > 1 ? "s have" : " has"} no #line: id, so no recording can be found for ${untagged.length > 1 ? "them" : "it"} (sci-ts lines tag adds them)`);
+    }
+    // Recorded lines, voices/<id>.wav: each filed under its line's message key today.
+    const voicesDir = join(dir, "voices");
+    if (existsSync(voicesDir)) {
+        const byId = new Map([...roomLines].flatMap(([room, lines]) => lines.filter((l) => l.id !== undefined).map((l) => [l.id, { room, line: l }])));
+        const clips = [];
+        for (const f of readdirSync(voicesDir).filter((x) => /\.wav$/i.test(x)).sort()) {
+            const file = join(voicesDir, f);
+            const found = byId.get(f.slice(0, -4));
+            if (!found) {
+                warnings.push(`${relative(process.cwd(), file)}: no line has the id #line:${f.slice(0, -4)}, so it isn't used`);
+                continue;
+            }
+            const { samples, rate } = audioFile(file, () => readWav(new Uint8Array(readFileSync(file))));
+            const { noun, verb, cond, seq } = found.line;
+            clips.push({ module: found.room, noun, verb, cond, seq, sol: writeSol(prepareSpeech(samples, rate), SPEECH_RATE, true) });
+        }
+        if (clips.length) {
+            const { aud, maps } = writeSpeech(clips);
+            files["RESOURCE.AUD"] = aud;
+            for (const m of maps)
+                resources.push({ type: ResourceType.Map, number: m.module, data: m.data });
+        }
+        // The script, and what's still to record.
+        let script;
+        try {
+            script = lineScript(dir, roomLines);
+        }
+        catch (e) {
+            throw new GameBuildError(`${relative(process.cwd(), join(voicesDir, "lines.json"))}: ${e.message}`);
+        }
+        writeLineScript(dir, script);
+        for (const l of script.filter((x) => x.recording === "changed")) {
+            warnings.push(`${relative(process.cwd(), join(voicesDir, `${l.id}.wav`))}: recorded before its line changed (${l.where}: "${l.text}"); record it again`);
+        }
+        const missing = script.filter((x) => x.recording === "missing").length;
+        if (missing)
+            warnings.push(`${relative(process.cwd(), join(voicesDir, "lines.json"))}: ${missing} of ${script.length} lines have no recording yet`);
+    }
     // Resources made in code: the game's, then the library's and the defaults for what's left.
     const made = async (path) => {
         if (!existsSync(path))
@@ -262,6 +318,7 @@ export async function buildGame(dir, options = {}) {
         generated,
         globals,
         roomMessages: roomMessageText,
+        lines: roomLines,
         files,
         warnings: [...new Set(warnings)],
     };