@lewismoten/gamemaker-sandbox-engine 0.0.0-stage → 3.1.0

package/dist/types/formats/binary.d.ts

@@ -0,0 +1,44 @@
+export declare class Reader {
+    readonly bytes: Uint8Array;
+    offset: number;
+    constructor(bytes: Uint8Array, offset?: number);
+    get length(): number;
+    get eof(): boolean;
+    skip(n: number): this;
+    u8(): number;
+    i8(): number;
+    u16(): number;
+    i16(): number;
+    u32(): number;
+    i32(): number;
+    /** Copies n bytes (zero padded when the source is short). */
+    bytesOf(n: number): Uint8Array;
+    /** Reads a fixed size, NUL terminated string field. */
+    cstr(n: number): string;
+}
+export declare class Writer {
+    private buf;
+    offset: number;
+    constructor(initial?: number);
+    private ensure;
+    u8(v: number): this;
+    i8(v: number): this;
+    u16(v: number): this;
+    i16(v: number): this;
+    u32(v: number): this;
+    i32(v: number): this;
+    bytes(b: ArrayLike<number>, length?: number): this;
+    /** Writes a string into a fixed size NUL padded field (truncated to leave room for the NUL). */
+    cstr(s: string, length: number): this;
+    /**
+     * Writes a fixed size string field. When the text is unchanged the original raw
+     * bytes (including any garbage after the NUL) are kept so files round-trip exactly.
+     */
+    cstrOver(s: string, original: Uint8Array | undefined, length: number): this;
+    toBytes(): Uint8Array;
+}
+/** Decodes a NUL terminated string; the whole array when there is no NUL. */
+export declare function cString(bytes: Uint8Array): string;
+export declare function latin1Text(bytes: Uint8Array): string;
+/** One byte per character (low 8 bits of each UTF-16 code unit). */
+export declare function textBytes(text: string): Uint8Array;

package/dist/types/formats/blocks.d.ts

@@ -0,0 +1,52 @@
+export declare const BLEN = 20;
+export declare const BLOCK_SIZE = 420;
+export declare const BACKBL = 150;
+export declare const MONBL = 100;
+export declare const CHARBL = 50;
+export declare const TRANSPARENT = 255;
+export declare const SOLTOP = 1;
+export declare const SOLRIG = 2;
+export declare const SOLBOT = 4;
+export declare const SOLLEF = 8;
+export type BlockKind = 'bbl' | 'mbl' | 'cbl';
+export declare const BLOCK_COUNTS: Record<BlockKind, number>;
+export interface Block {
+    /** 20x20 palette indices, row major (y * 20 + x). 255 is transparent for sprites. */
+    pixels: Uint8Array;
+    /** Monster number to give birth to (background blocks). */
+    birthMon: number;
+    /** Clock ticks between monster births; 0 = never. */
+    birthTime: number;
+    xtra: Uint8Array;
+    /** Solid sides: SOLTOP | SOLRIG | SOLBOT | SOLLEF. */
+    solid: number;
+    /** Sides that hurt (unused by playgame, kept for fidelity). */
+    hitpt: number;
+    /** Score points when touched. */
+    scorePts: number;
+    /** Hit points added (negative hurts) when touched. */
+    chHitPt: number;
+    /** Block this one animates into after ntime ticks (== self means never). */
+    nextBl: number;
+    ntime: number;
+    /** Block this one becomes when touched (== self means unchanged). */
+    touchBl: number;
+    /** Gravity direction bits: 1 up, 2 right, 4 down, 8 left. */
+    grav: number;
+    /** Non-zero if the character can pick this block up. */
+    obj: number;
+    /** Which counter is affected: 1 lives, 3 money, 5..19 sequence counters, 20..29 extra counters. */
+    effect: number;
+    /** Amount the effect counter changes. */
+    eamt: number;
+}
+export declare function emptyBlock(index: number, transparent?: boolean): Block;
+export declare function parseBlocks(bytes: Uint8Array, count: number): Block[];
+export declare function serializeBlocks(blocks: Block[]): Uint8Array;
+export declare function newBlockSet(kind: BlockKind): Block[];
+/**
+ * Pixel lookup for a block drawn with one of the 8 orientations used by playgame
+ * (rotations/mirrors; see Sdrawspbloc in PLAYGAME.C). Returns the source index for
+ * destination (x, y).
+ */
+export declare function orientIndex(orient: number, x: number, y: number): number;

