sci2-ts 0.9.0 → 0.10.0

package/tools/game/build.ts

@@ -4,12 +4,13 @@ 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, type AsmContext,
+  resourceKey, writeClassTable, writeEffects, writeMessages, writeSelectorNames, writeSol, writeSound, writeSpeech, type AsmContext, type SpeechClip,
   type ResourceData, type ScriptObject,
 } from "../../packages/sci/src/index.ts";
-import { ContentError, compileRoom } from "../../packages/content/src/index.ts";
+import { ContentError, compileRoom, type SpokenLine } from "../../packages/content/src/index.ts";
 import { modFlags } from "../mod-build.ts";
-import { AudioFileError, readMidiFile, readWav } from "./audio.ts";
+import { AudioFileError, SPEECH_RATE, prepareSpeech, readMidiFile, readWav } from "./audio.ts";
+import { lineScript, writeLineScript, type ScriptLine } from "./voices.ts";
 import { defaultResources } from "./defaults.ts";
 import { ITEMS_SCRIPT, libraryTarget } from "./target.ts";
 
@@ -28,6 +29,9 @@ import { ITEMS_SCRIPT, libraryTarget } from "./target.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/
@@ -46,7 +50,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[];
@@ -148,6 +154,7 @@ export async function buildGame(dir: string, options: { library?: boolean } = {}
   // Rooms as YAML and Yarn: compiled once script 0 is (the target needs its globals).
   const roomMessages: ResourceData[] = [];
   const roomMessageText = new Map<number, string>();
+  const roomLines = new Map<number, SpokenLine[]>();
   const compileRooms = (): { file: string; text: string }[] => {
     const roomsDir = join(dir, "rooms");
     if (!existsSync(roomsDir)) return [];
@@ -168,6 +175,7 @@ export async function buildGame(dir: string, options: { library?: boolean } = {}
       }
       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 });
     }
@@ -264,6 +272,55 @@ export async function buildGame(dir: string, options: { library?: boolean } = {}
     }
   }
 
