sci2-ts 0.0.0-stage → 0.2.2

package/tools/game/audio.js

@@ -0,0 +1,143 @@
+import { SoundDevice } from "../../packages/sci/src/index.js";
+/**
+ * Music and sound for games, from the files people make them with: Standard MIDI Files
+ * (.mid, from any sequencer) become sound resources; WAV files (PCM) become digital effects.
+ */
+export class AudioFileError extends Error {
+}
+const CONTROL_CHANNEL = 15;
+/**
+ * A Standard MIDI File (format 0 or 1) as a sound resource for General MIDI: its tempo
+ * changes turned into SCI's 1/60 s ticks, a channel stream per MIDI channel it uses. SCI
+ * keeps channel 16 (15 counting from 0) for signals to the scripts, so music there moves to
+ * a free channel.
+ */
+export function readMidiFile(data) {
+    const v = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    const tag = (at) => String.fromCharCode(...data.subarray(at, at + 4));
+    if (tag(0) !== "MThd")
+        throw new AudioFileError("not a MIDI file (no MThd)");
+    const format = v.getUint16(8), trackCount = v.getUint16(10), division = v.getUint16(12);
+    if (format > 1)
+        throw new AudioFileError(`MIDI format ${format} isn't supported (save as format 0 or 1)`);
+    if (division & 0x8000)
+        throw new AudioFileError("SMPTE-timed MIDI files aren't supported (use ticks per quarter note)");
+    const events = [];
+    const tempos = [];
+    let pos = 8 + v.getUint32(4), order = 0;
+    for (let t = 0; t < trackCount; t++) {
+        if (tag(pos) !== "MTrk")
+            throw new AudioFileError(`track ${t + 1}: expected MTrk`);
+        const end = pos + 8 + v.getUint32(pos + 4);
+        pos += 8;
+        let tick = 0, running = 0;
+        const varLen = () => {
+            let n = 0, b;
+            do {
+                b = data[pos++];
+                n = (n << 7) | (b & 0x7f);
+            } while (b & 0x80 && pos < end);
+            return n;
+        };
+        while (pos < end) {
+            tick += varLen();
+            let status = data[pos];
+            if (status & 0x80)
+                pos++;
+            else if (running)
+                status = running;
+            else
+                throw new AudioFileError(`track ${t + 1}: data before any status byte`);
+            if (status === 0xff) {
+                const type = data[pos++], len = varLen();
+                if (type === 0x51 && len === 3)
+                    tempos.push({ tick, usPerQuarter: (data[pos] << 16) | (data[pos + 1] << 8) | data[pos + 2] });
+                pos += len;
+                if (type === 0x2f)
+                    break;
+                continue;
+            }
+            if (status === 0xf0 || status === 0xf7) {
+                pos += varLen();
+                continue;
+            }
+            running = status;
+            const n = (status & 0xf0) === 0xc0 || (status & 0xf0) === 0xd0 ? 1 : 2;
+            events.push({ tick, bytes: [status, ...data.subarray(pos, pos + n)], order: order++ });
+            pos += n;
+        }
+        pos = end;
+    }
+    // MIDI ticks to seconds, through the tempo changes (120 bpm until the first).
+    tempos.sort((a, b) => a.tick - b.tick);
+    const toSciTicks = (tick) => {
+        let seconds = 0, last = 0, us = 500_000;
+        for (const t of tempos) {
+            if (t.tick >= tick)
+                break;
+            seconds += ((t.tick - last) * us) / division / 1e6;
+            last = t.tick;
+            us = t.usPerQuarter;
+        }
+        seconds += ((tick - last) * us) / division / 1e6;
+        return Math.round(seconds * 60);
+    };
+    const byChannel = new Map();
+    for (const e of events.sort((a, b) => a.tick - b.tick || a.order - b.order)) {
+        const channel = e.bytes[0] & 0x0f;
+        if (!byChannel.has(channel))
+            byChannel.set(channel, []);
+        byChannel.get(channel).push({ tick: toSciTicks(e.tick), bytes: e.bytes });
+    }
+    const music = byChannel.get(CONTROL_CHANNEL);
+    if (music) {
+        const free = [...Array(15).keys()].find((c) => !byChannel.has(c));
+        if (free === undefined)
+            throw new AudioFileError("all 16 MIDI channels are used; SCI needs channel 16 for itself");
+        byChannel.delete(CONTROL_CHANNEL);
+        byChannel.set(free, music);
+    }
+    const channels = [...byChannel].sort((a, b) => a[0] - b[0]).map(([midiChannel, evs]) => ({ midiChannel, voices: 1, events: evs }));
+    if (!channels.length)
+        throw new AudioFileError("no notes in this MIDI file");
+    return { tracks: [{ device: SoundDevice.GeneralMidi, channels }] };
+}
+/** A PCM WAV file (8- or 16-bit, mono or stereo) as mono 16-bit samples. */
+export function readWav(data) {
+    const v = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    const tag = (at) => String.fromCharCode(...data.subarray(at, at + 4));
+    if (tag(0) !== "RIFF" || tag(8) !== "WAVE")
+        throw new AudioFileError("not a WAV file");
+    let fmt;
+    for (let pos = 12; pos + 8 <= data.length;) {
+        const id = tag(pos), size = v.getUint32(pos + 4, true), body = pos + 8;
+        if (id === "fmt ") {
+            fmt = { format: v.getUint16(body, true), channels: v.getUint16(body + 2, true), rate: v.getUint32(body + 4, true), bits: v.getUint16(body + 14, true) };
+            if (fmt.format !== 1)
+                throw new AudioFileError(`WAV format ${fmt.format} isn't supported (save as PCM)`);
+            if (fmt.bits !== 8 && fmt.bits !== 16)
+                throw new AudioFileError(`${fmt.bits}-bit WAV isn't supported (8 or 16)`);
+            if (fmt.channels < 1 || fmt.channels > 2)
+                throw new AudioFileError(`${fmt.channels} channels: mono or stereo only`);
+            if (fmt.rate > 65535)
+                throw new AudioFileError(`${fmt.rate} Hz is too high (65,535 at most; 22,050 is plenty)`);
+        }
+        else if (id === "data") {
+            if (!fmt)
+                throw new AudioFileError("WAV data before its format");
+            const bytes = fmt.bits / 8, frames = Math.floor(Math.min(size, data.length - body) / bytes / fmt.channels);
+            const samples = new Int16Array(frames);
+            for (let i = 0; i < frames; i++) {
+                let sum = 0;
+                for (let c = 0; c < fmt.channels; c++) {
+                    const at = body + (i * fmt.channels + c) * bytes;
+                    sum += fmt.bits === 16 ? v.getInt16(at, true) : (data[at] - 128) << 8;
+                }
+                samples[i] = Math.round(sum / fmt.channels);
+            }
+            return { samples, rate: fmt.rate };
+        }
+        pos = body + size + (size & 1);
+    }
+    throw new AudioFileError("WAV file without data");
+}

