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

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

@@ -0,0 +1,79 @@
+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;
+/**
+ * The game's name for showing outside DOS: the start scene's description, which holds CP437
+ * byte codes (the menu draws them with the PC font), as the Unicode a PC showed, without the
+ * spaces and frame characters (box lines, blocks) authors put around it to center or box it.
+ * Empty when there is none.
+ */
+export declare function gameTitle(game: Game): string;
+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.js';
+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/gifProgressive.d.ts

@@ -0,0 +1,46 @@
+import { type IndexedImage } from './gif.js';
+import { type Palette } from './palette.js';
+/** A GIF read from as many of its bytes as there are so far. */
+interface PartialGif {
+    width: number;
+    height: number;
+    /** 6-bit VGA values (the DAC), as decodeGif() gives them. */
+    palette: Palette;
+    /** How many colors the file's color table has. */
+    colors: number;
+    interlaced: boolean;
+    /** Indexes in file order: row by row as stored (interlaced files store their passes in turn). */
+    stored: Uint8Array;
+    /** How many pixels of `stored` have arrived. */
+    received: number;
+    /** All the pixels have arrived. */
+    complete: boolean;
+    /** Pixel width/height ratio from the GIF89a header (1 when not given). */
+    aspect: number;
+}
+/** The picture row each stored row is, and how many rows it covers until finer rows arrive. */
+export declare function storedRows(height: number, interlaced: boolean): {
+    y: number;
+    span: number;
+}[];
+/**
+ * Reads the start of a GIF. Undefined until the header, color table and image descriptor
+ * have all arrived (a viewer can't draw anything before that).
+ */
+export declare function decodePartialGif(bytes: Uint8Array): PartialGif | undefined;
+/**
+ * The picture as far as it has arrived, rows in screen order. Rows not yet received are
+ * `blank`, or, in an interlaced file, a copy of the coarser row above them.
+ */
+export declare function partialPixels(g: PartialGif, blank?: number): Uint8Array;
+/**
+ * Encodes an image as GIF89a: interlaced if asked, with a color table just big enough for
+ * `colors` and an optional pixel aspect byte ((n + 15) / 64 = pixel width / height; 38 is
+ * the tall pixels of 320x200 and 640x400 on a 4:3 screen).
+ */
+export declare function encodeGif89(img: IndexedImage, opts?: {
+    interlaced?: boolean;
+    colors?: number;
+    aspect?: number;
+}): Uint8Array;
+export {};

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/jpeg.d.ts

@@ -0,0 +1,20 @@
+/** A JPEG decoded from as much of it as there is. */
+export interface PartialJpeg {
+    width: number;
+    height: number;
+    /** 1 (grayscale) or 3 (RGB). */
+    channels: number;
+    /** width * height * channels bytes. */
+    pixels: Uint8Array;
+    /** Per pixel: 1 once that part of the picture has arrived (a progressive file: all of it after its first scan). */
+    shown: Uint8Array;
+    progressive: boolean;
+    /** Scans that have fully arrived. */
+    scans: number;
+    complete: boolean;
+    /** Pixel width / height from the JFIF header (1 when not given). */
+    aspect: number;
+}
+export declare function isJpeg(bytes: Uint8Array): boolean;
+/** Decodes as much of a JPEG as there is; undefined until the frame header has arrived. */
+export declare function decodePartialJpeg(data: Uint8Array): PartialJpeg | undefined;

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/colorVision.d.ts