package/dist/types/formats/character.d.ts

@@ -0,0 +1,65 @@
+export declare const MAXSEQ = 20;
+export declare const MAXFRAME = 10;
+export declare const MAXINV = 10;
+export declare const METERS: number;
+export declare const INF_REPEAT = 32767;
+export declare const CHR_RECORD_SIZE = 3784;
+export declare const IDLESEQ = 0;
+export declare const DIESEQ = 1;
+export declare const HURTSEQ = 2;
+export declare const PICKUPSEQ = 3;
+export declare const DROPSEQ = 4;
+export declare const SEQUENCE_NAMES: string[];
+export interface Frame {
+    /** Pixel offset from the previous frame. */
+    x: number;
+    y: number;
+    /** Low nibble: orientation of top block. High nibble: orientation of bottom block. */
+    orient: number;
+    /** Top block number (CHARBL = none). When pic2 == MONBL, pic1 is the monster to give birth to. */
+    pic1: number;
+    /** Bottom block number. CHARBL+1 marks the end of the sequence. */
+    pic2: number;
+    /** Clock ticks (1/18.2 s) to wait before the next frame. */
+    pause: number;
+    extra: Uint8Array;
+}
+export interface Sequence {
+    frames: Frame[];
+    /** Activation key: high byte = PC scan code, low byte = ASCII. */
+    key: number;
+    /** Sound effect number (>= 30 means none). */
+    sound: number;
+    on: number;
+    /** Background block required in inventory to use this sequence (150 = none). */
+    bloc: number;
+    /** Non-zero: sequence cannot be interrupted. */
+    ground: number;
+    /** Joystick button (0 any, 1/2 button, 4 none). */
+    jstkBut: number;
+    /** Joystick direction (0 none, 1-8 directions, 9 any). */
+    jstkMov: number;
+    /** Non-zero: one run per key press. */
+    norepeat: number;
+    /** Non-zero: motion adds to momentum instead of moving directly. */
+    momentum: number;
+    xtra: Uint8Array;
+}
+export interface Character {
+    sequences: Sequence[];
+    x: number[];
+    y: number[];
+    cframe: number;
+    cseq: number;
+    inv: Uint8Array;
+    /** Repetition counters: 0 hit points, 1 lives, 3 money, 5..19 sequence counters, 20..29 extra. */
+    meter: number[];
+    /** Raw bytes of the unused second player record. */
+    rest: Uint8Array;
+}
+export declare function parseCharacter(bytes: Uint8Array): Character;
+export declare function serializeCharacter(c: Character): Uint8Array;
+export declare function emptyFrame(end?: boolean): Frame;
+export declare function newCharacter(): Character;
+/** Number of frames before the end marker. */
+export declare function frameCount(s: Sequence): number;

package/dist/types/formats/cmf.d.ts

@@ -0,0 +1,33 @@
+export declare const CMF_GAMEMAKER_CLOCK = 146;
+interface CmfFile {
+    version: number;
+    ticksPerBeat: number;
+    /** Ticks per second the song was converted for. */
+    clockTicks: number;
+    channelUsed: Uint8Array;
+    /** 16 byte SBI instrument records. */
+    instruments: Uint8Array[];
+    basicTempo: number;
+    /** The event stream (music block to end of file). */
+    music: Uint8Array;
+}
+export declare function isCmf(bytes: Uint8Array): boolean;
+export declare function parseCmf(bytes: Uint8Array): CmfFile;
+/** One event of a song: when (in ticks from the start) and its MIDI bytes. */
+export interface CmfEvent {
+    tick: number;
+    data: number[];
+}
+interface CmfSong {
+    /** 16-byte SBI FM instruments; instrument n starts on MIDI channel n. */
+    instruments: Uint8Array[];
+    events: CmfEvent[];
+    ticksPerBeat?: number;
+    basicTempo?: number;
+}
+/**
+ * Writes a Creative Music File at Game-Maker's 146 ticks a second (PLAYGAME refuses any
+ * other clock). Events are sorted by tick; the song ends with an end-of-track marker.
+ */
+export declare function encodeCmf(song: CmfSong): Uint8Array;
+export {};

