sci2-ts 0.0.0-stage → 0.2.2

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

@@ -0,0 +1,108 @@
+import type { MidiEvent } from "./midi.ts";
+import { SolFlag } from "./sol.ts";
+
+/**
+ * Writers for sound: sound resources (music, in the layout parseSound reads), SOL clips, and
+ * the effects file RESOURCE.SFX with its index, map 65535 (the layout AudioIndex reads).
+ */
+
+export interface SoundChannel {
+  /** 0-15; 15 is the control channel (signals and cues to the scripts), not music. */
+  midiChannel: number;
+  /** Voices it wants from a voice-limited device (AdLib); others ignore it. */
+  voices: number;
+  /** Absolute ticks (1/60 s); bytes are MIDI messages (their channel nibble is replaced). */
+  events: MidiEvent[];
+}
+
+export interface SoundSpec {
+  priority?: number;
+  /** One per sound device (SoundDevice): each device plays its own arrangement. */
+  tracks: { device: number; channels: SoundChannel[] }[];
+}
+
+const dataBytes = (status: number) => ((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: SoundChannel): number[] {
+  if (c.midiChannel < 0 || c.midiChannel > 15) throw new Error(`MIDI channel ${c.midiChannel} isn't 0-15`);
+  const out = [c.midiChannel, c.voices & 0x0f];
+  const events = [...c.events].sort((a, b) => a.tick - b.tick);
+  let tick = 0, running = -1;
+  for (const e of events) {
+    if (e.tick < tick) throw new Error(`event at tick ${e.tick} before ${tick}`);
+    let delta = Math.round(e.tick - tick);
+    tick += delta;
+    // A delta of 240 or more is 0xF8 bytes of 240 each, then the rest.
+    for (; delta >= 240; delta -= 240) out.push(0xf8);
+    out.push(delta);
+    const status = (e.bytes[0]! & 0xf0) | c.midiChannel;
+    if (status < 0x80 || status >= 0xf0) throw new Error(`not a channel message: ${e.bytes.map((b) => b.toString(16)).join(" ")}`);
+    if (status !== running) out.push(status);
+    running = status;
+    const n = dataBytes(status);
+    for (let i = 1; i <= n; i++) out.push((e.bytes[i] ?? 0) & 0x7f);
+  }
+  out.push(0, 0xfc);
+  return out;
+}
+
+export function writeSound(spec: SoundSpec): Uint8Array {
+  const header = [0xf0, spec.priority ?? 0, 0, 0, 0, 0, 0, 0];
+  const streams = spec.tracks.map((t) => t.channels.map(channelStream));
+  // Track table: device, 6-byte entries (u16 0, u16 offset, u16 size), 0xFF; then 0xFF.
+  const tableSize = spec.tracks.reduce((n, t) => n + 1 + t.channels.length * 6 + 1, 0) + 1;
+  let at = header.length + tableSize;
+  const table: number[] = [];
+  const body: number[] = [];
+  spec.tracks.forEach((t, i) => {
+    table.push(t.device);
+    for (const s of streams[i]!) {
+      if (at + s.length > 0xffff) throw new Error("sound too large: offsets are 16-bit (64 KB)");
+      table.push(0, 0, at & 0xff, at >> 8, s.length & 0xff, s.length >> 8);
+      body.push(...s);
+      at += s.length;
+    }
+    table.push(0xff);
+  });
+  table.push(0xff);
+  return Uint8Array.from([...header, ...table, ...body]);
+}
+
+/** A SOL clip: 16-bit samples at `rate`, uncompressed. */
+export function writeSol(samples: Int16Array, rate: number): Uint8Array {
+  const out = new Uint8Array(13 + samples.length * 2);
+  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));
+  return out;
+}
+
+/**
+ * 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.
+ */
+export function writeEffects(clips: readonly { number: number; sol: Uint8Array }[]): { sfx: Uint8Array; map: Uint8Array } {
+  const sorted = [...clips].sort((a, b) => a.number - b.number);
+  const sfx = new Uint8Array(sorted.reduce((n, c) => n + c.sol.length, 0));
+  const map = new Uint8Array(sorted.length * 5 + 5);
+  const v = new DataView(map.buffer);
+  let at = 0, prev = 0;
+  sorted.forEach((c, i) => {
+    if (i && c.number === sorted[i - 1]!.number) throw new Error(`sound effect ${c.number} is there twice`);
+    if (at - prev > 0xffffff) throw new Error("sound effect too large");
+    sfx.set(c.sol, at);
+    v.setUint16(i * 5, c.number, true);
+    const delta = at - prev;
+    map.set([delta & 0xff, (delta >> 8) & 0xff, delta >> 16], i * 5 + 2);
+    prev = at;
+    at += c.sol.length;
+  });
+  v.setUint16(sorted.length * 5, 0xffff, true);
+  return { sfx, map };
+}