@@ -0,0 +1,26 @@
+export type Rgb = [number, number, number];
+export type Vision = 'protan' | 'deutan' | 'tritan';
+/** Machado et al. 2009, Table 1, severity 1.0 (rows give linear R, G, B out). */
+export declare const MACHADO: {
+    readonly protan: readonly [0.152286, 1.052583, -0.204868, 0.114503, 0.786281, 0.099216, -0.003882, -0.048116, 1.051998];
+    readonly deutan: readonly [0.367322, 0.860646, -0.227968, 0.280085, 0.672501, 0.047413, -0.01182, 0.04294, 0.968881];
+    readonly tritan: readonly [1.255528, -0.076749, -0.178779, -0.078411, 0.930809, 0.147602, 0.004733, 0.691367, 0.3039];
+};
+/** An sRGB value (0..1) as linear light (0..1). */
+export declare const srgbToLinear: (c: number) => number;
+/** Linear light as an sRGB value (0..1), clamped first. */
+export declare function linearToSrgb(l: number): number;
+/** A linear RGB color as the given kind of color vision sees it, each channel clamped to 0..1. */
+export declare function simulateLinear(rgb: Rgb, matrix: readonly number[]): Rgb;
+/** Linear RGB to CIELAB (D65 white). */
+export declare function lab([r, g, b]: Rgb): Rgb;
+/** CIELAB back to linear RGB (unclamped). */
+export declare function unlab([L, a, b]: Rgb): Rgb;
+/** How far apart two CIELAB colors look (CIE76 delta E: about 2.3 is just noticeable side by side). */
+export declare const deltaELab: (a: Rgb, b: Rgb) => number;
+/** A color (0-255 per channel) as the given kind of color vision sees it. */
+export declare function simulateBytes(c: Rgb, v: Vision): Rgb;
+/** How far apart two colors (0-255 per channel) look: CIE76 delta E; about 2 is just noticeable, over 25 plainly different. */
+export declare const deltaEBytes: (a: Rgb, b: Rgb) => number;
+/** A whole VGA palette (768 bytes of 6-bit values) as the given kind of color vision sees it. */
+export declare function simulatePalette(pal: Uint8Array, v: Vision): Uint8Array;

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,50 @@
+export declare const SIZEX = 320;
+export declare const SIZEY = 200;
+export declare class Screen {
+    /** Observer metadata only: PLAYGAME's CropScreen is active (no effect on rendering). */
+    dosCropped: boolean;
+    /** Level number for screen captures; retained during function-key screens. */
+    sceneNumber: number;
+    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/index.d.ts

@@ -0,0 +1,4 @@
+export { Machine, GameAborted } from './engine/machine.js';
+export { runGame, loadGameFile, gameNameOf, type RunOptions } from './engine/game.js';
+export { GameFiles, normalize, cdName, type FileStream } from './core/gameFiles.js';
+export { AudioEngine } from './audio/engine.js';

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.js';
+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;

package/dist/types/player/fileExtensions.d.ts

@@ -0,0 +1,44 @@
+interface ExtKind {
+    /** Game-Maker's own extension, lower case, no dot. */
+    ext: string;
+    label: string;
+    note: string;
+    /**
+     * File offsets of each ".ext" in XFERPLAY 3.00, the one it opens files by first; none for the
+     * kinds the .gam names in full.
+     */
+    offsets: number[];
+}
+export declare const EXT_KINDS: ExtKind[];
+/** The patch id for a kind. */
+export declare const extId: (ext: string) => string;
+/** The kind an id names, if it is one. */
+export declare function extKind(id: string): ExtKind | undefined;
+/** Why `value` can't be kind `ext`'s new extension, or undefined when it can. */
+export declare function extValueProblem(ext: string, value: unknown): string | undefined;
+/** The kinds a set of patches renames: Game-Maker's extension -> the new one (both lower case, no dot). */
+export declare function extensionMap(patches: Record<string, unknown> | undefined): Map<string, string>;
+/** Kinds that share a new extension (each problem names both), for the panel and the export. */
+export declare function extensionClashes(patches: Record<string, unknown> | undefined): Map<string, string>;
+/** The patches without any renamed extensions (what the web player and web-page exports carry). */
+export declare function withoutExtensions<T>(patches: Record<string, T>): Record<string, T>;
+/** Writes each renamed kind's extension into every one of its copies in the player. */
+export declare function writeExtensions(exe: Uint8Array, patches: Record<string, unknown>): void;
+/**
+ * A player's renamed extensions as patches, for the kinds whose copies all agree and keep the
+ * rules; `read` lists the kinds read (so their bytes are explained).
+ */
+export declare function readExtensions(exe: Uint8Array): {
+    patches: Record<string, string>;
+    read: string[];
+};
+/** Writes Game-Maker's own extension back into every copy of the kinds listed. */
+export declare function writeStockExtensions(exe: Uint8Array, kinds: string[]): void;
+/**
+ * The CD's extension -> the one this player opens files by instead ('' when blanked), lower
+ * case with the dot, for the player's own kinds that differ. (Virtual Mario blanked .gam.)
+ */
+export declare function renamedExtensions(exe: Uint8Array): Record<string, string>;
+/** Acord Games' extensions, as NEVER.EXE and its games' files use them (.lst, .voc and .dat kept). */
+export declare const ACORD_EXTENSIONS: Record<string, string>;
+export {};

package/dist/types/player/patchRules.d.ts

@@ -0,0 +1,24 @@
+import { type FramePatch, type PatchEntry } from './patchTable.js';
+export type PatchValue = string | number | number[];
+/** A project's DOS player choices: patch id -> value (patchTable.ts says what each takes). */
+export type PlayerPatches = Record<string, PatchValue>;
+export declare function patchEntry(id: string): PatchEntry | undefined;
+/** A printf format's % codes, in order. */
+export declare function formatCodes(text: string): string[];
+/** Why `value` can't be written for `entry`, or undefined when it can. */
+export declare function patchProblem(entry: PatchEntry, value: unknown): string | undefined;
+/** The largest value a frame's left, top, right or bottom (i: 0-3) takes: a push imm8 is sign-extended, so a 1-byte one stops at 127. */
+export declare function frameLimit(entry: FramePatch, i: number): number;
+/** True when `value` is what the CD's player already has (so no patch is needed). */
+export declare function isStock(entry: PatchEntry, value: PatchValue): boolean;
+/** Writes a value already checked with patchProblem. */
+export declare function writePatch(exe: Uint8Array, entry: PatchEntry, value: PatchValue): void;
+/** The entry's value in `exe` (text up to its first 0, trailing spaces dropped), or undefined when it can't be read as one. */
+export declare function readPatch(exe: Uint8Array, entry: PatchEntry): PatchValue | undefined;
+/** Writes the CD's own value back (for every byte the entry covers, the 0s included). */
+export declare function writeStock(exe: Uint8Array, entry: PatchEntry): void;
+/**
+ * Only the patches that are known, valid and not the stock value; the rest are left out. Renamed
+ * file extensions (fileExtensions.ts) are kept in lower case.
+ */
+export declare function cleanPatches(patches: Record<string, unknown> | undefined): PlayerPatches;

package/dist/types/player/patchTable.d.ts

@@ -0,0 +1,83 @@
+/** The editor panel's groups. */
+export type PatchGroup = 'words' | 'colors' | 'frames' | 'positions' | 'times' | 'keys' | 'play';
+/** The screen a patch shows on, which the panel previews while it is edited ('gameplay': every scene, no preview). */
+export type PatchScreen = 'menu' | 'hiscores' | 'newHiscore' | 'status' | 'load' | 'save' | 'drop' | 'help' | 'text' | 'missing' | 'about' | 'play' | 'gameplay' | 'all';
+/**
+ * The color targets RGBdata::Match looks for, by name, with the DGROUP offset of each object
+ * (what a color selector's push imm16 names).
+ */
+export declare const COLOR_TARGETS: {
+    readonly yellow: 623;
+    readonly red: 626;
+    readonly blue: 629;
+    readonly purple: 632;
+    readonly hsRed: 5626;
+    readonly hsBlue: 5629;
+    readonly hsGreen: 5632;
+};
+export type ColorName = keyof typeof COLOR_TARGETS;
+/** One immediate in the code: its file offset and size (1: imm8, sign-extended; 2: imm16). */
+export interface ImmField {
+    offset: number;
+    size: number;
+    /** It holds the value's negative (the -MAXGRAV of `if (tx < -MAXGRAV) tx = -MAXGRAV`). */
+    negate?: true;
+}
+interface Base {
+    id: string;
+    group: PatchGroup;
+    screen: PatchScreen;
+    label: string;
+    note?: string;
+    /** experimental: changes how every scene plays (the `play` group); test it in DOSBox. */
+    safety: 'safe' | 'caution' | 'experimental';
+    /** The web player shows it too (false: DOS only). */
+    web: boolean;
+}
+/** A NUL-ended string: never longer than `length`, characters 0x20-0x7E; a `format` keeps its % codes. */
+export interface TextPatch extends Base {
+    kind: 'text' | 'format';
+    offset: number;
+    length: number;
+    stock: string;
+}
+/** A number in one immediate, or the same number in each of several (`fields`, patched together). */
+export interface NumberPatch extends Base {
+    kind: 'number';
+    fields: ImmField[];
+    /** A 1-byte field is a sign-extended push imm8. */
+    signed: boolean;
+    min: number;
+    max: number;
+    stock: number;
+}
+/** A color: red, green and blue (0-63), one byte each. */
+interface RgbPatch extends Base {
+    kind: 'rgb';
+    offsets: [number, number, number];
+    stock: [number, number, number];
+}
+/** Which color target a screen matches (the push imm16 before RGBdata::Match). */
+interface SelectPatch extends Base {
+    kind: 'select';
+    offset: number;
+    stock: ColorName;
+}
+/** A Box(x1, y1, x2, y2) frame. */
+export interface FramePatch extends Base {
+    kind: 'frame';
+    fields: [ImmField, ImmField, ImmField, ImmField];
+    stock: [number, number, number, number];
+}
+/** A function key's entry in DoFunKy's jump table: on (as shipped) or 'off'. */
+interface FkeyPatch extends Base {
+    kind: 'fkey';
+    key: number;
+    offset: number;
+    stock: number;
+}
+export type PatchEntry = TextPatch | NumberPatch | RgbPatch | SelectPatch | FramePatch | FkeyPatch;
+/** DoFunKy's "does nothing" target: an F-key whose entry jumps here is off. */
+export declare const FKEY_OFF = 10489;
+export declare const PATCHES: PatchEntry[];
+export {};