package/tools/game/audio.ts

@@ -0,0 +1,130 @@
+import { SoundDevice, type MidiEvent, type SoundSpec } from "../../packages/sci/src/index.ts";
+
+/**
+ * Music and sound for games, from the files people make them with: Standard MIDI Files
+ * (.mid, from any sequencer) become sound resources; WAV files (PCM) become digital effects.
+ */
+
+export class AudioFileError extends Error {}
+
+const CONTROL_CHANNEL = 15;
+
+/**
+ * A Standard MIDI File (format 0 or 1) as a sound resource for General MIDI: its tempo
+ * changes turned into SCI's 1/60 s ticks, a channel stream per MIDI channel it uses. SCI
+ * keeps channel 16 (15 counting from 0) for signals to the scripts, so music there moves to
+ * a free channel.
+ */
+export function readMidiFile(data: Uint8Array): SoundSpec {
+  const v = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  const tag = (at: number) => String.fromCharCode(...data.subarray(at, at + 4));
+  if (tag(0) !== "MThd") throw new AudioFileError("not a MIDI file (no MThd)");
+  const format = v.getUint16(8), trackCount = v.getUint16(10), division = v.getUint16(12);
+  if (format > 1) throw new AudioFileError(`MIDI format ${format} isn't supported (save as format 0 or 1)`);
+  if (division & 0x8000) throw new AudioFileError("SMPTE-timed MIDI files aren't supported (use ticks per quarter note)");
+
+  const events: { tick: number; bytes: number[]; order: number }[] = [];
+  const tempos: { tick: number; usPerQuarter: number }[] = [];
+  let pos = 8 + v.getUint32(4), order = 0;
+  for (let t = 0; t < trackCount; t++) {
+    if (tag(pos) !== "MTrk") throw new AudioFileError(`track ${t + 1}: expected MTrk`);
+    const end = pos + 8 + v.getUint32(pos + 4);
+    pos += 8;
+    let tick = 0, running = 0;
+    const varLen = () => {
+      let n = 0, b: number;
+      do {
+        b = data[pos++]!;
+        n = (n << 7) | (b & 0x7f);
+      } while (b & 0x80 && pos < end);
+      return n;
+    };
+    while (pos < end) {
+      tick += varLen();
+      let status = data[pos]!;
+      if (status & 0x80) pos++;
+      else if (running) status = running;
+      else throw new AudioFileError(`track ${t + 1}: data before any status byte`);
+      if (status === 0xff) {
+        const type = data[pos++]!, len = varLen();
+        if (type === 0x51 && len === 3) tempos.push({ tick, usPerQuarter: (data[pos]! << 16) | (data[pos + 1]! << 8) | data[pos + 2]! });
+        pos += len;
+        if (type === 0x2f) break;
+        continue;
+      }
+      if (status === 0xf0 || status === 0xf7) {
+        pos += varLen();
+        continue;
+      }
+      running = status;
+      const n = (status & 0xf0) === 0xc0 || (status & 0xf0) === 0xd0 ? 1 : 2;
+      events.push({ tick, bytes: [status, ...data.subarray(pos, pos + n)], order: order++ });
+      pos += n;
+    }
+    pos = end;
+  }
+
+  // MIDI ticks to seconds, through the tempo changes (120 bpm until the first).
+  tempos.sort((a, b) => a.tick - b.tick);
+  const toSciTicks = (tick: number) => {
+    let seconds = 0, last = 0, us = 500_000;
+    for (const t of tempos) {
+      if (t.tick >= tick) break;
+      seconds += ((t.tick - last) * us) / division / 1e6;
+      last = t.tick;
+      us = t.usPerQuarter;
+    }
+    seconds += ((tick - last) * us) / division / 1e6;
+    return Math.round(seconds * 60);
+  };
+
+  const byChannel = new Map<number, MidiEvent[]>();
+  for (const e of events.sort((a, b) => a.tick - b.tick || a.order - b.order)) {
+    const channel = e.bytes[0]! & 0x0f;
+    if (!byChannel.has(channel)) byChannel.set(channel, []);
+    byChannel.get(channel)!.push({ tick: toSciTicks(e.tick), bytes: e.bytes });
+  }
+  const music = byChannel.get(CONTROL_CHANNEL);
+  if (music) {
+    const free = [...Array(15).keys()].find((c) => !byChannel.has(c));
+    if (free === undefined) throw new AudioFileError("all 16 MIDI channels are used; SCI needs channel 16 for itself");
+    byChannel.delete(CONTROL_CHANNEL);
+    byChannel.set(free, music);
+  }
+  const channels = [...byChannel].sort((a, b) => a[0] - b[0]).map(([midiChannel, evs]) => ({ midiChannel, voices: 1, events: evs }));
+  if (!channels.length) throw new AudioFileError("no notes in this MIDI file");
+  return { tracks: [{ device: SoundDevice.GeneralMidi, channels }] };
+}
+
+/** A PCM WAV file (8- or 16-bit, mono or stereo) as mono 16-bit samples. */
+export function readWav(data: Uint8Array): { samples: Int16Array; rate: number } {
+  const v = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  const tag = (at: number) => String.fromCharCode(...data.subarray(at, at + 4));
+  if (tag(0) !== "RIFF" || tag(8) !== "WAVE") throw new AudioFileError("not a WAV file");
+  let fmt: { format: number; channels: number; rate: number; bits: number } | undefined;
+  for (let pos = 12; pos + 8 <= data.length; ) {
+    const id = tag(pos), size = v.getUint32(pos + 4, true), body = pos + 8;
+    if (id === "fmt ") {
+      fmt = { format: v.getUint16(body, true), channels: v.getUint16(body + 2, true), rate: v.getUint32(body + 4, true), bits: v.getUint16(body + 14, true) };
+      if (fmt.format !== 1) throw new AudioFileError(`WAV format ${fmt.format} isn't supported (save as PCM)`);
+      if (fmt.bits !== 8 && fmt.bits !== 16) throw new AudioFileError(`${fmt.bits}-bit WAV isn't supported (8 or 16)`);
+      if (fmt.channels < 1 || fmt.channels > 2) throw new AudioFileError(`${fmt.channels} channels: mono or stereo only`);
+      if (fmt.rate > 65535) throw new AudioFileError(`${fmt.rate} Hz is too high (65,535 at most; 22,050 is plenty)`);
+    } else if (id === "data") {
+      if (!fmt) throw new AudioFileError("WAV data before its format");
+      const bytes = fmt.bits / 8, frames = Math.floor(Math.min(size, data.length - body) / bytes / fmt.channels);
+      const samples = new Int16Array(frames);
+      for (let i = 0; i < frames; i++) {
+        let sum = 0;
+        for (let c = 0; c < fmt.channels; c++) {
+          const at = body + (i * fmt.channels + c) * bytes;
+          sum += fmt.bits === 16 ? v.getInt16(at, true) : (data[at]! - 128) << 8;
+        }
+        samples[i] = Math.round(sum / fmt.channels);
+      }
+      return { samples, rate: fmt.rate };
+    }
+    pos = body + size + (size & 1);
+  }
+  throw new AudioFileError("WAV file without data");
+}