package/packages/sci/src/gfx/cel.d.ts

@@ -0,0 +1,36 @@
+import type { Palette } from "./palette.ts";
+/** A single decoded image: 8-bit palette indices, row-major. */
+export interface Cel {
+    width: number;
+    height: number;
+    /** Signed displacement from the anchor point, as stored in the header. */
+    displaceX: number;
+    displaceY: number;
+    /** Palette index that is transparent. */
+    skipColor: number;
+    pixels: Uint8Array;
+}
+/**
+ * Decodes an SCI32 cel. The header layout is shared by views and pics:
+ *
+ *   +0  u16 width        +2  u16 height
+ *   +4  i16 displaceX    +6  i16 displaceY
+ *   +8  u8  skip colour  +9  u8  compression (0 = raw, 0x8A = RLE)
+ *   +24 u32 data offset (RLE control stream, or raw pixels)
+ *   +28 u32 literal offset (RLE literal pixels)
+ *   +32 u32 row table offset (RLE: height u32 control offsets, then height u32 literal offsets)
+ *
+ * All offsets are relative to the start of the resource.
+ */
+export declare function decodeCel(data: Uint8Array, headerOffset: number): Cel;
+export interface RgbaOptions {
+    mirror?: boolean;
+    /**
+     * Remap colours: indices that aren't real colours but tell the engine to transform
+     * whatever is underneath (e.g. 253/254 for shadows). Scripts configure the real
+     * transform at runtime; until the VM exists they're approximated as translucent black.
+     */
+    remap?: ReadonlyMap<number, number>;
+}
+/** Converts a cel to RGBA using `palette`, making the skip colour transparent. */
+export declare function celToRgba(cel: Cel, palette: Palette, { mirror, remap }?: RgbaOptions): Uint8ClampedArray<ArrayBuffer>;

package/packages/sci/src/gfx/cel.js

