@raskell/wasm-ad 0.1.0 → 0.2.0

package/README.md

@@ -1,8 +1,8 @@
 # WASM-AD for AssemblyScript
 
 An AssemblyScript SDK for [WASM-AD](https://github.com/raskell-io/wasm-ad) carts: register
-addresses, typed builders for backgrounds, sprites and affine matrices, input, save RAM and
-`trace`, with no runtime allocation and no mutable globals.
+addresses, typed builders for backgrounds (tiled and affine), sprites, affine matrices and
+sound, input, save RAM and `trace`, with no runtime allocation and no mutable globals.
 
 ## The starter cart
 
@@ -12,8 +12,9 @@ npm run build            # build/starter.wasm
 node ../../tools/wasmad.mjs check build/starter.wasm
 ```
 
-[`examples/starter.ts`](examples/starter.ts) is the same cart as every other SDK's starter
-and renders bit-identical frames. Drop `build/starter.wasm` into the player.
+[`examples/starter.ts`](examples/starter.ts) is the same cart as every other SDK's starter: a
+rotating affine checkerboard, a spinning star and a little tune on every sound channel, with
+bit-identical frames and sound. Drop `build/starter.wasm` into the player.
 
 ## A new cart
 
@@ -72,7 +73,27 @@ export function start(): void {
 ```
 
 `const` values are fine. Avoid `new`, string concatenation, arrays and anything else that
-allocates; use `memory.data` for static buffers.
+allocates; use `memory.data` for static buffers and tables, e.g.
+`const NOTES = memory.data<u32>([262, 330, 392])` read with `load<u32>(NOTES + (i << 2))`.
+
+## Sound
+
+`sound.enable()` turns sound on with every channel on both sides. A channel plays when its
+start bit is written; the host clears it after the frame (SPEC.md §14):
+
+```ts
+write16(reg.SOUND2CNT_L, sound.DUTY_50 | sound.envelope(12, 2, false));
+write16(reg.SOUND2CNT_H, sound.START | sound.rate(440));
+```
+
+Sample channels play signed 8-bit samples you write to `sound.sampleRam()`:
+`pcm.play(0, offset, length, 16000, 64)`.
+
+## Affine backgrounds
+
+In modes 1 and 2, BG2 (and BG3 in mode 2) is drawn through a matrix. Its tiles are 8bpp
+(`bgTile8`) and its map is one byte per tile (`affineMap`). `setBgAffine(2, m, tx, ty, sx, sy)`
+puts texture pixel (tx, ty) at screen pixel (sx, sy) and rotates and scales around it.
 
 ## API
 
@@ -83,11 +104,12 @@ All values are plain integers; builders take a value and return a new one.
 | `read16`, `write16`, `read32`, `write32` | Raw register access, e.g. `write16(reg.DISPCNT, dispcnt.MODE0 \| dispcnt.BG0)` |
 | `reg.*`, `reg.BGCNT(i)`, `reg.BGHOFS(i)`, `reg.BGVOFS(i)` | Register addresses by their SPEC.md names |
 | `dispcnt`, `layer`, `blend`, `key` | Bit constants; `blend.cnt(effect, first, second)`, `blend.alpha(eva, evb)` |
-| `bgcnt.priority/charBlock/screenBlock/size/bpp8/mosaic` | `BGxCNT` builders |
+| `bgcnt.priority/charBlock/screenBlock/size/bpp8/mosaic/affineSize/wrap` | `BGxCNT` builders |
 | `rgb(r, g, b)` | 8-bit channels to RGB555 |
 | `setBgColor(i, c)`, `setObjColor(i, c)` | Palette RAM |
 | `bgTile(block, i)`, `objTile(i)`, `fillTile(addr, byte)` | Addresses of 32-byte 4bpp tiles |
 | `screenBlock(b)`, `setScreenEntry(b, i, e)`, `screenEntry.make/hflip/vflip` | Background maps |
+| `bgTile8(block, i)`, `affineMap(b)`, `setBgAffine(bg, m, tx, ty, sx, sy)` | Affine backgrounds (modes 1 and 2) |
 | `sprite.make(x, y, SpriteSize.S16x16, tile)` then `.bank/.priority/.hflip/.vflip/.semiTransparent/.window/.mosaic/.bpp8/.affine` | Sprites, packed in a `u64` |
 | `oam.set(i, s)`, `oam.hide(i)`, `oam.hideAll()`, `oam.setAffine(slot, m)` | OAM |
 | `affine.rotateScaleFixed(angle, sx, sy)`, `affine.IDENTITY`, `affine.make` | Affine matrices; angle in 1/256 turns, scale in 8.8 |
@@ -95,4 +117,7 @@ All values are plain integers; builders take a value and return a new one.
 | `buttons.update()`, `buttons.held(k)`, `buttons.pressed(k)`, `keys()` | Input |
 | `frame()`, `seed()` | Time and the only entropy source |
 | `saveRam()`, `saveRestored()`, `requestSave()` | 32 KB of save RAM at 0x19000 |
+| `sound.enable/disable`, `sound.rate(hz)`, `sound.sweep/envelope/length/noise`, `sound.START/LENGTH/DUTY_*/WAVE_*` | Sound channels 1–4, through `reg.SOUND*` |
+| `sound.waveRam()`, `sound.sampleRam()`, `sound.status()` | Wave RAM, sample RAM, which channels are playing |
+| `pcm.play(ch, start, len, rate, vol)`, `pcm.playLooped`, `pcm.stop`, `pcm.position`, `pcm.playing` | Sample channels A (0) and B (1) |
 | `trace(msg)` | UTF-8 to the host's debug log (at most 1 KB) |

package/assembly/index.ts

@@ -27,13 +27,18 @@ export const VRAM_SIZE: usize = 0x18000;
 export const OBJ_VRAM: usize = VRAM + 0x10000;
 export const SAVE: usize = 0x19000;
 export const SAVE_SIZE: usize = 0x8000;
+/** Sample RAM: signed 8-bit samples for the sample channels (SPEC.md §14.6). */
+export const SAMPLE_RAM: usize = 0x21000;
+export const SAMPLE_RAM_SIZE: usize = 0x7000;
+/** Wave RAM: two banks of 16 bytes (SPEC.md §14.5). */
+export const WAVE_RAM: usize = 0x490;
 /** First address the cart may use for its own data, stack and heap. */
 export const CART: usize = 0x28000;
 /** OAM attribute 0 that hides a sprite. */
 export const OBJ_HIDDEN: u16 = 0x0200;
-export const SPEC_VERSION: u16 = 0x0001;
+export const SPEC_VERSION: u16 = 0x0002;
 
-// ---- Registers (SPEC.md §5, §6) ---------------------------------------------
+// ---- Registers (SPEC.md §5, §6, §14) ----------------------------------------
 
 /** Every register address, by its SPEC.md name. Use with `read16`/`write16`. */
 export namespace reg {
@@ -56,6 +61,46 @@ export namespace reg {
   export const SAVESTAT: usize = 0x70e;
   export const SPEC: usize = 0x710;
 
+  export const BG2PA: usize = 0x420;
+  export const BG2PB: usize = 0x422;
+  export const BG2PC: usize = 0x424;
+  export const BG2PD: usize = 0x426;
+  export const BG2X: usize = 0x428; // u32
+  export const BG2Y: usize = 0x42c; // u32
+  export const BG3PA: usize = 0x430;
+  export const BG3PB: usize = 0x432;
+  export const BG3PC: usize = 0x434;
+  export const BG3PD: usize = 0x436;
+  export const BG3X: usize = 0x438; // u32
+  export const BG3Y: usize = 0x43c; // u32
+
+  export const SOUND1CNT_L: usize = 0x460;
+  export const SOUND1CNT_H: usize = 0x462;
+  export const SOUND1CNT_X: usize = 0x464;
+  export const SOUND2CNT_L: usize = 0x468;
+  export const SOUND2CNT_H: usize = 0x46c;
+  export const SOUND3CNT_L: usize = 0x470;
+  export const SOUND3CNT_H: usize = 0x472;
+  export const SOUND3CNT_X: usize = 0x474;
+  export const SOUND4CNT_L: usize = 0x478;
+  export const SOUND4CNT_H: usize = 0x47c;
+  export const SOUNDCNT_L: usize = 0x480;
+  export const SOUNDCNT_H: usize = 0x482;
+  export const SOUNDCNT_X: usize = 0x484;
+
+  export const PCMA_SAD: usize = 0x4b0;
+  export const PCMA_LEN: usize = 0x4b2;
+  export const PCMA_LOOP: usize = 0x4b4;
+  export const PCMA_RATE: usize = 0x4b6;
+  export const PCMA_CNT: usize = 0x4b8;
+  export const PCMA_POS: usize = 0x4ba;
+  export const PCMB_SAD: usize = 0x4c0;
+  export const PCMB_LEN: usize = 0x4c2;
+  export const PCMB_LOOP: usize = 0x4c4;
+  export const PCMB_RATE: usize = 0x4c6;
+  export const PCMB_CNT: usize = 0x4c8;
+  export const PCMB_POS: usize = 0x4ca;
+
   /** `BGxCNT` for background 0–3. */
   // @ts-ignore: decorator
   @inline export function BGCNT(bg: i32): usize {
@@ -93,6 +138,10 @@ export namespace reg {
 /** `DISPCNT` bits (SPEC.md §6.1). */
 export namespace dispcnt {
   export const MODE0: u16 = 0;
+  /** BG0 and BG1 tiled, BG2 affine. */
+  export const MODE1: u16 = 1;
+  /** BG2 and BG3 affine. */
+  export const MODE2: u16 = 2;
   export const MODE3: u16 = 3;
   export const MODE4: u16 = 4;
   export const MODE5: u16 = 5;
@@ -165,6 +214,14 @@ export enum MapSize {
   S64x64 = 3,
 }
 
+/** Affine background map sizes, in tiles (SPEC.md §8.4). */
+export enum AffineSize {
+  S16x16 = 0,
+  S32x32 = 1,
+  S64x64 = 2,
+  S128x128 = 3,
+}
+
 /** Builders for a `BGxCNT` value (SPEC.md §6.2), e.g. `bgcnt.priority(bgcnt.screenBlock(0, 31), 1)`. */
 export namespace bgcnt {
   // @ts-ignore: decorator
@@ -191,6 +248,16 @@ export namespace bgcnt {
   @inline export function mosaic(c: u16): u16 {
     return c | 0x40;
   }
+  /** Map size of an affine background. */
+  // @ts-ignore: decorator
+  @inline export function affineSize(c: u16, s: AffineSize): u16 {
+    return (c & 0x3fff) | (<u16>s << 14);
+  }
+  /** An affine background repeats instead of being transparent outside its map. */
+  // @ts-ignore: decorator
+  @inline export function wrap(c: u16): u16 {
+    return c | 0x2000;
+  }
 }
 
 /** Packs 8-bit channels into RGB555. */
@@ -215,6 +282,19 @@ export namespace bgcnt {
 @inline export function bgTile(block: i32, index: i32): usize {
   return VRAM + <usize>block * 0x4000 + (<usize>index << 5);
 }
+/** Address of 8bpp background tile `index` counted from character block `block` (0–3). Tiles are 64 bytes;
+ *  affine backgrounds always use these. */
+// @ts-ignore: decorator
+@inline export function bgTile8(block: i32, index: i32): usize {
+  return VRAM + <usize>block * 0x4000 + (<usize>index << 6);
+}
+/** Address of an affine background's map at screen block `block` (0–31): one tile index per byte,
+ *  row-major (SPEC.md §8.4). */
+// @ts-ignore: decorator
+@inline export function affineMap(block: i32): usize {
+  return VRAM + <usize>block * 0x800;
+}
+
 /** Address of 4bpp sprite tile `index` (0–1023). */
 // @ts-ignore: decorator
 @inline export function objTile(index: i32): usize {
@@ -412,6 +492,146 @@ export namespace oam {
   }
 }
 
+/** Sets affine background `bg` (2 or 3) to matrix `m`, placed so that texture
+ *  pixel (texX, texY) appears at screen pixel (scrX, scrY). Rotation and
+ *  scaling then happen around that point. */
+export function setBgAffine(bg: i32, m: AffineMatrix, texX: i32, texY: i32, scrX: i32, scrY: i32): void {
+  const at = reg.BG2PA + <usize>(bg - 2) * 0x10;
+  const pa = <i32>affine.pa(m), pb = <i32>affine.pb(m), pc = <i32>affine.pc(m), pd = <i32>affine.pd(m);
+  store<u16>(at, <u16>pa);
+  store<u16>(at + 2, <u16>pb);
+  store<u16>(at + 4, <u16>pc);
+  store<u16>(at + 6, <u16>pd);
+  store<u32>(at + 8, <u32>((texX << 8) - pa * scrX - pb * scrY));
+  store<u32>(at + 12, <u32>((texY << 8) - pc * scrX - pd * scrY));
+}
+
+// ---- Sound (SPEC.md §14) -------------------------------------------------------
+
+/** Sound: four GBA-style channels written through `reg.SOUND*`, with
+ *  builders for their fields, and setup:
+ *
+ *    sound.enable();
+ *    write16(reg.SOUND2CNT_L, sound.DUTY_50 | sound.envelope(12, 2, false));
+ *    write16(reg.SOUND2CNT_H, sound.START | sound.rate(440));
+ */
+export namespace sound {
+  /** Starts (or restarts) a channel; the host clears it. */
+  export const START: u16 = 1 << 15;
+  /** Stops the channel when its length runs out. */
+  export const LENGTH: u16 = 1 << 14;
+
+  export const DUTY_12: u16 = 0 << 6;
+  export const DUTY_25: u16 = 1 << 6;
+  export const DUTY_50: u16 = 2 << 6;
+  export const DUTY_75: u16 = 3 << 6;
+
+  /** `SOUND3CNT_L`: the wave channel is on. */
+  export const WAVE_ON: u16 = 1 << 7;
+  /** `SOUND3CNT_L`: play bank 1 (or start with it, with `WAVE_64`). */
+  export const WAVE_BANK1: u16 = 1 << 6;
+  /** `SOUND3CNT_L`: play both banks as one 64-sample wave. */
+  export const WAVE_64: u16 = 1 << 5;
+  /** `SOUND3CNT_H` volumes. */
+  export const WAVE_100: u16 = 1 << 13;
+  export const WAVE_50: u16 = 2 << 13;
+  export const WAVE_25: u16 = 3 << 13;
+  export const WAVE_75: u16 = 1 << 15;
+
+  /** Turns sound on with every channel on both sides at full volume. */
+  export function enable(): void {
+    store<u16>(reg.SOUNDCNT_X, 0x80);
+    store<u16>(reg.SOUNDCNT_L, 0xff77);
+    store<u16>(reg.SOUNDCNT_H, 0x330e);
+  }
+  /** Turns sound off; every channel stops. */
+  export function disable(): void {
+    store<u16>(reg.SOUNDCNT_X, 0);
+  }
+
+  /** The rate field for a square channel playing `hz` (64 Hz and up); the
+   *  wave channel plays an octave lower at the same rate. */
+  // @ts-ignore: decorator
+  @inline export function rate(hz: u32): u16 {
+    return hz < 64 ? 0 : <u16>(2048 - 131072 / hz);
+  }
+  /** `SOUND1CNT_L`: every `time` 128ths of a second (1–7, 0 = off), the
+   *  rate changes by rate >> `shift` (1–7), down if `decrease`. */
+  // @ts-ignore: decorator
+  @inline export function sweep(time: u16, shift: u16, decrease: bool): u16 {
+    return ((time & 7) << 4) | (shift & 7) | (decrease ? 8 : 0);
+  }
+  /** The envelope fields: start at `volume` (0–15), stepping by one every
+   *  `step` 64ths of a second (0 = constant), up if `increase`. */
+  // @ts-ignore: decorator
+  @inline export function envelope(volume: u16, step: u16, increase: bool): u16 {
+    return ((volume & 15) << 12) | ((step & 7) << 8) | (increase ? 1 << 11 : 0);
+  }
+  /** The length field of channels 1, 2 and 4 for `n` 256ths of a second
+   *  (1–64); it only counts with `LENGTH` set. Channel 3 takes 256 − n. */
+  // @ts-ignore: decorator
+  @inline export function length(n: u16): u16 {
+    return (64 - n) & 63;
+  }
+  /** `SOUND4CNT_H`: noise from a divider (0–7) and shift (0–13), with the
+   *  7-bit register if `short` (more tonal). */
+  // @ts-ignore: decorator
+  @inline export function noise(divider: u16, shift: u16, short: bool): u16 {
+    return (divider & 7) | ((shift & 15) << 4) | (short ? 8 : 0);
+  }
+
+  /** Address of wave RAM: two banks of 16 bytes, each 32 4-bit samples, high nibble first. */
+  // @ts-ignore: decorator
+  @inline export function waveRam(): usize {
+    return WAVE_RAM;
+  }
+  /** Address of the 28 KB of sample RAM (signed 8-bit) that the sample channels play from. */
+  // @ts-ignore: decorator
+  @inline export function sampleRam(): usize {
+    return SAMPLE_RAM;
+  }
+  /** Which channels are playing: bits 0–3 channels 1–4, bits 4 and 5 sample
+   *  channels A and B, as of the end of the last frame. */
+  // @ts-ignore: decorator
+  @inline export function status(): u16 {
+    return load<u16>(reg.SOUNDCNT_X) & 0x3f;
+  }
+}
+
+/** The two sample channels, A (0) and B (1), playing signed 8-bit samples
+ *  from sample RAM (SPEC.md §14.6). */
+export namespace pcm {
+  // @ts-ignore: decorator
+  @inline function base(ch: i32): usize {
+    return ch == 0 ? reg.PCMA_SAD : reg.PCMB_SAD;
+  }
+
+  /** Plays `len` samples from sample RAM offset `start` at `rate` Hz and `volume` 0–64, once. */
+  export function play(ch: i32, start: u16, len: u16, rate: u16, volume: u16): void {
+    const b = base(ch);
+    store<u16>(b, start);
+    store<u16>(b + 2, len);
+    store<u16>(b + 6, rate);
+    store<u16>(b + 8, sound.START | (volume < 64 ? volume : 64));
+  }
+  /** Like `play`, then repeats from sample `loopAt` until stopped. */
+  export function playLooped(ch: i32, start: u16, len: u16, loopAt: u16, rate: u16, volume: u16): void {
+    store<u16>(base(ch) + 4, loopAt);
+    play(ch, start, len, rate, volume);
+    store<u16>(base(ch) + 8, load<u16>(base(ch) + 8) | (1 << 13));
+  }
+  export function stop(ch: i32): void {
+    store<u16>(base(ch) + 8, 1 << 14);
+  }
+  /** The playback position, in samples from the start, as of the end of the last frame. */
+  export function position(ch: i32): u16 {
+    return load<u16>(base(ch) + 10);
+  }
+  export function playing(ch: i32): bool {
+    return (sound.status() & (1 << (4 + ch))) != 0;
+  }
+}
+
 // ---- Fixed-point trigonometry --------------------------------------------------
 
 /** Fixed-point trigonometry shared by all WASM-AD SDKs, so carts in any

package/bin/wasmad.mjs

@@ -10,26 +10,31 @@
 // defaults to the version this tool implements. It is for toolchains that
 // cannot emit custom sections themselves (AssemblyScript, TinyGo).
 //
-// `run` boots the cart like a host does (SPEC.md §3) and renders with the
-// reference renderer, player/web/core.wasm (`make player`). Options:
+// `run` boots the cart like a host does (SPEC.md §3) and renders and makes
+// sound with the reference core, player/web/core.wasm (`make player`). Options:
 //   --frames N        frames to run (default 1)
 //   --keys SCRIPT     held buttons per frame, e.g. "0-29:right,30-59:down+b,60:a"
 //   --seed N          value for SEED (default 1)
-//   --hash F,F,...    print a hash of the frame rendered at each listed frame
+//   --hash F,F,...    print a hash of the frame rendered at each listed frame,
+//                     and one of all the sound
 //   --ppm FILE        write the last rendered frame as a PPM image
+//   --wav FILE        write the sound of every frame as a 48 kHz stereo WAV
 //   --core FILE       a different core.wasm
 
 import { readFileSync, realpathSync, writeFileSync } from 'node:fs';
 import { createHash } from 'node:crypto';
 import { fileURLToPath } from 'node:url';
 
-const SPEC = '0.1';
-const SPEC_VERSION = 0x0001;
+const SPEC = '0.2';
+const SPEC_VERSION = 0x0002;
 const W = 240, H = 160;
 const A = {
   IO: 0x400, PAL_END: 0xC00, OAM: 0xC00, VIDEO_END: 0x19000, SAVE: 0x19000, SAVE_SIZE: 0x8000, CART: 0x28000,
   VCOUNT: 0x406, KEYS: 0x700, FRAME: 0x704, SEED: 0x708, SAVECNT: 0x70C, SAVESTAT: 0x70E, SPEC: 0x710,
+  BG2PA: 0x420, BG2PD: 0x426, BG3PA: 0x430, BG3PD: 0x436,
+  SOUND_REGS: 0x460, SOUND_REGS_END: 0x4D0, SOUND_STATE: 0x780, SOUND_STATE_END: 0x800,
 };
+const SOUND_SAMPLES = 800;
 const KEY = { a: 1, b: 2, select: 4, start: 8, right: 16, left: 32, up: 64, down: 128, r: 256, l: 512 };
 const MAX_CART = 32 * 1024 * 1024;
 
@@ -315,13 +320,16 @@ export async function boot(bytes, { core: corePath, seed = 1, onTrace = () => {}
   const dv = () => new DataView(ex.memory.buffer);
   mem().fill(0, 0, A.CART);
   for (let i = 0; i < 128; i++) dv().setUint16(A.OAM + i * 8, 0x0200, true);
+  for (const a of [A.BG2PA, A.BG2PD, A.BG3PA, A.BG3PD]) dv().setUint16(a, 0x100, true);
   dv().setUint32(A.SEED, seed >>> 0, true);
   dv().setUint16(A.SPEC, SPEC_VERSION, true);
   ex.start?.();
 
-  let frame = 0;
+  let frame = 0, sound = new Int16Array(SOUND_SAMPLES * 2);
   return {
     exports: ex,
+    /** The last frame's sound: 800 stereo pairs of i16, left first. */
+    get sound() { return sound; },
     /** Runs one frame with `keys` held and returns the rendered RGBA8 pixels. */
     frame(keys = 0) {
       dv().setUint16(A.KEYS, keys & 0x3FF, true);
@@ -329,7 +337,12 @@ export async function boot(bytes, { core: corePath, seed = 1, onTrace = () => {}
       dv().setUint16(A.VCOUNT, 160, true);
       ex.update();
       const coreMem = new Uint8Array(core.memory.buffer, core.ad_mem(), core.ad_mem_len());
-      coreMem.set(mem().subarray(0, A.VIDEO_END));
+      coreMem.set(mem().subarray(0, A.CART));
+      core.ad_sound_frame();
+      for (const [from, to] of [[A.SOUND_REGS, A.SOUND_REGS_END], [A.SOUND_STATE, A.SOUND_STATE_END]]) {
+        mem().set(coreMem.subarray(from, to), from);
+      }
+      sound = new Int16Array(core.memory.buffer, core.ad_sound_buffer(), SOUND_SAMPLES * 2).slice();
       for (let y = 0; y < H; y++) {
         if (ex.scanline) {
           dv().setUint16(A.VCOUNT, y, true);
@@ -345,8 +358,24 @@ export async function boot(bytes, { core: corePath, seed = 1, onTrace = () => {}
   };
 }
 
-export function hash(pixels) {
-  return createHash('sha256').update(pixels).digest('hex').slice(0, 16);
+export function hash(...chunks) {
+  const h = createHash('sha256');
+  for (const c of chunks) h.update(new Uint8Array(c.buffer, c.byteOffset, c.byteLength));
+  return h.digest('hex').slice(0, 16);
+}
+
+/** A 48 kHz 16-bit stereo WAV file of `frames` (Int16Arrays from `sound`). */
+export function wav(frames) {
+  const bytes = frames.reduce((n, f) => n + f.byteLength, 0);
+  const out = new DataView(new ArrayBuffer(44 + bytes));
+  const tag = (at, s) => [...s].forEach((c, i) => out.setUint8(at + i, c.charCodeAt(0)));
+  tag(0, 'RIFF'); out.setUint32(4, 36 + bytes, true); tag(8, 'WAVEfmt ');
+  out.setUint32(16, 16, true); out.setUint16(20, 1, true); out.setUint16(22, 2, true);
+  out.setUint32(24, 48000, true); out.setUint32(28, 48000 * 4, true); out.setUint16(32, 4, true);
+  out.setUint16(34, 16, true); tag(36, 'data'); out.setUint32(40, bytes, true);
+  let at = 44;
+  for (const f of frames) for (const s of f) { out.setInt16(at, s, true); at += 2; }
+  return new Uint8Array(out.buffer);
 }
 
 function ppm(pixels) {
@@ -373,7 +402,7 @@ async function main([cmd, ...args]) {
   const opts = options(args);
   const [file, ...rest] = opts._;
   if (!cmd || !file || !['check', 'meta', 'run'].includes(cmd)) {
-    console.error('usage: wasmad check <cart.wasm>\n       wasmad meta <cart.wasm> [-o out.wasm] key=value...\n       wasmad run <cart.wasm> [--frames N] [--keys SCRIPT] [--seed N] [--hash F,F] [--ppm FILE]');
+    console.error('usage: wasmad check <cart.wasm>\n       wasmad meta <cart.wasm> [-o out.wasm] key=value...\n       wasmad run <cart.wasm> [--frames N] [--keys SCRIPT] [--seed N] [--hash F,F] [--ppm FILE] [--wav FILE]');
     return 2;
   }
   const bytes = new Uint8Array(readFileSync(file));
@@ -411,11 +440,15 @@ async function main([cmd, ...args]) {
   const frames = Number(opts.frames ?? 1);
   const marks = new Set((opts.hash ?? '').split(',').filter(Boolean).map(Number));
   let pixels;
+  const sound = [];
   for (let f = 0; f < frames; f++) {
     pixels = host.frame(keys(f));
+    sound.push(host.sound);
     if (marks.has(f)) console.log(`frame ${f}: ${hash(pixels)}`);
   }
+  if (opts.hash) console.log(`sound: ${hash(...sound)}`);
   if (opts.ppm) writeFileSync(opts.ppm, ppm(pixels));
+  if (opts.wav) writeFileSync(opts.wav, wav(sound));
   return 0;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@raskell/wasm-ad",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "AssemblyScript SDK for writing WASM-AD carts",
   "license": "MIT",
   "repository": {