package/dist/types/formats/fli.d.ts

@@ -0,0 +1,45 @@
+interface FliAnimation {
+    width: number;
+    height: number;
+    frameCount: number;
+    /** Delay per frame in 1/70 s (FLI) — FLC files are converted from milliseconds. */
+    speed: number;
+    /** Byte offsets of each frame record. */
+    frames: number[];
+    bytes: Uint8Array;
+}
+interface FliCanvas {
+    pixels: Uint8Array;
+    /** 6-bit palette, 768 bytes. */
+    palette: Uint8Array;
+}
+export declare function isFli(bytes: Uint8Array): boolean;
+export declare function parseFli(bytes: Uint8Array): FliAnimation;
+export declare function newFliCanvas(anim: FliAnimation): FliCanvas;
+/** Applies frame n to the canvas. Returns true if the palette changed. */
+export declare function applyFliFrame(anim: FliAnimation, n: number, c: FliCanvas): boolean;
+/**
+ * The most bytes a chunk (with its 6-byte header) may take. PLAYGAME reads an .FLI through
+ * FileRead (code/DRV/FILECLSS.CPP): one buffer of up to 0xFFF0 bytes, 2 bytes smaller each
+ * time `new` fails, and FrameHeader::View (code/Image/FLI/FLI.CPP) hands each chunk to its
+ * decoder only when the whole chunk fits in that buffer (FileRead::Peek). With a game loaded
+ * through XFERPLAY there is less memory, and a 63K chunk drew garbage where a 32.7K one
+ * played. 16,000 bytes is under half of that 32.7K, so it fits with a quarter of the 64K
+ * buffer PLAYGAME asks for; splitting a full 64,000-pixel frame into bands this size costs a
+ * few dozen bytes of headers.
+ */
+export declare const FLI_CHUNK_MAX = 16000;
+/**
+ * Writes an Autodesk Animator .FLI (Game-Maker shows 320x200): each frame run-length coded
+ * or as the lines that changed, the 6-bit palette in the first frame, and a closing "ring"
+ * frame that leads back to the start. No chunk is bigger than FLI_CHUNK_MAX: a bigger frame
+ * is split into bands of lines. `speed` is the delay after each frame in 1/70 s.
+ */
+export declare function encodeFli(frames: Uint8Array[], palette: Uint8Array, opts?: {
+    width?: number;
+    height?: number;
+    speed?: number;
+    /** A palette per frame (fades, flashes); changes are stored where they happen. */ palettes?: Uint8Array[];
+    /** Code runs of a color inside changed spans as run packets too (smaller deltas for drawn art). */ runs?: boolean;
+}): Uint8Array;
+export {};

package/dist/types/formats/game.d.ts