@@ -0,0 +1,82 @@
+const CelCompression = { None: 0, Rle: 0x8a };
+/**
+ * Decodes an SCI32 cel. The header layout is shared by views and pics:
+ *
+ *   +0  u16 width        +2  u16 height
+ *   +4  i16 displaceX    +6  i16 displaceY
+ *   +8  u8  skip colour  +9  u8  compression (0 = raw, 0x8A = RLE)
+ *   +24 u32 data offset (RLE control stream, or raw pixels)
+ *   +28 u32 literal offset (RLE literal pixels)
+ *   +32 u32 row table offset (RLE: height u32 control offsets, then height u32 literal offsets)
+ *
+ * All offsets are relative to the start of the resource.
+ */
+export function decodeCel(data, headerOffset) {
+    const v = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    const h = headerOffset;
+    const width = v.getUint16(h, true);
+    const height = v.getUint16(h + 2, true);
+    const cel = {
+        width,
+        height,
+        displaceX: v.getInt16(h + 4, true),
+        displaceY: v.getInt16(h + 6, true),
+        skipColor: data[h + 8],
+        pixels: new Uint8Array(width * height),
+    };
+    const compression = data[h + 9];
+    const dataOffset = v.getUint32(h + 24, true);
+    if (compression === CelCompression.None) {
+        cel.pixels.set(data.subarray(dataOffset, dataOffset + width * height));
+        return cel;
+    }
+    if (compression !== CelCompression.Rle) {
+        throw new Error(`Unknown cel compression 0x${compression.toString(16)}`);
+    }
+    const literalBase = v.getUint32(h + 28, true);
+    const rowTable = v.getUint32(h + 32, true);
+    for (let y = 0; y < height; y++) {
+        let ctrl = dataOffset + v.getUint32(rowTable + y * 4, true);
+        let lit = literalBase + v.getUint32(rowTable + (height + y) * 4, true);
+        const row = y * width;
+        for (let x = 0; x < width;) {
+            const op = data[ctrl++];
+            if (op & 0x80) {
+                const len = op & 0x3f;
+                // 11xxxxxx = run of transparent; 10xxxxxx = run of the next literal byte
+                const color = op & 0x40 ? cel.skipColor : data[lit++];
+                cel.pixels.fill(color, row + x, row + x + len);
+                x += len;
+            }
+            else {
+                // 0xxxxxxx = copy that many literal bytes
+                cel.pixels.set(data.subarray(lit, lit + op), row + x);
+                lit += op;
+                x += op;
+            }
+        }
+    }
+    return cel;
+}
+/** Converts a cel to RGBA using `palette`, making the skip colour transparent. */
+export function celToRgba(cel, palette, { mirror = false, remap } = {}) {
+    const out = new Uint8ClampedArray(cel.width * cel.height * 4);
+    for (let y = 0; y < cel.height; y++) {
+        for (let x = 0; x < cel.width; x++) {
+            const src = cel.pixels[y * cel.width + (mirror ? cel.width - 1 - x : x)];
+            if (src === cel.skipColor)
+                continue;
+            const o = (y * cel.width + x) * 4;
+            const remapAlpha = remap?.get(src);
+            if (remapAlpha !== undefined) {
+                out[o + 3] = remapAlpha;
+                continue;
+            }
+            out[o] = palette.rgb[src * 3];
+            out[o + 1] = palette.rgb[src * 3 + 1];
+            out[o + 2] = palette.rgb[src * 3 + 2];
+            out[o + 3] = 255;
+        }
+    }
+    return out;
+}

package/packages/sci/src/gfx/cel.ts