package/tools/game/build.d.ts

@@ -0,0 +1,46 @@
+import { type ResourceData } from "../../packages/sci/src/index.ts";
+/**
+ * Builds a game from its sources, needing nothing from any other game:
+ *
+ *   games/<name>/scripts/<n>.sc    scripts (see packages/sci/src/script/compiler.ts), compiled
+ *                                  together; they may include files from the game folder
+ *   games/<name>/scripts/<n>.sca   scripts in assembly (packages/sci/src/script/assembly.ts)
+ *   games/<name>/messages/<n>.msg  message files, as text (`pnpm msg` writes the same form)
+ *   games/<name>/rooms/<n>.room.yaml (+ <n>.yarn)  rooms as data (packages/content), compiled
+ *                                  for the class library; their Yarn variables are flags
+ *                                  numbered in flags.yaml
+ *   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>/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/
+ *
+ * plus the class library (lib/: its scripts and resources) and font 0, palette 999 and cursor
+ * view 999 (tools/game/defaults.ts), unless the game makes its own. Selectors are numbered as the scripts use them, starting with the nine object
+ * header slots; vocab 997 lists them and vocab 996 says which script defines each class.
+ */
+export interface BuiltGame {
+    resources: ResourceData[];
+    selectors: string[];
+    classes: Map<number, {
+        name: string;
+        script: number;
+    }>;
+    /** The assembly compiled from each .sc file, by script number. */
+    generated: Map<number, string>;
+    /** The globals' names, by number (when script 0 is compiled). */
+    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). */
+    files: Record<string, Uint8Array>;
+    /** Likely mistakes that still built, as file:line: message. */
+    warnings: string[];
+}
+export declare class GameBuildError extends Error {
+}
+/** sci-ts's class library: scripts every game gets, and the resources they use. */
+export declare const LIBRARY_DIR: string;
+export declare function buildGame(dir: string, options?: {
+    library?: boolean;
+}): Promise<BuiltGame>;

