sci2-ts 0.8.2 → 0.10.0

package/packages/content/src/room.ts

@@ -7,7 +7,8 @@ import { parseYarn, type YarnChoice, type YarnCommand, type YarnExpr, type YarnI
  * (.sca) and message text (.msg), the formats tools/mod-build.ts already builds from.
  *
  *   room: 701
- *   hero: { at: [36, 152], enterTo: [110, 160], scale: { front: 100, back: 70, frontY: 186, backY: 122 } }
+ *   hero: { at: [36, 152], enterTo: [110, 160] }
+ *   perspective: { horizon: 72, fullSize: 176 }
  *   walkable: [[28, 152], [60, 135], ...]
  *   features:
  *     pods: { rect: [236, 14, 310, 94] }
@@ -31,9 +32,17 @@ export interface RoomSpec {
     at?: Point;
     /** Walk here on arrival (hands off until there). */
     enterTo?: Point;
-    /** Perspective: `front`% at y `frontY`, `back`% at y `backY`. */
+    /** Perspective for the hero alone: `front`% at y `frontY`, `back`% at y `backY` (perspective: is simpler). */
     scale?: { front: number; back: number; frontY: number; backY: number };
   };
+  /**
+   * The picture's camera, for sizing people by where they stand: the horizon (the y the
+   * floor's lines meet at), and the y where a figure's feet are when it's drawn at full
+   * size. A figure's height is in proportion to how far below the horizon it stands, so it
+   * shrinks towards the back and grows past fullSize at the front. The hero and props that
+   * move are sized as they go; a still prop only with scale: true.
+   */
+  perspective?: { horizon: number; fullSize: number };
   /** The floor: a polygon the hero stays inside. */
   walkable?: Point[];
   /** Polygons the hero walks around. */
@@ -87,6 +96,11 @@ interface PropSpec {
   sightAngle?: number;
   /** A Script class of the game's: an instance of it runs on the prop (ambient behaviour). */
   script?: string;
+  /**
+   * Sized by the room's perspective: by default a prop that moves is and a still one
+   * (drawn to fit its place, like someone in a chair) isn't.
+   */
+  scale?: boolean;
 }
 
 export interface CompiledRoom {
@@ -99,6 +113,30 @@ export interface CompiledRoom {
   roomTalkers: boolean;
   /** Yarn variables ($name) used: each is a flag, numbered by `options.flag`. */
   flags: string[];
+  /** The spoken lines (not menu labels), with their message keys today. */
+  lines: SpokenLine[];
+}
+
+/**
+ * A line someone says. Its message key (noun, verb, cond, seq) is positional and changes
+ * when lines or things are added before it; its id (#line:) doesn't, so recordings use that.
+ */
+export interface SpokenLine {
+  id?: string;
+  noun: number;
+  verb: number;
+  cond: number;
+  seq: number;
+  talker: number;
+  /** As written in the Yarn (Narrator when it has none). */
+  speaker: string;
+  text: string;
+  /** The Yarn node it's in (and for a topic's answer, the topic). */
+  node: string;
+  /** What's said just before it in the same node, if anything: context for whoever records it. */
+  before?: { speaker: string; text: string };
+  /** file:line in the Yarn. */
+  where: string;
 }
 
 export interface CompileOptions {
@@ -157,7 +195,7 @@ class SpecChecker {
   check(): void {
     const s = this.spec as unknown as Record<string, unknown>;
     if (!s || typeof s !== "object") this.fail([], "expected a mapping (room: ..., features: ...)");
-    this.known(s, [], ["room", "picture", "music", "hero", "walkable", "obstacles", "features", "exits", "props", "characters", "properties"]);
+    this.known(s, [], ["room", "picture", "music", "hero", "perspective", "walkable", "obstacles", "features", "exits", "props", "characters", "properties"]);
     this.int(s.room, ["room"], 0, 65535);
     if (s.picture !== undefined) this.int(s.picture, ["picture"], 0, 65535);
     if (s.music !== undefined) this.int(s.music, ["music"], 0, 65535);
@@ -172,6 +210,13 @@ class SpecChecker {
         for (const k of ["front", "back", "frontY", "backY"]) this.int(sc[k], ["hero", "scale", k], 0, 1000);
       }
     }
+    if (s.perspective !== undefined) {
+      const pv = this.map(s.perspective, ["perspective"]);
+      this.known(pv, ["perspective"], ["horizon", "fullSize"]);
+      this.int(pv.horizon, ["perspective", "horizon"], -1000, 199);
+      this.int(pv.fullSize, ["perspective", "fullSize"], 0, 1000);
+      if ((pv.fullSize as number) <= (pv.horizon as number)) this.fail(["perspective", "fullSize"], "must be below the horizon (a bigger y)");
+    }
     if (s.walkable !== undefined) this.polygon(s.walkable, ["walkable"]);
     if (s.obstacles !== undefined) {
       if (!Array.isArray(s.obstacles)) this.fail(["obstacles"], "expected a list of polygons");
@@ -188,7 +233,9 @@ class SpecChecker {
         names.add(name);
         const t = this.map(value, path);
         if (group === "props") {
-          this.known(t, path, ["view", "at", "loop", "cel", "cycle", "sightAngle", "moves", "script"]);
+          this.known(t, path, ["view", "at", "loop", "cel", "cycle", "sightAngle", "moves", "script", "scale"]);
+          if (t.scale !== undefined && typeof t.scale !== "boolean") this.fail([...path, "scale"], "expected true or false");
+          if (t.scale === true && s.perspective === undefined) this.fail([...path, "scale"], "the room has no perspective: to size it by");
           if (t.script !== undefined && (typeof t.script !== "string" || !/^[A-Z][A-Za-z0-9]*$/.test(t.script))) this.fail([...path, "script"], "expected a class name, e.g. Scurry");
           if (t.moves !== undefined && typeof t.moves !== "boolean") this.fail([...path, "moves"], "expected true or false");
           this.int(t.view, [...path, "view"], 0, 65535);
@@ -265,6 +312,7 @@ type Val = number | { obj: string } | { cls: string } | "self" | { code: string[
 /** Who receives a send. */
 type To = { global: number } | { obj: string } | { cls: string } | "self" | { superOf: string };
 
+const SCREEN_BOTTOM = 200;
 const num = (n: number) => (n < 0 ? `-$${(-n).toString(16)}` : String(n));
 
 function pushVal(v: Val): string[] {
@@ -300,6 +348,7 @@ interface Message {
   cond: number;
   seq: number;
   talker: number;
+  speaker: string;
   text: string;
   label: string;
 }
@@ -347,6 +396,7 @@ class RoomCompiler {
   readonly name: string;
   readonly nouns = new Map<string, number>();
   readonly messages: Message[] = [];
+  readonly lines: SpokenLine[] = [];
   readonly instances: string[] = [];
   readonly code: string[] = [];
   readonly strings: string[] = [];
@@ -425,7 +475,7 @@ class RoomCompiler {
 
     return {
       number: spec.room, sca: this.assembly(), msg: this.messageText(), roomTalkers: characters.length > 0,
-      flags: [...this.flagsUsed].sort(),
+      flags: [...this.flagsUsed].sort(), lines: this.lines,
     };
   }
 
@@ -492,7 +542,7 @@ class RoomCompiler {
         if (!c.body.length) fail(`choice "${c.text}" needs at least one line under it`, c.line);
         const topic = k + 1;
         const label = `${node.title}: ${c.text}`;
-        this.message(conv.rootNoun, tv, topic, 1, { kind: "line", speaker: "Hero", text: c.text, line: c.line }, label);
+        this.message(conv.rootNoun, tv, topic, 1, { kind: "line", speaker: "Hero", text: c.text, line: c.line }, label, false);
         if (c.when) conv.conditional.push({ topic, when: c.when, where: `${this.yarnFile}:${c.line}` });
         if (c.body.every((x) => x.kind === "line")) {
           c.body.forEach((l, j) => this.message(conv.sayNoun, tv, topic, j + 1, l as YarnLine, label));
@@ -794,9 +844,19 @@ class RoomCompiler {
 
   // --- Objects ---
 
-  private message(noun: number, verb: number, cond: number, seq: number, l: YarnLine, label: string): void {
+  /** A message; `spoken` is false for a topic menu's labels, which nobody says. */
+  private message(noun: number, verb: number, cond: number, seq: number, l: YarnLine, label: string, spoken = true): void {
     const where = `${this.yarnFile}:${l.line}`;
-    this.messages.push({ noun, verb, cond, seq, talker: this.talkerOf(l.speaker, where), text: plainText(l.text, where), label });
+    const prev = this.messages.at(-1);
+    const m: Message = { noun, verb, cond, seq, talker: this.talkerOf(l.speaker, where), speaker: l.speaker ?? "Narrator", text: plainText(l.text, where), label };
+    this.messages.push(m);
+    if (!spoken) return;
+    const twice = l.id !== undefined && this.lines.find((x) => x.id === l.id);
+    if (twice) throw new ContentError(`${where}: #line:${l.id} is already the id of ${twice.where}`);
+    this.lines.push({
+      ...(l.id === undefined ? {} : { id: l.id }), noun, verb, cond, seq, talker: m.talker, speaker: m.speaker, text: m.text, node: label,
+      ...(prev?.label === label ? { before: { speaker: prev.speaker, text: prev.text } } : {}), where,
+    });
   }
 
   private talkerOf(speaker: string | undefined, where: string): number {
@@ -836,13 +896,18 @@ class RoomCompiler {
     const egoCalls: [string, Val[]][] = [["init", []]];
     if (hero?.at) egoCalls.push(["x", [hero.at[0]]], ["y", [hero.at[1]]]);
     egoCalls.push(["normalize", []]);
+    // Each room sizes the hero its own way, or not at all.
+    const perspective = this.perspective();
     if (hero?.scale) egoCalls.push(["setScaler", [{ cls: "Scaler" }, hero.scale.front, hero.scale.back, hero.scale.frontY, hero.scale.backY]]);
+    else if (perspective) egoCalls.push(["setScaler", [{ cls: "Scaler" }, ...perspective]]);
+    else egoCalls.push(["setScaler", [0]]);
     c.push(...send({ global: target.globals.ego }, egoCalls));
     if (spec.music !== undefined) c.push(...this.playMusic(spec.music));
     for (const name of [...Object.keys(spec.features ?? {}), ...Object.keys(spec.exits ?? {})]) c.push(...send({ obj: name }, [["init", []]]));
     for (const [name, p] of Object.entries(spec.props ?? {})) {
       c.push(...send({ obj: name }, [
         ["init", []],
+        ...(perspective && p.moves && p.scale !== false ? [["setScaler", [{ cls: "Scaler" }, ...perspective]] as [string, Val[]]] : []),
         ...(p.cycle === "forward" ? [["setCycle", [{ cls: this.target.forwardCycle }]] as [string, Val[]]] : []),
         // A new instance of the game's Script class, running on the prop.
         ...(p.script ? [["setScript", [{ code: ["pushi #new", "push0", `class ${p.script}`, "send 4"] }]] as [string, Val[]]] : []),
@@ -974,11 +1039,39 @@ class RoomCompiler {
     if (cases.length) this.doVerb(name, "Feature", cases);
   }
 
+  /**
+   * The room's perspective as Scaler arguments (front, back, frontY, backY): sizes at the
+   * nearest and farthest places anyone stands (the floor, and where the hero and props that
+   * move start). Size is a straight line in y, so the Scaler's in-between is exact; keeping
+   * to that range keeps its 16-bit arithmetic from overflowing.
+   */
+  private perspective(): [number, number, number, number] | undefined {
+    const pv = this.spec.perspective;
+    if (!pv) return undefined;
+    const ys = [
+      ...(this.spec.walkable ?? []).map((p) => p[1]),
+      ...Object.values(this.spec.props ?? {}).filter((p) => p.moves).map((p) => p.at[1]),
+      ...[this.spec.hero?.at, this.spec.hero?.enterTo].flatMap((p) => (p ? [p[1]] : [])),
+    ].filter((y) => y > pv.horizon);
+    const backY = ys.length ? Math.min(...ys) : pv.horizon + 1, frontY = ys.length ? Math.max(...ys) : SCREEN_BOTTOM - 1;
+    const size = (y: number) => Math.round(((y - pv.horizon) / (pv.fullSize - pv.horizon)) * 100);
+    const [front, back] = [size(frontY), size(backY)];
+    // Scaler works out (front - back) * (y - backY) on the way.
+    if ((front - back) * (frontY - backY) > 32767) throw new ContentError(`room ${this.spec.room}: perspective: sizes from ${back}% to ${front}% over ${frontY - backY} lines are too much for the Scaler`);
+    return [front, back, Math.max(frontY, backY + 1), backY];
+  }
+
   private prop(name: string, p: PropSpec): void {
     const cases = this.scriptedVerbs.get(name) ?? [];
+    // A still prop is sized once, for where it is.
+    const pv = this.spec.perspective;
+    const fixed = pv && p.scale === true && !p.moves ? Math.round(((p.at[1] - pv.horizon) / (pv.fullSize - pv.horizon)) * 128) : undefined;
     this.instance(
       name, p.moves ? "Actor" : "Prop",
-      { noun: this.nouns.get(name)!, modNum: -1, sightAngle: p.sightAngle ?? 180, x: p.at[0], y: p.at[1], view: p.view, loop: p.loop ?? 0, cel: p.cel ?? 0 },
+      {
+        noun: this.nouns.get(name)!, modNum: -1, sightAngle: p.sightAngle ?? 180, x: p.at[0], y: p.at[1], view: p.view, loop: p.loop ?? 0, cel: p.cel ?? 0,
+        ...(fixed === undefined ? {} : { scaleSignal: 1, scaleX: fixed, scaleY: fixed }),
+      },
       cases.length ? ["doVerb"] : [],
     );
     if (cases.length) this.doVerb(name, p.moves ? "Actor" : "Prop", cases);

package/packages/content/src/yarn.d.ts

@@ -40,6 +40,8 @@ export interface YarnLine {
     kind: "line";
     speaker?: string;
     text: string;
+    /** Its #line: tag, which stays with it when lines around it change (recordings use it). */
+    id?: string;
     line: number;
 }
 export interface YarnChoice {
@@ -88,3 +90,14 @@ export declare class YarnError extends Error {
 export declare function parseYarn(source: string, file?: string): YarnNode[];
 /** `$a and not ($b or $c == false)`: Yarn's boolean operators, both spellings. */
 export declare function parseExpr(source: string, fail: (why: string) => never): YarnExpr;
+/** Every line in some items, including those under choices and in <<if>> branches. */
+export declare function yarnLines(items: YarnItem[]): YarnLine[];
+/**
+ * Gives every line without a #line: tag one, `<prefix>-001` and on, skipping ids already
+ * `taken` (pass the game's, so they're unique across rooms). Lines that have an id keep it,
+ * and nothing else in the file changes.
+ */
+export declare function tagLines(source: string, prefix: string, taken: Set<string>, file?: string): {
+    source: string;
+    added: string[];
+};

package/packages/content/src/yarn.js

@@ -8,7 +8,18 @@ export class YarnError extends Error {
     }
 }
 /** Trailing #tags (Yarn's line ids and metadata) don't belong to the text. */
-const stripTags = (s) => s.replace(/(\s+#[^\s#]+)+\s*$/, "");
+const TAGS = /(\s+#[^\s#]+)+\s*$/;
+const stripTags = (s) => s.replace(TAGS, "");
+/** The id in a line's #line: tag, if it has one. */
+function lineId(s, fail) {
+    const tags = TAGS.exec(s)?.[0].trim().split(/\s+/) ?? [];
+    const ids = tags.filter((t) => t.startsWith("#line:")).map((t) => t.slice(6));
+    if (ids.length > 1)
+        fail("a line can only have one #line: tag");
+    if (ids[0] !== undefined && !/^[A-Za-z0-9_-]+$/.test(ids[0]))
+        fail(`"#line:${ids[0]}": a line id is letters, digits, - and _`);
+    return ids[0];
+}
 const indentOf = (s) => /^[ \t]*/.exec(s)[0].replace(/\t/g, "    ").length;
 export function parseYarn(source, file = "<yarn>") {
     const nodes = [];
@@ -131,8 +142,10 @@ class BodyParser {
             if (text.startsWith("<<"))
                 this.fail(line, `expected <<command ...>>, got "${text}"`);
             const clean = stripTags(text);
+            const id = lineId(text, (why) => this.fail(line, why));
             const m = /^([A-Za-z][\w ]*?)\s*:\s+(.+)$/.exec(clean);
-            items.push(m ? { kind: "line", speaker: m[1], text: m[2], line } : { kind: "line", text: clean, line });
+            const said = m ? { speaker: m[1], text: m[2] } : { text: clean };
+            items.push({ kind: "line", ...said, ...(id === undefined ? {} : { id }), line });
         }
         return items;
     }
@@ -212,3 +225,40 @@ export function parseExpr(source, fail) {
         fail(`unexpected "${tokens[p]}" in "${source}"`);
     return e;
 }
+/** Every line in some items, including those under choices and in <<if>> branches. */
+export function yarnLines(items) {
+    return items.flatMap((x) => x.kind === "line" ? [x]
+        : x.kind === "choice" ? yarnLines(x.body)
+            : x.kind === "if" ? x.branches.flatMap((b) => yarnLines(b.body))
+                : []);
+}
+/**
+ * Gives every line without a #line: tag one, `<prefix>-001` and on, skipping ids already
+ * `taken` (pass the game's, so they're unique across rooms). Lines that have an id keep it,
+ * and nothing else in the file changes.
+ */
+export function tagLines(source, prefix, taken, file = "<yarn>") {
+    const lines = parseYarn(source, file).flatMap((n) => yarnLines(n.body));
+    for (const l of lines)
+        if (l.id !== undefined)
+            taken.add(l.id);
+    const untagged = new Set(lines.filter((l) => l.id === undefined).map((l) => l.line));
+    const added = [];
+    let n = 0;
+    const next = () => {
+        let id;
+        do
+            id = `${prefix}-${String(++n).padStart(3, "0")}`;
+        while (taken.has(id));
+        taken.add(id);
+        added.push(id);
+        return id;
+    };
+    const out = source.split("\n").map((text, i) => {
+        if (!untagged.has(i + 1))
+            return text;
+        const cr = text.endsWith("\r") ? "\r" : "";
+        return `${text.slice(0, text.length - cr.length).trimEnd()} #line:${next()}${cr}`;
+    });
+    return { source: out.join("\n"), added };
+}

package/packages/content/src/yarn.ts

@@ -43,6 +43,8 @@ export interface YarnLine {
   kind: "line";
   speaker?: string;
   text: string;
+  /** Its #line: tag, which stays with it when lines around it change (recordings use it). */
+  id?: string;
   line: number;
 }
 
@@ -83,7 +85,16 @@ export class YarnError extends Error {
 }
 
 /** Trailing #tags (Yarn's line ids and metadata) don't belong to the text. */
-const stripTags = (s: string) => s.replace(/(\s+#[^\s#]+)+\s*$/, "");
+const TAGS = /(\s+#[^\s#]+)+\s*$/;
+const stripTags = (s: string) => s.replace(TAGS, "");
+/** The id in a line's #line: tag, if it has one. */
+function lineId(s: string, fail: (why: string) => never): string | undefined {
+  const tags = TAGS.exec(s)?.[0].trim().split(/\s+/) ?? [];
+  const ids = tags.filter((t) => t.startsWith("#line:")).map((t) => t.slice(6));
+  if (ids.length > 1) fail("a line can only have one #line: tag");
+  if (ids[0] !== undefined && !/^[A-Za-z0-9_-]+$/.test(ids[0])) fail(`"#line:${ids[0]}": a line id is letters, digits, - and _`);
+  return ids[0];
+}
 const indentOf = (s: string) => /^[ \t]*/.exec(s)![0].replace(/\t/g, "    ").length;
 
 export function parseYarn(source: string, file = "<yarn>"): YarnNode[] {
@@ -189,8 +200,10 @@ class BodyParser {
       }
       if (text.startsWith("<<")) this.fail(line, `expected <<command ...>>, got "${text}"`);
       const clean = stripTags(text);
+      const id = lineId(text, (why) => this.fail(line, why));
       const m = /^([A-Za-z][\w ]*?)\s*:\s+(.+)$/.exec(clean);
-      items.push(m ? { kind: "line", speaker: m[1]!, text: m[2]!, line } : { kind: "line", text: clean, line });
+      const said = m ? { speaker: m[1]!, text: m[2]! } : { text: clean };
+      items.push({ kind: "line", ...said, ...(id === undefined ? {} : { id }), line });
     }
     return items;
   }
@@ -259,3 +272,39 @@ export function parseExpr(source: string, fail: (why: string) => never): YarnExp
   if (p < tokens.length) fail(`unexpected "${tokens[p]}" in "${source}"`);
   return e;
 }
+
+/** Every line in some items, including those under choices and in <<if>> branches. */
+export function yarnLines(items: YarnItem[]): YarnLine[] {
+  return items.flatMap((x) =>
+    x.kind === "line" ? [x]
+    : x.kind === "choice" ? yarnLines(x.body)
+    : x.kind === "if" ? x.branches.flatMap((b) => yarnLines(b.body))
+    : []);
+}
+
+/**
+ * Gives every line without a #line: tag one, `<prefix>-001` and on, skipping ids already
+ * `taken` (pass the game's, so they're unique across rooms). Lines that have an id keep it,
+ * and nothing else in the file changes.
+ */
+export function tagLines(source: string, prefix: string, taken: Set<string>, file = "<yarn>"): { source: string; added: string[] } {
+  const lines = parseYarn(source, file).flatMap((n) => yarnLines(n.body));
+  for (const l of lines) if (l.id !== undefined) taken.add(l.id);
+  const untagged = new Set(lines.filter((l) => l.id === undefined).map((l) => l.line));
+  const added: string[] = [];
+  let n = 0;
+  const next = () => {
+    let id: string;
+    do id = `${prefix}-${String(++n).padStart(3, "0")}`;
+    while (taken.has(id));
+    taken.add(id);
+    added.push(id);
+    return id;
+  };
+  const out = source.split("\n").map((text, i) => {
+    if (!untagged.has(i + 1)) return text;
+    const cr = text.endsWith("\r") ? "\r" : "";
+    return `${text.slice(0, text.length - cr.length).trimEnd()} #line:${next()}${cr}`;
+  });
+  return { source: out.join("\n"), added };
+}

package/packages/sci/src/audio/sol.d.ts

@@ -29,4 +29,6 @@ export interface SolHeader {
 export declare function parseSolHeader(data: Uint8Array): SolHeader | undefined;
 /** Samples a SOL clip of `dataBytes` bytes decodes to, per channel. */
 export declare function solSampleCount(flags: number, dataBytes: number): number;
+/** The steps of 16-bit DPCM, by the low seven bits of a byte (bit 7 makes it a step down). */
+export declare const DPCM16: number[];
 export declare function decodeSol(data: Uint8Array): SolAudio | undefined;

package/packages/sci/src/audio/sol.js

@@ -17,7 +17,8 @@ export function solSampleCount(flags, dataBytes) {
     const bytesPerSample = flags & SolFlag.Compressed ? (flags & SolFlag.Bits16 ? 1 : 0.5) : flags & SolFlag.Bits16 ? 2 : 1;
     return Math.floor(dataBytes / bytesPerSample / channels);
 }
-const DPCM16 = [
+/** The steps of 16-bit DPCM, by the low seven bits of a byte (bit 7 makes it a step down). */
+export const DPCM16 = [
     0x0000, 0x0008, 0x0010, 0x0020, 0x0030, 0x0040, 0x0050, 0x0060, 0x0070, 0x0080, 0x0090, 0x00a0, 0x00b0, 0x00c0,
     0x00d0, 0x00e0, 0x00f0, 0x0100, 0x0110, 0x0120, 0x0130, 0x0140, 0x0150, 0x0160, 0x0170, 0x0180, 0x0190, 0x01a0,
     0x01b0, 0x01c0, 0x01d0, 0x01e0, 0x01f0, 0x0200, 0x0208, 0x0210, 0x0218, 0x0220, 0x0228, 0x0230, 0x0238, 0x0240,

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

@@ -43,7 +43,8 @@ export function solSampleCount(flags: number, dataBytes: number): number {
   return Math.floor(dataBytes / bytesPerSample / channels);
 }
 
-const DPCM16 = [
+/** The steps of 16-bit DPCM, by the low seven bits of a byte (bit 7 makes it a step down). */
+export const DPCM16 = [
   0x0000, 0x0008, 0x0010, 0x0020, 0x0030, 0x0040, 0x0050, 0x0060, 0x0070, 0x0080, 0x0090, 0x00a0, 0x00b0, 0x00c0,
   0x00d0, 0x00e0, 0x00f0, 0x0100, 0x0110, 0x0120, 0x0130, 0x0140, 0x0150, 0x0160, 0x0170, 0x0180, 0x0190, 0x01a0,
   0x01b0, 0x01c0, 0x01d0, 0x01e0, 0x01f0, 0x0200, 0x0208, 0x0210, 0x0218, 0x0220, 0x0228, 0x0230, 0x0238, 0x0240,

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

@@ -20,8 +20,43 @@ export interface SoundSpec {
     }[];
 }
 export declare function writeSound(spec: SoundSpec): Uint8Array;
-/** A SOL clip: 16-bit samples at `rate`, uncompressed. */
-export declare function writeSol(samples: Int16Array, rate: number): Uint8Array;
+/**
+ * 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 declare function writeSol(samples: Int16Array, rate: number, compressed?: boolean): Uint8Array;
+/**
+ * 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 declare function encodeDpcm16(samples: Int16Array): Uint8Array;
+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 declare function writeSpeech(clips: readonly SpeechClip[]): {
+    aud: Uint8Array;
+    maps: {
+        module: number;
+        data: Uint8Array;
+    }[];
+};
 /**
  * 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/audio/write.js

@@ -1,4 +1,4 @@
-import { SolFlag } from "./sol.js";
+import { DPCM16, SolFlag } from "./sol.js";
 const dataBytes = (status) => ((status & 0xf0) === 0xc0 || (status & 0xf0) === 0xd0 ? 1 : 2);
 /** A channel stream: channel, voices, then delta-timed events with running status, then 0xFC. */
 function channelStream(c) {
@@ -51,19 +51,108 @@ export function writeSound(spec) {
     table.push(0xff);
     return Uint8Array.from([...header, ...table, ...body]);
 }
-/** A SOL clip: 16-bit samples at `rate`, uncompressed. */
-export function writeSol(samples, rate) {
-    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, rate, compressed = false) {
+    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) {
+    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) => 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;
 }
+/**
+ * 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) {
+    const key = (c) => ((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) => {
+            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]])
+                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.