@@ -0,0 +1,110 @@
+import type { Palette } from "./palette.ts";
+
+/** A single decoded image: 8-bit palette indices, row-major. */
+export interface Cel {
+  width: number;
+  height: number;
+  /** Signed displacement from the anchor point, as stored in the header. */
+  displaceX: number;
+  displaceY: number;
+  /** Palette index that is transparent. */
+  skipColor: number;
+  pixels: Uint8Array;
+}
+
+const CelCompression = { None: 0, Rle: 0x8a } as const;
+
+/**
+ * Decodes an SCI32 cel. The header layout is shared by views and pics:
+ *
+ *   +0  u16 width        +2  u16 height
+ *   +4  i16 displaceX    +6  i16 displaceY
+ *   +8  u8  skip colour  +9  u8  compression (0 = raw, 0x8A = RLE)
+ *   +24 u32 data offset (RLE control stream, or raw pixels)
+ *   +28 u32 literal offset (RLE literal pixels)
+ *   +32 u32 row table offset (RLE: height u32 control offsets, then height u32 literal offsets)
+ *
+ * All offsets are relative to the start of the resource.
+ */
+export function decodeCel(data: Uint8Array, headerOffset: number): Cel {
+  const v = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  const h = headerOffset;
+  const width = v.getUint16(h, true);
+  const height = v.getUint16(h + 2, true);
+  const cel: Cel = {
+    width,
+    height,
+    displaceX: v.getInt16(h + 4, true),
+    displaceY: v.getInt16(h + 6, true),
+    skipColor: data[h + 8]!,
+    pixels: new Uint8Array(width * height),
+  };
+  const compression = data[h + 9]!;
+  const dataOffset = v.getUint32(h + 24, true);
+
+  if (compression === CelCompression.None) {
+    cel.pixels.set(data.subarray(dataOffset, dataOffset + width * height));
+    return cel;
+  }
+  if (compression !== CelCompression.Rle) {
+    throw new Error(`Unknown cel compression 0x${compression.toString(16)}`);
+  }
+
+  const literalBase = v.getUint32(h + 28, true);
+  const rowTable = v.getUint32(h + 32, true);
+
+  for (let y = 0; y < height; y++) {
+    let ctrl = dataOffset + v.getUint32(rowTable + y * 4, true);
+    let lit = literalBase + v.getUint32(rowTable + (height + y) * 4, true);
+    const row = y * width;
+
+    for (let x = 0; x < width; ) {
+      const op = data[ctrl++]!;
+      if (op & 0x80) {
+        const len = op & 0x3f;
+        // 11xxxxxx = run of transparent; 10xxxxxx = run of the next literal byte
+        const color = op & 0x40 ? cel.skipColor : data[lit++]!;
+        cel.pixels.fill(color, row + x, row + x + len);
+        x += len;
+      } else {
+        // 0xxxxxxx = copy that many literal bytes
+        cel.pixels.set(data.subarray(lit, lit + op), row + x);
+        lit += op;
+        x += op;
+      }
+    }
+  }
+  return cel;
+}
+
+export interface RgbaOptions {
+  mirror?: boolean;
+  /**
+   * Remap colours: indices that aren't real colours but tell the engine to transform
+   * whatever is underneath (e.g. 253/254 for shadows). Scripts configure the real
+   * transform at runtime; until the VM exists they're approximated as translucent black.
+   */
+  remap?: ReadonlyMap<number, number>; // index -> alpha 0..255
+}
+
+/** Converts a cel to RGBA using `palette`, making the skip colour transparent. */
+export function celToRgba(cel: Cel, palette: Palette, { mirror = false, remap }: RgbaOptions = {}): Uint8ClampedArray<ArrayBuffer> {
+  const out = new Uint8ClampedArray(cel.width * cel.height * 4);
+  for (let y = 0; y < cel.height; y++) {
+    for (let x = 0; x < cel.width; x++) {
+      const src = cel.pixels[y * cel.width + (mirror ? cel.width - 1 - x : x)]!;
+      if (src === cel.skipColor) continue;
+      const o = (y * cel.width + x) * 4;
+      const remapAlpha = remap?.get(src);
+      if (remapAlpha !== undefined) {
+        out[o + 3] = remapAlpha;
+        continue;
+      }
+      out[o] = palette.rgb[src * 3]!;
+      out[o + 1] = palette.rgb[src * 3 + 1]!;
+      out[o + 2] = palette.rgb[src * 3 + 2]!;
+      out[o + 3] = 255;
+    }
+  }
+  return out;
+}

package/packages/sci/src/gfx/palette.d.ts

@@ -0,0 +1,24 @@
+/** 256-colour VGA palette: 8-bit RGB triplets plus a per-entry "used" flag. */
+export interface Palette {
+    rgb: Uint8Array;
+    used: Uint8Array;
+}
+export declare const emptyPalette: () => Palette;
+/**
+ * Parses a "hunk palette", the SCI32 palette format used by palette resources and
+ * embedded in pics and views.
+ *
+ *   header (13 bytes): byte 10 = number of palettes
+ *   u16 per palette (skipped)
+ *   entry header (22 bytes):
+ *     +10 u8  first colour index
+ *     +14 u16 colour count
+ *     +16 u8  default "used" flag
+ *     +17 u8  shared-used: 1 = entries are RGB (3 bytes), 0 = used+RGB (4 bytes)
+ *   colours
+ *
+ * Returns a palette with only the entries this hunk defines marked used.
+ */
+export declare function parseHunkPalette(data: Uint8Array, offset?: number): Palette | undefined;
+/** Returns `base` with every used entry of `over` applied on top. */
+export declare function mergePalette(base: Palette, over: Palette | undefined): Palette;

package/packages/sci/src/gfx/palette.js