@@ -0,0 +1,72 @@
+export declare const NOSCENE = 65535;
+export declare const STARTTYPE = 1;
+export declare const ENDTYPE = 2;
+export declare const ADVTYPE = 10;
+export declare const SCENEDESCLEN = 20;
+export declare const SCENEFILES = 20;
+export declare const MAXSCENELINKS = 20;
+export declare const GAM_VERSION = 300;
+/** Scene 0 (title/menu) file slots. */
+export declare const START_FILES: readonly ["Title graphic", "Title song", "Menu graphic", "Menu song", "Storyline graphic", "Storyline song", "Game instructions", "Beginning credits", "High score backdrop", "Load game background", "Save game background", "Demo recording"];
+/** Scene 1 (game over) file slots. */
+export declare const END_FILES: readonly ["Game won graphic", "Game won song", "Game lost graphic", "Game lost song"];
+/** Adventure (level) scene file slots. */
+export declare const ADV_FILES: readonly ["Palette", "Map", "Background block set", "Monsters", "Monster block set", "Character", "Character block set", "Sound set", "Sound Blaster music", "Level intro graphic", "Level exit graphic"];
+export declare const ADV_EXTS: readonly ["pal", "map", "bbl", "mon", "mbl", "chr", "cbl", "snd", "cmf", "graphic", "graphic"];
+export declare const GRAPHIC_EXTS: string[];
+export interface Point {
+    x: number;
+    y: number;
+}
+export interface Link {
+    /** Scene to go to, NOSCENE = unused. */
+    toScene: number;
+    /** Map block that triggers the link. */
+    from: Point;
+    /** Map block where the character starts in the next scene. */
+    to: Point;
+}
+interface ScrollInfo {
+    /** 0 = no scrolling, 0xFF = scroll when the character nears the edge. */
+    up: number;
+    down: number;
+    left: number;
+    right: number;
+    style: number;
+    xtra: Uint8Array;
+}
+export interface Scene {
+    gametype: number;
+    /** Position of the scene box in the integrator's world view. */
+    pos: Point;
+    scroll: ScrollInfo;
+    numLinks: number;
+    desc: string;
+    descRaw?: Uint8Array;
+    /** File names by slot ('' = none). */
+    files: string[];
+    links: Link[];
+}
+export interface Game {
+    version: number;
+    /** Raw 256 byte header so unknown bytes survive a round trip. */
+    header: Uint8Array;
+    filesPerScene: number;
+    linksPerScene: number;
+    scenes: Scene[];
+    /** Original string pool, kept to reproduce the file exactly when nothing changed. */
+    pool?: Uint8Array;
+    poolOffsets?: number[][];
+    /** True when the file was converted from the pre-3.00 layout. */
+    converted: boolean;
+}
+export declare function emptyLink(): Link;
+export declare function emptyScene(gametype?: number): Scene;
+export declare function defaultHeader(): Uint8Array;
+export declare function newGame(title?: string): Game;
+export declare function parseGame(bytes: Uint8Array): Game;
+export declare function serializeGame(g: Game): Uint8Array;
+export declare function sceneKind(s: Scene): 'start' | 'end' | 'adventure' | 'unused';
+export declare function fileSlotsFor(s: Scene): readonly string[];
+export declare function slotExtensions(s: Scene): readonly string[];
+export {};

package/dist/types/formats/gif.d.ts

@@ -0,0 +1,15 @@
+import { type Palette } from './palette';
+export interface IndexedImage {
+    width: number;
+    height: number;
+    pixels: Uint8Array;
+    palette: Palette;
+}
+export declare function isGif(bytes: Uint8Array): boolean;
+export declare function decodeGif(bytes: Uint8Array): IndexedImage;
+export declare function lzwDecode(data: Uint8Array, minCodeSize: number, pixelCount: number, done?: {
+    count: number;
+}): Uint8Array;
+/** Encodes an 8-bit indexed image as GIF87a with a full 256 color table. */
+export declare function encodeGif(img: IndexedImage): Uint8Array;
+export declare function lzwEncode(pixels: Uint8Array, minCodeSize: number): Uint8Array;

package/dist/types/formats/graphicScripts.d.ts

@@ -0,0 +1,18 @@
+interface Backdrop {
+    x: number;
+    y: number;
+    gif: string;
+}
+export declare function parseBackdrop(bytes: Uint8Array): Backdrop;
+export declare function serializeBackdrop(b: Backdrop): Uint8Array;
+export interface SlideEntry {
+    name: string;
+    /** Seconds to wait; undefined = the caller's default. */
+    pause?: number;
+}
+/** Port of FileEntry/FileListClass: "name [pause]" per line, names up to 15 chars. */
+export declare function parseSlideList(bytes: Uint8Array): SlideEntry[];
+export declare function serializeSlideList(entries: SlideEntry[]): Uint8Array;
+/** Splits a .txt file into the 31 character lines Display_File shows (fgets with a 32 byte buffer). */
+export declare function textLines(bytes: Uint8Array): string[];
+export {};

package/dist/types/formats/highscore.d.ts

@@ -0,0 +1,10 @@
+export interface HighScore {
+    score: number;
+    name: string;
+}
+export declare const HIGH_SCORES = 10;
+export declare function parseHighScores(bytes: Uint8Array): HighScore[];
+export declare function serializeHighScores(list: HighScore[]): Uint8Array;
+/** Port of CheckHighScores' ranking: returns the 0-based place, or -1 if not in the top ten. */
+export declare function placeFor(list: HighScore[], score: number): number;
+export declare function insertHighScore(list: HighScore[], place: number, entry: HighScore): HighScore[];

package/dist/types/formats/map.d.ts