package/tools/game/build.js

@@ -0,0 +1,259 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { basename, dirname, join, relative, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+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 { ContentError, compileRoom } from "../../packages/content/src/index.js";
+import { modFlags } from "../mod-build.js";
+import { AudioFileError, readMidiFile, readWav } from "./audio.js";
+import { defaultResources } from "./defaults.js";
+import { libraryTarget } from "./target.js";
+const HEADER = OBJECT_HEADER;
+export class GameBuildError extends Error {
+}
+/** sci-ts's class library: scripts every game gets, and the resources they use. */
+export const LIBRARY_DIR = resolve(import.meta.dirname, "../../lib");
+export async function buildGame(dir, options = {}) {
+    const scriptsDir = join(dir, "scripts");
+    if (!existsSync(scriptsDir))
+        throw new GameBuildError(`${dir}: no scripts/ folder`);
+    const config = existsSync(join(dir, "game.json")) ? JSON.parse(readFileSync(join(dir, "game.json"), "utf8")) : {};
+    const library = options.library ?? config.library ?? true;
+    const load = (from, re) => readdirSync(from).sort().filter((f) => re.test(f)).map((f) => ({ file: join(from, f), text: readFileSync(join(from, f), "utf8") }));
+    const sources = load(scriptsDir, /^\d+\.sca$/);
+    const compiled = load(scriptsDir, /^\d+\.sc$/);
+    const numberOf = (file) => Number(basename(file).split(".")[0]);
+    const numbers = [...sources, ...compiled].map((s) => numberOf(s.file));
+    if (!numbers.includes(0))
+        throw new GameBuildError(`${dir}: no scripts/0.sc or 0.sca (script 0 exports the game object)`);
+    const repeated = numbers.find((n, i) => numbers.indexOf(n) !== i);
+    if (repeated !== undefined)
+        throw new GameBuildError(`${dir}: script ${repeated} is there twice`);
+    if (library) {
+        const lib = load(LIBRARY_DIR, /^\d+\.sc$/);
+        const clash = lib.find((l) => numbers.includes(numberOf(l.file)));
+        if (clash)
+            throw new GameBuildError(`${dir}: script ${numberOf(clash.file)} is the library's (${relative(process.cwd(), clash.file)})`);
+        compiled.push(...lib);
+    }
+    const selectors = [...HEADER];
+    const classes = new Map();
+    const byName = new Map();
+    const ctx = {
+        selectorNames: selectors,
+        kernelNames,
+        className: (species) => classes.get(species)?.name,
+        propSelectors: (obj) => (obj.isClass ? obj.propSelectors : classes.get(obj.superclass)?.propSelectors),
+        classSpecies: (name) => byName.get(name),
+        classPropSelectors: (species) => classes.get(species)?.propSelectors,
+        classDefaults: (species) => classes.get(species)?.properties,
+        newSelector: (name) => selectors.push(name) - 1,
+    };
+    // Compiled scripts may subclass classes from assembled ones (known once those are built),
+    // so the compiler runs inside the same loop.
+    const generated = new Map();
+    let globals = [];
+    const takenSpecies = new Set(sources.flatMap((s) => [...s.text.matchAll(/^\s*class\s+\S+\s+of\s+\S+\s+species\s+(\d+)/gm)].map((m) => Number(m[1]))));
+    let compileError;
+    const warnings = [];
+    const tryCompile = () => {
+        if (!compiled.length)
+            return [];
+        try {
+            const out = compileScripts(compiled.map((s) => ({ file: relative(process.cwd(), s.file), text: s.text })), {
+                kernelNames,
+                takenSpecies,
+                // Only when every class is compiled: hand-written scripts' methods can't be seen.
+                onWarning: sources.length ? undefined : (w) => warnings.push(`${w.file}:${w.line}: ${w.message}`),
+                externalClass: (name) => {
+                    const species = byName.get(name);
+                    const c = species === undefined ? undefined : classes.get(species);
+                    if (!c)
+                        return undefined;
+                    const props = c.propSelectors.slice(HEADER.length);
+                    return { species: c.species, properties: props.map((sel, i) => ({ name: selectors[sel], value: c.properties[HEADER.length + i] })) };
+                },
+                // Next to the including file, then in the game folder, then in the library.
+                include: (name, from) => {
+                    const path = [join(dirname(from), name), join(dir, name), join(LIBRARY_DIR, name)].find((p) => existsSync(p));
+                    return path ? readFileSync(path, "utf8") : undefined;
+                },
+            });
+            compiled.length = 0;
+            compileError = undefined;
+            for (const c of out)
+                generated.set(c.number, c.assembly);
+            globals = out.find((c) => c.number === 0)?.variables ?? [];
+            const rooms = library ? compileRooms() : [];
+            return [...out.map((c) => ({ file: c.file, text: c.assembly })), ...rooms];
+        }
+        catch (e) {
+            if (!(e instanceof CompileError))
+                throw e;
+            compileError = e;
+            return [];
+        }
+    };
+    // Rooms as YAML and Yarn: compiled once script 0 is (the target needs its globals).
+    const roomMessages = [];
+    const roomMessageText = new Map();
+    const compileRooms = () => {
+        const roomsDir = join(dir, "rooms");
+        if (!existsSync(roomsDir))
+            return [];
+        const target = libraryTarget(globals);
+        const flags = modFlags(dir, { content: target });
+        const out = [];
+        for (const { file, text } of load(roomsDir, /^\d+\.room\.yaml$/)) {
+            const n = numberOf(file);
+            if (numbers.includes(n))
+                throw new GameBuildError(`${relative(process.cwd(), file)}: there's also a scripts/${n} (a room is one or the other)`);
+            const yarnFile = join(roomsDir, `${n}.yarn`);
+            let room;
+            try {
+                room = compileRoom(text, existsSync(yarnFile) ? readFileSync(yarnFile, "utf8") : undefined, target, { yaml: relative(process.cwd(), file), yarn: relative(process.cwd(), yarnFile) }, { flag: flags.number });
+            }
+            catch (e) {
+                if (e instanceof ContentError)
+                    throw new GameBuildError(e.message);
+                throw e;
+            }
+            generated.set(n, room.sca);
+            roomMessageText.set(n, room.msg);
+            roomMessages.push({ type: ResourceType.Message, number: n, data: writeMessages(messagesFromText(room.msg).file) });
+            out.push({ file: relative(process.cwd(), file), text: room.sca });
+        }
+        flags.save();
+        return out;
+    };
+    // A script can only be assembled once the classes it uses are known, so keep going round
+    // until everything is built or nothing more can be.
+    const resources = [];
+    let pending = [...sources, ...tryCompile()];
+    while (pending.length || compiled.length) {
+        const failed = [];
+        for (const src of pending) {
+            try {
+                const built = assemble(src.text, ctx);
+                if (Number(basename(src.file).split(".")[0]) !== built.number)
+                    throw new GameBuildError(`${src.file} says it is script ${built.number}`);
+                resources.push({ type: ResourceType.Script, number: built.number, data: built.code }, { type: ResourceType.Heap, number: built.number, data: built.heap });
+                for (const o of parseScript(built.number, built.code, built.heap).objects) {
+                    if (!o.isClass)
+                        continue;
+                    const other = classes.get(o.species);
+                    if (other)
+                        throw new GameBuildError(`${src.file}: class ${o.name} has species ${o.species}, already taken by ${other.name} (script ${other.script})`);
+                    if (byName.has(o.name))
+                        throw new GameBuildError(`${src.file}: class ${o.name} is defined twice`);
+                    classes.set(o.species, { ...o, script: built.number });
+                    byName.set(o.name, o.species);
+                }
+            }
+            catch (e) {
+                if (!(e instanceof AsmError))
+                    throw e;
+                failed.push({ ...src, error: e });
+            }
+        }
+        const more = tryCompile();
+        if (failed.length === pending.length && !more.length) {
+            if (compileError)
+                throw new GameBuildError(compileError.message);
+            throw new GameBuildError(failed.map((f) => `${f.file}: ${f.error.message}`).join("\n"));
+        }
+        pending = [...failed, ...more];
+    }
+    const classTable = Array.from({ length: Math.max(-1, ...classes.keys()) + 1 }, (_, species) => classes.get(species)?.script ?? 0);
+    resources.push({ type: ResourceType.Vocab, number: 997, data: writeSelectorNames(selectors) }, { type: ResourceType.Vocab, number: 996, data: writeClassTable(classTable) });
+    // The globals' names, for tools reading the running game (the player's room links, the
+    // editor, the explorer): sci-ts's own vocab, in the selector list format.
+    if (globals.length)
+        resources.push({ type: ResourceType.Vocab, number: GLOBAL_NAMES_VOCAB, data: writeSelectorNames(globals) });
+    // Messages: the rooms', then those written as text.
+    resources.push(...roomMessages);
+    const messagesDir = join(dir, "messages");
+    if (existsSync(messagesDir)) {
+        for (const { file, text } of load(messagesDir, /^\d+\.msg$/)) {
+            let parsed;
+            try {
+                parsed = messagesFromText(text);
+            }
+            catch (e) {
+                throw new GameBuildError(`${relative(process.cwd(), file)}: ${e.message}`);
+            }
+            if (parsed.number !== numberOf(file))
+                throw new GameBuildError(`${file} says it is message file ${parsed.number}`);
+            resources.push({ type: ResourceType.Message, number: parsed.number, data: writeMessages(parsed.file) });
+        }
+    }
+    // Music (MIDI files) and digital effects (WAV files).
+    const audioFile = (file, read) => {
+        try {
+            return read();
+        }
+        catch (e) {
+            if (e instanceof AudioFileError)
+                throw new GameBuildError(`${relative(process.cwd(), file)}: ${e.message}`);
+            throw e;
+        }
+    };
+    const musicDir = join(dir, "music");
+    if (existsSync(musicDir)) {
+        for (const f of readdirSync(musicDir).filter((x) => /^\d+\.midi?$/i.test(x)).sort()) {
+            const file = join(musicDir, f);
+            const spec = audioFile(file, () => readMidiFile(new Uint8Array(readFileSync(file))));
+            resources.push({ type: ResourceType.Sound, number: numberOf(file), data: writeSound(spec) });
+        }
+    }
+    const files = {};
+    const soundsDir = join(dir, "sounds");
+    if (existsSync(soundsDir)) {
+        const clips = readdirSync(soundsDir).filter((x) => /^\d+\.wav$/i.test(x)).sort().map((f) => {
+            const file = join(soundsDir, f);
+            const { samples, rate } = audioFile(file, () => readWav(new Uint8Array(readFileSync(file))));
+            return { number: numberOf(file), sol: writeSol(samples, rate) };
+        });
+        if (clips.length) {
+            const { sfx, map } = writeEffects(clips);
+            files["RESOURCE.SFX"] = sfx;
+            resources.push({ type: ResourceType.Map, number: 65535, data: map });
+        }
+    }
+    // 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))
+            return [];
+        const mod = (await import(__rewriteRelativeImportExtension(pathToFileURL(resolve(path)).href)));
+        return mod.default();
+    };
+    resources.push(...(await made(join(dir, "resources.ts"))));
+    const have = new Set(resources.map(resourceKey));
+    // The library's resources are compiled in the npm package (resources.js), source here.
+    const libraryResources = ["resources.js", "resources.ts"].map((f) => join(LIBRARY_DIR, f)).find((f) => existsSync(f));
+    const fallback = [...(library ? await made(libraryResources) : []), ...defaultResources()];
+    for (const r of fallback)
+        if (!have.has(resourceKey(r)))
+            (resources.push(r), have.add(resourceKey(r)));
+    const keys = resources.map(resourceKey);
+    const twice = keys.find((k, i) => keys.indexOf(k) !== i);
+    if (twice)
+        throw new GameBuildError(`${dir}: resource ${twice} is made twice`);
+    return {
+        resources,
+        selectors,
+        classes: new Map([...classes].map(([species, c]) => [species, { name: c.name, script: c.script }])),
+        generated,
+        globals,
+        roomMessages: roomMessageText,
+        files,
+        warnings: [...new Set(warnings)],
+    };
+}