@@ -0,0 +1,49 @@
+export const emptyPalette = () => ({ rgb: new Uint8Array(768), used: new Uint8Array(256) });
+/**
+ * Parses a "hunk palette", the SCI32 palette format used by palette resources and
+ * embedded in pics and views.
+ *
+ *   header (13 bytes): byte 10 = number of palettes
+ *   u16 per palette (skipped)
+ *   entry header (22 bytes):
+ *     +10 u8  first colour index
+ *     +14 u16 colour count
+ *     +16 u8  default "used" flag
+ *     +17 u8  shared-used: 1 = entries are RGB (3 bytes), 0 = used+RGB (4 bytes)
+ *   colours
+ *
+ * Returns a palette with only the entries this hunk defines marked used.
+ */
+export function parseHunkPalette(data, offset = 0) {
+    const count = data[offset + 10] ?? 0;
+    if (count === 0)
+        return undefined;
+    const entry = offset + 13 + 2 * count;
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    const start = data[entry + 10];
+    const numColors = view.getUint16(entry + 14, true);
+    const defaultUsed = data[entry + 16];
+    const sharedUsed = data[entry + 17] !== 0;
+    const pal = emptyPalette();
+    let pos = entry + 22;
+    for (let i = start; i < start + numColors && i < 256; i++) {
+        pal.used[i] = sharedUsed ? defaultUsed : data[pos++];
+        pal.rgb[i * 3] = data[pos++];
+        pal.rgb[i * 3 + 1] = data[pos++];
+        pal.rgb[i * 3 + 2] = data[pos++];
+    }
+    return pal;
+}
+/** Returns `base` with every used entry of `over` applied on top. */
+export function mergePalette(base, over) {
+    if (!over)
+        return base;
+    const out = { rgb: base.rgb.slice(), used: base.used.slice() };
+    for (let i = 0; i < 256; i++) {
+        if (!over.used[i])
+            continue;
+        out.used[i] = 1;
+        out.rgb.set(over.rgb.subarray(i * 3, i * 3 + 3), i * 3);
+    }
+    return out;
+}

package/packages/sci/src/gfx/palette.ts

@@ -0,0 +1,56 @@
+/** 256-colour VGA palette: 8-bit RGB triplets plus a per-entry "used" flag. */
+export interface Palette {
+  rgb: Uint8Array; // 256 * 3
+  used: Uint8Array; // 256
+}
+
+export const emptyPalette = (): Palette => ({ rgb: new Uint8Array(768), used: new Uint8Array(256) });
+
+/**
+ * Parses a "hunk palette", the SCI32 palette format used by palette resources and
+ * embedded in pics and views.
+ *
+ *   header (13 bytes): byte 10 = number of palettes
+ *   u16 per palette (skipped)
+ *   entry header (22 bytes):
+ *     +10 u8  first colour index
+ *     +14 u16 colour count
+ *     +16 u8  default "used" flag
+ *     +17 u8  shared-used: 1 = entries are RGB (3 bytes), 0 = used+RGB (4 bytes)
+ *   colours
+ *
+ * Returns a palette with only the entries this hunk defines marked used.
+ */
+export function parseHunkPalette(data: Uint8Array, offset = 0): Palette | undefined {
+  const count = data[offset + 10] ?? 0;
+  if (count === 0) return undefined;
+
+  const entry = offset + 13 + 2 * count;
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  const start = data[entry + 10]!;
+  const numColors = view.getUint16(entry + 14, true);
+  const defaultUsed = data[entry + 16]!;
+  const sharedUsed = data[entry + 17]! !== 0;
+
+  const pal = emptyPalette();
+  let pos = entry + 22;
+  for (let i = start; i < start + numColors && i < 256; i++) {
+    pal.used[i] = sharedUsed ? defaultUsed : data[pos++]!;
+    pal.rgb[i * 3] = data[pos++]!;
+    pal.rgb[i * 3 + 1] = data[pos++]!;
+    pal.rgb[i * 3 + 2] = data[pos++]!;
+  }
+  return pal;
+}
+
+/** Returns `base` with every used entry of `over` applied on top. */
+export function mergePalette(base: Palette, over: Palette | undefined): Palette {
+  if (!over) return base;
+  const out: Palette = { rgb: base.rgb.slice(), used: base.used.slice() };
+  for (let i = 0; i < 256; i++) {
+    if (!over.used[i]) continue;
+    out.used[i] = 1;
+    out.rgb.set(over.rgb.subarray(i * 3, i * 3 + 3), i * 3);
+  }
+  return out;
+}