@@ -0,0 +1,24 @@
+export declare const MLEN = 100;
+export declare const MWID = 100;
+export declare const LASTMM = 200;
+export interface PlacedMonster {
+    /** Monster number in the .mon file; LASTMON (64) or more = empty slot. */
+    monnum: number;
+    status: number;
+    xtra: number;
+    curx: number;
+    cury: number;
+    extra: number;
+}
+export interface GameMap {
+    /** Background block per cell (index = y * 100 + x). */
+    blocks: Uint8Array;
+    /** Placed monster index per cell (LASTMM = none). */
+    mons: Uint8Array;
+    monsters: PlacedMonster[];
+}
+export declare function parseMap(bytes: Uint8Array): GameMap;
+export declare function serializeMap(m: GameMap): Uint8Array;
+export declare function newMap(): GameMap;
+/** Rebuilds the per-cell monster index from the placed monster list (as the map editor does). */
+export declare function reindexMonsters(m: GameMap): void;

package/dist/types/formats/monster.d.ts

@@ -0,0 +1,48 @@
+export declare const LASTMON = 64;
+export declare const LASTSL = 20;
+export declare const MAXMARCH = 10;
+export declare const MONSTER_SIZE = 300;
+export declare const NORMALMOVEMENT = 0;
+export declare const ATTACKMOVEMENT = 1;
+export interface March {
+    /** Block offset from the previous corner (first corner: from the start). */
+    x: number;
+    y: number;
+    /** Speed (pixels per tick) to move toward this corner; 0 ends the path. */
+    pic: number;
+    /** Picture orientation (0-7) while moving to this corner. */
+    orient: number;
+}
+export interface Monster {
+    used: number;
+    /** Non-zero: monster is not affected by gravity (unused by playgame). */
+    fly: number;
+    jump: number;
+    stick: number;
+    /** Higher power kills lower power; >= 100 (CHARPOWER) can't be killed by touching the character. */
+    power: number;
+    /** Non-zero: monster stops at solid blocks. */
+    thru: number;
+    /** Animation: [block number (>= 100 ends), ticks to show] x 21. */
+    pic: [number, number][];
+    lasttime: number;
+    /** Monster this becomes when it dies (64 = none). */
+    newmon: number;
+    /** Score bonus when killed by the character's weapons. */
+    upscore: number;
+    xtra: Uint8Array;
+    /** 0 no attack path, 1 attack path is absolute, 2 relative to the character. */
+    activate: number;
+    /** -2 never dies, -1 dies after path, 0 dies when killed, > 0 lifetime in ticks. */
+    end: number;
+    /** 0 follow path, 1..63 toward the character at this speed (negative: away), >= 64 random (speed = towards >> 6). */
+    towards: number;
+    close: [number, number];
+    /** [normal path, attack path], 10 corners each. */
+    march: [March[], March[]];
+    cur: March;
+}
+export declare function parseMonsters(bytes: Uint8Array): Monster[];
+export declare function serializeMonsters(mons: Monster[]): Uint8Array;
+export declare function emptyMonster(): Monster;
+export declare function newMonsterSet(): Monster[];

package/dist/types/formats/palette.d.ts

@@ -0,0 +1,15 @@
+export declare const PALETTE_SIZE: number;
+export type Palette = Uint8Array;
+export declare function parsePalette(bytes: Uint8Array): Palette;
+export declare function serializePalette(pal: Palette): Uint8Array;
+/** Expands 6-bit VGA components to packed 0xAABBGGRR values for ImageData/Uint32Array. */
+export declare function paletteToRGBA(pal: Palette): Uint32Array;
+export declare function vga8(v: number): number;
+export declare function paletteCss(pal: Palette, index: number): string;
+/**
+ * Port of RGBdata::Match: the palette index whose color is closest to (r,g,b)
+ * (6-bit components), by squared distance; first match wins ties.
+ */
+export declare function matchColor(pal: Palette, r: number, g: number, b: number): number;
+/** Default palette GameMaker editors start with: a rainbow ramp plus grays (port of RainbowCols-ish). */
+export declare function defaultPalette(): Palette;

package/dist/types/formats/recording.d.ts

@@ -0,0 +1,7 @@
+export declare const RECLEN = 1000;
+export interface RecordedKey {
+    delta: number;
+    key: number;
+}
+export declare function parseRecording(bytes: Uint8Array): RecordedKey[];
+export declare function serializeRecording(keys: RecordedKey[]): Uint8Array;