+  // Line ids are the game's, not just a room's: recordings are filed under them.
+  const ids = new Map<string, string>();
+  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 }] as const)));
+    const clips: SpeechClip[] = [];
+    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: ScriptLine[];
+    try {
+      script = lineScript(dir, roomLines);
+    } catch (e) {
+      throw new GameBuildError(`${relative(process.cwd(), join(voicesDir, "lines.json"))}: ${(e as Error).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: string) => {
     if (!existsSync(path)) return [];
@@ -288,6 +345,7 @@ export async function buildGame(dir: string, options: { library?: boolean } = {}
     generated,
     globals,
     roomMessages: roomMessageText,
+    lines: roomLines,
     files,
     warnings: [...new Set(warnings)],
   };

package/tools/game/lines.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Gives every spoken line in the game's rooms/*.yarn without an id one: `<room>-001` and on,
+ * unique across the game. Returns the files changed and the ids added to each.
+ */
+export declare function tagGameLines(dir: string): {
+    file: string;
+    added: string[];
+}[];

package/tools/game/lines.js

@@ -0,0 +1,53 @@
+import { readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { join, relative } from "node:path";
+import { YarnError, parseYarn, tagLines, yarnLines } from "../../packages/content/src/index.js";
+import { GameBuildError } from "./build.js";
+/**
+ * Spoken lines and their recordings. Recordings are filed under a line's #line: id, which
+ * stays with the line however the rooms change; the build maps ids to message keys.
+ */
+const yarnFiles = (dir) => {
+    const rooms = join(dir, "rooms");
+    let names;
+    try {
+        names = readdirSync(rooms);
+    }
+    catch {
+        return [];
+    }
+    return names.filter((f) => /^\d+\.yarn$/.test(f)).sort().map((f) => ({ file: join(rooms, f), room: f.slice(0, -5) }));
+};
+/**
+ * Gives every spoken line in the game's rooms/*.yarn without an id one: `<room>-001` and on,
+ * unique across the game. Returns the files changed and the ids added to each.
+ */
+export function tagGameLines(dir) {
+    const files = yarnFiles(dir).map((f) => ({ ...f, text: readFileSync(f.file, "utf8") }));
+    const parse = (f) => {
+        try {
+            return f();
+        }
+        catch (e) {
+            if (e instanceof YarnError)
+                throw new GameBuildError(e.message);
+            throw e;
+        }
+    };
+    const taken = new Set();
+    for (const f of files) {
+        const where = relative(process.cwd(), f.file);
+        for (const l of parse(() => parseYarn(f.text, where)).flatMap((n) => yarnLines(n.body)))
+            if (l.id !== undefined)
+                taken.add(l.id);
+    }
+    const changed = [];
+    for (const f of files) {
+        const where = relative(process.cwd(), f.file);
+        const { source, added } = parse(() => tagLines(f.text, f.room, taken, where));
+        if (!added.length)
+            continue;
+        writeFileSync(f.file, source);
+        changed.push({ file: f.file, added });
+    }
+    return changed;
+}

package/tools/game/lines.ts

@@ -0,0 +1,44 @@
+import { readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { join, relative } from "node:path";
+import { YarnError, parseYarn, tagLines, yarnLines } from "../../packages/content/src/index.ts";
+import { GameBuildError } from "./build.ts";
+
+/**
+ * Spoken lines and their recordings. Recordings are filed under a line's #line: id, which
+ * stays with the line however the rooms change; the build maps ids to message keys.
+ */
+
+const yarnFiles = (dir: string) => {
+  const rooms = join(dir, "rooms");
+  let names: string[];
+  try { names = readdirSync(rooms); } catch { return []; }
+  return names.filter((f) => /^\d+\.yarn$/.test(f)).sort().map((f) => ({ file: join(rooms, f), room: f.slice(0, -5) }));
+};
+
+/**
+ * Gives every spoken line in the game's rooms/*.yarn without an id one: `<room>-001` and on,
+ * unique across the game. Returns the files changed and the ids added to each.
+ */
+export function tagGameLines(dir: string): { file: string; added: string[] }[] {
+  const files = yarnFiles(dir).map((f) => ({ ...f, text: readFileSync(f.file, "utf8") }));
+  const parse = <T>(f: () => T): T => {
+    try { return f(); } catch (e) {
+      if (e instanceof YarnError) throw new GameBuildError(e.message);
+      throw e;
+    }
+  };
+  const taken = new Set<string>();
+  for (const f of files) {
+    const where = relative(process.cwd(), f.file);
+    for (const l of parse(() => parseYarn(f.text, where)).flatMap((n) => yarnLines(n.body))) if (l.id !== undefined) taken.add(l.id);
+  }
+  const changed: { file: string; added: string[] }[] = [];
+  for (const f of files) {
+    const where = relative(process.cwd(), f.file);
+    const { source, added } = parse(() => tagLines(f.text, f.room, taken, where));
+    if (!added.length) continue;
+    writeFileSync(f.file, source);
+    changed.push({ file: f.file, added });
+  }
+  return changed;
+}

package/tools/game/voices.d.ts

@@ -0,0 +1,37 @@
+import type { SpokenLine } from "../../packages/content/src/index.ts";
+/**
+ * voices/lines.json: the script, for a recording session or a TTS run. One entry per line
+ * with an id, with what's needed to say it (who, what, the line before) and whether
+ * voices/<id>.wav exists and was recorded for the line as it is now. The build keeps it
+ * up to date, as it does flags.yaml.
+ */
+export interface ScriptLine {
+    id: string;
+    room: number;
+    speaker: string;
+    text: string;
+    node: string;
+    before?: {
+        speaker: string;
+        text: string;
+    };
+    /** file:line in the game's folder (rooms/1.yarn:4). */
+    where: string;
+    /** missing: no voices/<id>.wav. recorded: there is, for this text. changed: the text has changed since. */
+    recording: "missing" | "recorded" | "changed";
+    /** What the recording was made for: hashes of the line's text then, and of the WAV file. */
+    recorded?: {
+        text: string;
+        wav: string;
+    };
+}
+/** The script as it was last written, by id; empty if there's none. */
+export declare function readLineScript(dir: string): Map<string, ScriptLine>;
+/**
+ * The script for the game's lines now. A recording keeps the text it was made for from the
+ * last script; one not seen before, or a WAV that has changed (recorded again), is taken to
+ * be for the text as it is now.
+ */
+export declare function lineScript(dir: string, rooms: Map<number, SpokenLine[]>): ScriptLine[];
+/** Writes voices/lines.json if it has changed. */
+export declare function writeLineScript(dir: string, script: ScriptLine[]): void;

package/tools/game/voices.js

@@ -0,0 +1,44 @@
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join, relative, resolve } from "node:path";
+const hash = (data) => createHash("sha256").update(data).digest("hex").slice(0, 12);
+/** The script as it was last written, by id; empty if there's none. */
+export function readLineScript(dir) {
+    const file = join(dir, "voices/lines.json");
+    if (!existsSync(file))
+        return new Map();
+    const { lines } = JSON.parse(readFileSync(file, "utf8"));
+    return new Map(lines.map((l) => [l.id, l]));
+}
+/**
+ * The script for the game's lines now. A recording keeps the text it was made for from the
+ * last script; one not seen before, or a WAV that has changed (recorded again), is taken to
+ * be for the text as it is now.
+ */
+export function lineScript(dir, rooms) {
+    const previous = readLineScript(dir);
+    // Lines know where they are from the working directory; the script, from the game's.
+    const inGame = (where) => where.replace(/^(.*)(:\d+)$/, (_, file, line) => `${relative(dir, resolve(file))}${line}`);
+    return [...rooms].sort(([a], [b]) => a - b).flatMap(([room, lines]) => lines.flatMap((l) => {
+        if (l.id === undefined)
+            return [];
+        const entry = {
+            id: l.id, room, speaker: l.speaker, text: l.text, node: l.node, ...(l.before ? { before: l.before } : {}), where: inGame(l.where), recording: "missing",
+        };
+        const wavFile = join(dir, "voices", `${l.id}.wav`);
+        if (existsSync(wavFile)) {
+            const wav = hash(readFileSync(wavFile));
+            const old = previous.get(l.id)?.recorded;
+            entry.recorded = old?.wav === wav ? old : { text: hash(l.text), wav };
+            entry.recording = entry.recorded.text === hash(l.text) ? "recorded" : "changed";
+        }
+        return [entry];
+    }));
+}
+/** Writes voices/lines.json if it has changed. */
+export function writeLineScript(dir, script) {
+    const file = join(dir, "voices/lines.json");
+    const text = `${JSON.stringify({ lines: script }, null, 2)}\n`;
+    if (!existsSync(file) || readFileSync(file, "utf8") !== text)
+        writeFileSync(file, text);
+}

package/tools/game/voices.ts

@@ -0,0 +1,67 @@
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join, relative, resolve } from "node:path";
+import type { SpokenLine } from "../../packages/content/src/index.ts";
+
+/**
+ * voices/lines.json: the script, for a recording session or a TTS run. One entry per line
+ * with an id, with what's needed to say it (who, what, the line before) and whether
+ * voices/<id>.wav exists and was recorded for the line as it is now. The build keeps it
+ * up to date, as it does flags.yaml.
+ */
+export interface ScriptLine {
+  id: string;
+  room: number;
+  speaker: string;
+  text: string;
+  node: string;
+  before?: { speaker: string; text: string };
+  /** file:line in the game's folder (rooms/1.yarn:4). */
+  where: string;
+  /** missing: no voices/<id>.wav. recorded: there is, for this text. changed: the text has changed since. */
+  recording: "missing" | "recorded" | "changed";
+  /** What the recording was made for: hashes of the line's text then, and of the WAV file. */
+  recorded?: { text: string; wav: string };
+}
+
+const hash = (data: string | Uint8Array) => createHash("sha256").update(data).digest("hex").slice(0, 12);
+
+/** The script as it was last written, by id; empty if there's none. */
+export function readLineScript(dir: string): Map<string, ScriptLine> {
+  const file = join(dir, "voices/lines.json");
+  if (!existsSync(file)) return new Map();
+  const { lines } = JSON.parse(readFileSync(file, "utf8")) as { lines: ScriptLine[] };
+  return new Map(lines.map((l) => [l.id, l]));
+}
+
+/**
+ * The script for the game's lines now. A recording keeps the text it was made for from the
+ * last script; one not seen before, or a WAV that has changed (recorded again), is taken to
+ * be for the text as it is now.
+ */
+export function lineScript(dir: string, rooms: Map<number, SpokenLine[]>): ScriptLine[] {
+  const previous = readLineScript(dir);
+  // Lines know where they are from the working directory; the script, from the game's.
+  const inGame = (where: string) => where.replace(/^(.*)(:\d+)$/, (_, file: string, line: string) => `${relative(dir, resolve(file))}${line}`);
+  return [...rooms].sort(([a], [b]) => a - b).flatMap(([room, lines]) => lines.flatMap((l): ScriptLine[] => {
+    if (l.id === undefined) return [];
+    const entry: ScriptLine = {
+      id: l.id, room, speaker: l.speaker, text: l.text, node: l.node, ...(l.before ? { before: l.before } : {}), where: inGame(l.where), recording: "missing",
+    };
+    const wavFile = join(dir, "voices", `${l.id}.wav`);
+    if (existsSync(wavFile)) {
+      const wav = hash(readFileSync(wavFile));
+      const old = previous.get(l.id)?.recorded;
+      entry.recorded = old?.wav === wav ? old : { text: hash(l.text), wav };
+      entry.recording = entry.recorded.text === hash(l.text) ? "recorded" : "changed";
+    }
+    return [entry];
+  }));
+}
+
+/** Writes voices/lines.json if it has changed. */
+export function writeLineScript(dir: string, script: ScriptLine[]): void {
+  const file = join(dir, "voices/lines.json");
+  const text = `${JSON.stringify({ lines: script }, null, 2)}\n`;
+  if (!existsSync(file) || readFileSync(file, "utf8") !== text) writeFileSync(file, text);
+}