package/packages/sci/src/gfx/pic-file.d.ts

@@ -0,0 +1,46 @@
+import type { Palette } from "./palette.ts";
+import type { PicCel } from "./pic.ts";
+/**
+ * A pic resource with everything needed to write it back byte for byte. Measured on all 59
+ * pics of an SCI2 game (every one has this exact layout; all cels are uncompressed):
+ *
+ *   +0  u16 header size (14)  +2 u8 cel count  +3 u8 0  +4 u16 cel header size (42)
+ *   +6  u32 palette offset    +10 u16/u16 resolution (320,200, or 0,0 meaning the default)
+ *   cel headers, 42 bytes each:
+ *     +0 u16 width  +2 u16 height  +4 i16 displaceX  +6 i16 displaceY  +8 u8 skip colour
+ *     +9 u8 compression (0 = raw)  +10 u16 0  +12 u32 pixel bytes (w*h)
+ *     +16 u32 `unknown16` (2768 in most pics, 6 in a few; the engine ignores it)
+ *     +20 u32 0  +24 u32 pixel offset  +28 u32 0  +32 u32 0
+ *     +36 i16 priority  +38 i16 x  +40 i16 y
+ *   00 03 u32 palette size | hunk palette
+ *   00 04 u32 pixel bytes  | each cel's pixels, in cel order
+ */
+export interface PicFile {
+    resolution: [number, number];
+    cels: (PicCel & {
+        unknown16: number;
+    })[];
+    palette: HunkPaletteFile;
+}
+/**
+ * A hunk palette with its exact header bytes. Pics use one entry: `first` and
+ * `count` colours, each with its own "used" flag (4 bytes per colour) unless `shared`.
+ */
+export interface HunkPaletteFile {
+    /** The 13-byte hunk header (byte 0 = 14, byte 10 = entry count = 1). */
+    header: Uint8Array;
+    /** The first 10 bytes of the entry header (editor data; varies, never read). */
+    entryPrefix: Uint8Array;
+    first: number;
+    used: number[];
+    rgb: [number, number, number][];
+    /** Shared "used" flag: every colour is 3 bytes and takes `defaultUsed`. */
+    shared: boolean;
+    defaultUsed: number;
+}
+export declare function parseHunkPaletteFile(data: Uint8Array, offset: number): HunkPaletteFile;
+export declare function writeHunkPalette(p: HunkPaletteFile): Uint8Array;
+export declare function parsePicFile(data: Uint8Array): PicFile;
+export declare function writePic(pic: PicFile): Uint8Array;
+/** The palette a pic installs, as the engine sees it. */
+export declare function hunkToPalette(p: HunkPaletteFile): Palette;

package/packages/sci/src/gfx/pic-file.js