package/dist/types/formats/sound.d.ts

@@ -0,0 +1,13 @@
+export declare const LASTSND = 30;
+export declare const NUMFREQ = 36;
+export declare const SOUND_NAMES: string[];
+export interface SoundSet {
+    /** freqs[n] has NUMFREQ frequencies in Hz (0 = silence). */
+    freqs: Uint16Array[];
+    /** Digital .voc file name (without extension) for each effect, '' = use PC speaker. */
+    digital: string[];
+    digitalRaw: Uint8Array[];
+}
+export declare function parseSoundSet(bytes: Uint8Array): SoundSet;
+export declare function serializeSoundSet(s: SoundSet): Uint8Array;
+export declare function newSoundSet(): SoundSet;

package/dist/types/formats/voc.d.ts

@@ -0,0 +1,13 @@
+interface DecodedVoc {
+    sampleRate: number;
+    samples: Float32Array;
+}
+export declare function isVoc(bytes: Uint8Array): boolean;
+export declare function decodeVoc(bytes: Uint8Array): DecodedVoc;
+/**
+ * Encodes mono samples (-1..1) as an 8-bit unsigned PCM Creative Voice File, the kind a
+ * Sound Blaster plays. The rate is stored as a time constant, so it is rounded the way
+ * the card did (11025 Hz is stored as 10,989 Hz: time constant 165, 1,000,000 / 91).
+ */
+export declare function encodeVoc(samples: Float32Array, sampleRate?: number): Uint8Array;
+export {};

package/dist/types/gfx/cp437Glyphs.d.ts

@@ -0,0 +1,2 @@
+/** The whole CP437 8x8 font: FONT8X8's ASCII plus GLYPHS, with NUL blank (256 x 8 rows, LSB = leftmost pixel). */
+export declare const FONT_CP437: Uint8Array;

package/dist/types/gfx/font8x8.d.ts

@@ -0,0 +1,2 @@
+/** 256 glyphs x 8 rows; characters outside printable ASCII are drawn as a box. */
+export declare const FONT8X8: Uint8Array;

package/dist/types/gfx/screen.d.ts

@@ -0,0 +1,46 @@
+export declare const SIZEX = 320;
+export declare const SIZEY = 200;
+export declare class Screen {
+    readonly pixels: Uint8Array<ArrayBuffer>;
+    /** Palette currently shown by the "DAC" (6-bit components). */
+    readonly palette: Uint8Array<ArrayBuffer>;
+    readonly canvas: HTMLCanvasElement;
+    private ctx;
+    private image;
+    private rgba;
+    private lut;
+    private dirty;
+    constructor(canvas: HTMLCanvasElement);
+    setPalette(pal: ArrayLike<number>): void;
+    /** SetAllPalTo: every entry the same color. */
+    setPaletteTo(r: number, g: number, b: number): void;
+    setColor(index: number, r: number, g: number, b: number): void;
+    private updateLut;
+    markDirty(): void;
+    present(): void;
+    clear(col?: number): void;
+    point(x: number, y: number, col: number): void;
+    getCol(x: number, y: number): number;
+    /** BoxFill: inclusive corners. */
+    boxFill(x: number, y: number, x1: number, y1: number, col: number): void;
+    /** Box: rectangle outline. */
+    box(x: number, y: number, x1: number, y1: number, col: number): void;
+    line(x0: number, y0: number, x1: number, y1: number, col: number): void;
+    /**
+     * GPutChar: transparent background, 8x8 glyph from the BIOS font (GetROMFont). That ROM font
+     * holds only characters 0-127, and GPutChar takes a signed char (code/GM/GRAPHC.C), so 128-255
+     * read whatever lies before the font: scribbles on a real VGA card. They draw nothing here.
+     * (Text read from a file with TextDecoder('latin1') brings 0x80-0x9F as code points above 255.)
+     */
+    putChar(x: number, y: number, col: number, code: number): void;
+    /** GWrite: '\n' moves to the next line at the starting column. */
+    write(x: number, y: number, col: number, text: string): void;
+    /** drawblk / BufDrawBlk: opaque 20x20 block, clipped. */
+    drawBlock(x: number, y: number, pixels: Uint8Array): void;
+    /** BufDrawSpBlk: transparent (255) sprite with one of 8 orientations, clipped. */
+    drawSprite(x: number, y: number, orient: number, pixels: Uint8Array): void;
+    /** Copies an indexed image (e.g. a GIF) with its top-left at (-sx, -sy). */
+    drawImage(pixels: Uint8Array, width: number, height: number, sx?: number, sy?: number): void;
+    snapshot(): Uint8Array;
+    restore(snap: Uint8Array): void;
+}