@@ -0,0 +1,114 @@
+const PIC_HEADER = 14;
+const CEL_HEADER = 42;
+export function parseHunkPaletteFile(data, offset) {
+    const v = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    if (data[offset + 10] !== 1)
+        throw new Error(`Hunk palette with ${data[offset + 10]} entries: only 1 is supported`);
+    const entry = offset + 13 + 2;
+    const first = data[entry + 10];
+    const count = v.getUint16(entry + 14, true);
+    const defaultUsed = data[entry + 16];
+    const shared = data[entry + 17] !== 0;
+    const used = [], rgb = [];
+    let p = entry + 22;
+    for (let i = 0; i < count; i++) {
+        used.push(shared ? defaultUsed : data[p++]);
+        rgb.push([data[p], data[p + 1], data[p + 2]]);
+        p += 3;
+    }
+    return { header: data.slice(offset, offset + 13), entryPrefix: data.slice(entry, entry + 10), first, used, rgb, shared, defaultUsed };
+}
+export function writeHunkPalette(p) {
+    const colors = p.rgb.length * (p.shared ? 3 : 4);
+    const out = new Uint8Array(13 + 2 + 22 + colors);
+    const v = new DataView(out.buffer);
+    out.set(p.header, 0);
+    out[10] = 1;
+    v.setUint16(13, 22 + colors, true);
+    const entry = 15;
+    out.set(p.entryPrefix, entry);
+    out[entry + 10] = p.first;
+    v.setUint16(entry + 14, p.rgb.length, true);
+    out[entry + 16] = p.defaultUsed;
+    out[entry + 17] = p.shared ? 1 : 0;
+    let o = entry + 22;
+    p.rgb.forEach((c, i) => {
+        if (!p.shared)
+            out[o++] = p.used[i];
+        out.set(c, o);
+        o += 3;
+    });
+    return out;
+}
+export function parsePicFile(data) {
+    const v = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    const count = data[2];
+    const cels = Array.from({ length: count }, (_, i) => {
+        const h = PIC_HEADER + CEL_HEADER * i;
+        if (data[h + 9] !== 0)
+            throw new Error(`Compressed pic cels aren't supported (cel ${i})`);
+        const width = v.getUint16(h, true), height = v.getUint16(h + 2, true);
+        const at = v.getUint32(h + 24, true);
+        return {
+            width, height,
+            displaceX: v.getInt16(h + 4, true), displaceY: v.getInt16(h + 6, true),
+            skipColor: data[h + 8],
+            pixels: data.slice(at, at + width * height),
+            unknown16: v.getUint32(h + 16, true),
+            priority: v.getInt16(h + 36, true), x: v.getInt16(h + 38, true), y: v.getInt16(h + 40, true),
+        };
+    });
+    return { resolution: [v.getUint16(10, true), v.getUint16(12, true)], cels, palette: parseHunkPaletteFile(data, v.getUint32(6, true)) };
+}
+export function writePic(pic) {
+    const palette = writeHunkPalette(pic.palette);
+    const headers = PIC_HEADER + CEL_HEADER * pic.cels.length;
+    const paletteAt = headers + 6;
+    const pixelsAt = paletteAt + palette.length + 6;
+    const pixelBytes = pic.cels.reduce((n, c) => n + c.width * c.height, 0);
+    const out = new Uint8Array(pixelsAt + pixelBytes);
+    const v = new DataView(out.buffer);
+    v.setUint16(0, PIC_HEADER, true);
+    out[2] = pic.cels.length;
+    v.setUint16(4, CEL_HEADER, true);
+    v.setUint32(6, paletteAt, true);
+    v.setUint16(10, pic.resolution[0], true);
+    v.setUint16(12, pic.resolution[1], true);
+    let at = pixelsAt;
+    pic.cels.forEach((c, i) => {
+        const h = PIC_HEADER + CEL_HEADER * i;
+        if (c.pixels.length !== c.width * c.height)
+            throw new Error(`cel ${i}: ${c.pixels.length} pixels for ${c.width}x${c.height}`);
+        v.setUint16(h, c.width, true);
+        v.setUint16(h + 2, c.height, true);
+        v.setInt16(h + 4, c.displaceX, true);
+        v.setInt16(h + 6, c.displaceY, true);
+        out[h + 8] = c.skipColor;
+        v.setUint32(h + 12, c.width * c.height, true);
+        v.setUint32(h + 16, c.unknown16, true);
+        v.setUint32(h + 24, at, true);
+        v.setInt16(h + 36, c.priority, true);
+        v.setInt16(h + 38, c.x, true);
+        v.setInt16(h + 40, c.y, true);
+        out.set(c.pixels, at);
+        at += c.pixels.length;
+    });
+    out.set([0, 3], headers);
+    v.setUint32(headers + 2, palette.length, true);
+    out.set(palette, paletteAt);
+    out.set([0, 4], paletteAt + palette.length);
+    v.setUint32(paletteAt + palette.length + 2, pixelBytes, true);
+    return out;
+}
+/** The palette a pic installs, as the engine sees it. */
+export function hunkToPalette(p) {
+    const pal = { rgb: new Uint8Array(768), used: new Uint8Array(256) };
+    p.rgb.forEach((c, i) => {
+        const idx = p.first + i;
+        if (idx > 255)
+            return;
+        pal.used[idx] = p.used[i];
+        pal.rgb.set(c, idx * 3);
+    });
+    return pal;
+}