package/dist/types/input/chords.d.ts

@@ -0,0 +1,22 @@
+/** The DOM key codes of the four arrow keys (the keypad's own 8 4 6 2 never chord). */
+export declare const ARROW_CODES: Record<string, number>;
+/**
+ * Turns the arrow keys physically held into the keys the game should see held.
+ * `bound` says whether the game uses a key; chords whose key it doesn't use stay plain arrows.
+ */
+export declare function chordKeys(held: ReadonlySet<number>, bound: (scan: number) => boolean): Set<number>;
+/**
+ * Tracks the arrows held and the keys the game was told about, and returns the scan code
+ * events (bit 7 set = released) that take the game from what it saw to what it should see.
+ * Releases come before presses, so the game never sees a chord and its arrows held at once.
+ */
+export declare class ArrowChords {
+    bound: (scan: number) => boolean;
+    private held;
+    private shown;
+    constructor(bound?: (scan: number) => boolean);
+    /** An arrow key went down or up; returns the events for the game. */
+    arrow(scan: number, pressed: boolean): number[];
+    /** Forgets everything (focus lost: the keyboard lets go of every key). */
+    reset(): void;
+}

package/dist/types/input/deskMouse.d.ts

@@ -0,0 +1,14 @@
+/** dx, dy in 320x200 screen pixels (fractions allowed); buttons: 1 = left, 2 = right. */
+type DeskMouseListener = (dx: number, dy: number, buttons: number) => void;
+/** Listens to the desk mouse; returns the function that stops listening. */
+export declare function listenDeskMouse(f: DeskMouseListener): () => void;
+/** The desk mouse rolled by (dx, dy) screen pixels with these buttons down. */
+export declare function deskMouse(dx: number, dy: number, buttons: number): void;
+/** Moves a pointer by whole pixels, keeping the fractions for next time. */
+export declare class Mickeys {
+    private rx;
+    private ry;
+    /** Whole pixels to move now for a roll of (dx, dy). */
+    take(dx: number, dy: number): [number, number];
+}
+export {};

package/dist/types/input/keyboard.d.ts

@@ -0,0 +1,39 @@
+import { ArrowChords } from './chords';
+export interface TypedKey {
+    scan: number;
+    /** ASCII code (0 for extended keys such as arrows). */
+    ascii: number;
+    /** The DOM key, for text entry. */
+    key: string;
+}
+export declare class Keyboard {
+    /** Scan code events; bit 7 set = released. */
+    readonly events: number[];
+    readonly typed: TypedKey[];
+    readonly down: Set<number>;
+    private target?;
+    private waiters;
+    /** Two arrows held together stand for the keypad key between them when the game binds it. */
+    readonly chords: ArrowChords;
+    /** Which keys the game binds, for arrow chords (none: arrows stay arrows). */
+    set chordable(bound: ((scan: number) => boolean) | undefined);
+    private onDown;
+    private onUp;
+    private onBlur;
+    attach(target?: EventTarget): void;
+    detach(): void;
+    private handle;
+    /** One scan code event for the game (an arrow chord's press or release). */
+    private apply;
+    /** Simulates a key event (touch controls, gamepad, demo playback). */
+    inject(scan: number, pressed: boolean): void;
+    /** Queues a recorded scan code as-is (demo playback while a screen waits for a key). */
+    feed(scan: number): void;
+    releaseAll(): void;
+    /** bioskey(1)/bioskey(0): peek or take the next typed key. */
+    peekKey(): TypedKey | undefined;
+    readKey(): TypedKey | undefined;
+    clear(): void;
+    /** Resolves on the next key press. */
+    nextPress(): Promise<void>;
+}

package/dist/types/input/scancodes.d.ts

@@ -0,0 +1,3 @@
+export declare const SCAN: Record<string, number>;
+export declare function scanToAscii(scan: number): number;
+export declare function scanName(scan: number): string;