@lewismoten/gamemaker-sandbox-tools 3.1.0 → 3.4.0

package/dist/types/web/src/engine/touch.d.ts

@@ -1,33 +0,0 @@
-import type { Block } from '../formats/blocks.js';
-import { type Coord, type TouchBlocks, type World } from './world.js';
-export declare const KILLSOUND = 1;
-export declare function doSound(w: World, n: number): boolean;
-/** ScrnLowBnd/ScrnUpBnd ({1,1} to {SIZEX-BLEN,SIZEY-BLEN}): where a 20x20 sprite is considered on screen. */
-export declare function inScreenBounds(p: Coord): boolean;
-/**
- * onscrn: screen position of map block (x, y); true if inside the screen bounds.
- * Cells left of / above the scroll origin (mx, my) are taken as wrapped around the map.
- */
-export declare function onscrn(w: World, x: number, y: number, ret: Coord): boolean;
-/**
- * GetTouchbl: the up to 6 map cells the (two block high) character overlaps:
- * 0/1 the top row (only while the top half is drawn), 2/3 its own row, 4/5 the
- * row below, left then right. The right/lower cells count only when the pixel
- * offset is past 0. Unused cells keep x = MLEN and BACKBL; blknum is the
- * displayed variant (blkmap) of the map block.
- */
-export declare function getTouchBlocks(w: World): TouchBlocks;
-/** checkseq_fortie: turns on/off every sequence tied to `block` (picked up or dropped). */
-export declare function checkSeqForTie(w: World, block: number, setting: boolean): void;
-/**
- * DoBlockTouchChar: applies a block's (or monster block's) effects to the character.
- * Returns 0 when blocked by an empty counter, otherwise (sound played ? 2 : 1).
- * Effect 1 is lives and 3 is money; effects 3 and up are counters (ci.meter), and
- * 3 or 20 and up refuse the touch when they would leave the counter at 0 or less.
- * i16/u16 keep the C's 16-bit int wrap and its unsigned overflow checks.
- */
-export declare function doBlockTouchChar(w: World, blk: Block): number;
-/** really_checktouch: 2 = touch refused (counter empty), else true. x === MLEN is an unused touch cell. */
-export declare function reallyCheckTouch(w: World, x: number, y: number, bnum: number): number;
-/** CheckTouch: touches every overlapped cell except objects, which only PickupBloc takes. */
-export declare function checkTouch(w: World): void;

package/dist/types/web/src/engine/world.d.ts

@@ -1,215 +0,0 @@
-import { BACKBL, BLEN, CHARBL, MONBL, type Block } from '../formats/blocks.js';
-import type { Character } from '../formats/character.js';
-import { INF_REPEAT, MAXINV, MAXSEQ } from '../formats/character.js';
-import { LASTMON, type Monster } from '../formats/monster.js';
-import { LASTMM, MLEN, MWID, type GameMap } from '../formats/map.js';
-import { LASTSND } from '../formats/sound.js';
-export { BLEN, BACKBL, MONBL, CHARBL, LASTMM, LASTMON, MLEN, MWID, MAXSEQ, MAXINV, INF_REPEAT, LASTSND };
-export declare const SIZEX = 320;
-export declare const SIZEY = 200;
-export declare const MAXKEYS = 20;
-export declare const MAXGRAV = 11;
-export declare const SCRNBLEN = 16;
-export declare const SCRNBWID = 10;
-export declare const GRAVSPEED = 1;
-export declare const MONMOVESPEED = 1;
-export declare const JSTICKKEY = 1;
-export declare const ATTACKX = 8;
-export declare const ATTACKY = 5;
-export declare const OFFSCRN = -100;
-export declare const SCRSPDX = 40;
-export declare const SCRSPDY = 40;
-export declare const SCROLLPERMOVE = 6;
-export declare const MAXMONSSHOWN = 50;
-export declare const CHARPOWER = 100;
-export declare const NEVER = 4294967295;
-export interface Coord {
-    x: number;
-    y: number;
-}
-/** cinfo: the player's state that persists across scenes. */
-export interface CharInfo {
-    score: number;
-    update: boolean;
-    topthere: boolean;
-    bottomthere: boolean;
-    curtop: number;
-    curbottom: number;
-    /** Where the character will be on screen next; scrx/scry where it is drawn; oldx/oldy where it is erased. */
-    nextx: number;
-    nexty: number;
-    scrx: number;
-    scry: number;
-    oldx: number;
-    oldy: number;
-    /** Delta of the character's last 2 moves. */
-    netx: number;
-    nety: number;
-    /** Current velocity due to gravity. */
-    gravx: number;
-    gravy: number;
-    hitpts: number;
-    /** Lives left; -1 before the first scene sets it from the character's meter. */
-    lives: number;
-    /** Game clock tick at which the character next moves. */
-    nextAni: number;
-    /** Inventory block numbers (BACKBL+1 in inv[0] = not filled in yet). */
-    inv: number[];
-    /** Repetition counters, MAXSEQ + 10 of them; meter[0] is hit points, meter[1] lives. */
-    meter: number[];
-    seqon: boolean[];
-}
-/** minfo: one live monster. */
-export interface MonInfo {
-    /** Born from the character, so it can't hurt the character. */
-    fromchar: number;
-    /** Bresenham's algorithm: dx = (curpos - dest). */
-    delta: Coord;
-    /** [0] map block, [1] pixel position within the block. */
-    curx: [number, number];
-    cury: [number, number];
-    /** Where the monster is going when on a path. */
-    target: Coord;
-    /** xy ratios in Bresenham's line algorithm. */
-    offl: number;
-    offs: number;
-    /** 0 normal, 1 attack pattern. */
-    curMarch: number;
-    /** Index into mon[].pic. */
-    curPic: number;
-    /** How to flip and rotate the picture. */
-    orient: number;
-    picDrawn: boolean;
-    scrPos: Coord;
-    oldPos: Coord;
-    /** Index of the next position in the monster's path. */
-    dest: number;
-    /** Game clock ticks of the next animation frame, next move, and when it was born. */
-    nextAni: number;
-    nextMove: number;
-    birthTime: number;
-}
-/** mm[]: monster number per slot (LASTMON = empty). */
-interface MonSlot {
-    monnum: number;
-    curx: number;
-    cury: number;
-}
-interface KeyStackEntry {
-    key: number;
-    seq: number;
-    frame: number;
-}
-export interface BresScroll {
-    dscroll: number;
-    ctr: number;
-    iters: number;
-}
-interface ScrollState {
-    /** Pixel offset of the screen edge within the edge block (mx, my). */
-    nx: number;
-    ny: number;
-    /** How far to move the screen this game tick; negative is up or left. */
-    totalx: number;
-    totaly: number;
-    /** Character's offset from the screen center (pixels; the C comment says blocks). */
-    distx: number;
-    disty: number;
-    /** SOLLEF/SOLRIG/SOLTOP/SOLBOT flags of the directions currently scrolling. */
-    inMotion: number;
-    maxX: number;
-    maxY: number;
-    minX: number;
-    minY: number;
-    leftStop: number;
-    rightStop: number;
-    upStop: number;
-    downStop: number;
-    /** Pixels waiting to be scrolled; whole 4 pixel steps are taken, 0..3 remain as the pan. */
-    movx: number;
-    movy: number;
-    /** 0..3 pixel hardware pan (an absolute position, not a delta). */
-    littleShiftx: number;
-    littleShifty: number;
-    /** 0xff where the scene allows scrolling that way (mirrored from the .gam file). */
-    up: number;
-    down: number;
-    left: number;
-    right: number;
-    bx: BresScroll;
-    by: BresScroll;
-}
-export interface TouchBlocks {
-    blks: [number, number][];
-    blknum: number[];
-}
-interface SoundHooks {
-    /** DoSound: returns true if a sound was started. */
-    play(n: number): boolean;
-}
-export interface World {
-    palette: Uint8Array;
-    map: Uint8Array;
-    mapMon: Uint8Array;
-    bg: Block[];
-    mblk: Block[];
-    cblk: Block[];
-    mon: Monster[];
-    chr: Character;
-    noMons: boolean;
-    ci: CharInfo;
-    mi: MonInfo[];
-    mm: MonSlot[];
-    firstEmptyMM: number;
-    monsolid: number;
-    mmSolid: number;
-    blkMon: {
-        blnum: number;
-        nexttime: number;
-    }[];
-    /** Per-block "birth this tick" flag (bit 0x4000 of Birthtime in the original). */
-    birthFlag: Uint8Array;
-    nxtchg: number[];
-    blkmap: Uint8Array;
-    mx: number;
-    my: number;
-    scroll: ScrollState;
-    clock: number;
-    keydn: Uint8Array;
-    keystack: KeyStackEntry[];
-    keystkptr: number;
-    curkey: number;
-    gclk: number;
-    joyOldTime: number;
-    joyOldBut: number;
-    sound: SoundHooks;
-    rand: () => number;
-    /** GetJoyPos: position 0 (center) or 1..8 clockwise from up, buttons bit 0/1. */
-    joystick?: () => {
-        pos: number;
-        buttons: number;
-    } | null;
-    jstickOn: boolean;
-    /**
-     * Not PLAYGAME's: told when the character's touch did something to map cell (x, y), shown as
-     * block `bnum` (it changed into its touch block, or was picked up). The web's tin heart
-     * tracking listens here; nothing in play reads it.
-     */
-    onTouched?: (x: number, y: number, bnum: number) => void;
-}
-export declare function newCharInfo(): CharInfo;
-/** Pads a block list with empty blocks so out-of-range numbers are harmless. */
-export declare function padBlocks(list: Block[] | undefined, count: number): Block[];
-export declare function mapBlock(w: World, x: number, y: number): number;
-export declare function mapMonAt(w: World, x: number, y: number): number;
-export declare function setMapMon(w: World, x: number, y: number, v: number): void;
-/** blks[0][blkmap[n]]: the currently displayed variant of background block n. */
-export declare function shownBlock(w: World, n: number): Block;
-export declare function bgBlock(w: World, n: number): Block;
-export declare function createWorld(map: GameMap, sound: SoundHooks, rand?: () => number): World;
-export declare const random: (w: World, n: number) => number;
-export declare const sign: (v: number) => 0 | 1 | -1;
-/** C int (16-bit) wrap. */
-export declare const i16: (v: number) => number;
-/** C unsigned int (16-bit). */
-export declare const u16: (v: number) => number;

package/dist/types/web/src/export/gameAbout.d.ts

@@ -1,15 +0,0 @@
-/** A DOS text file as plain text: up to the ^Z end mark, no CRs or control characters. */
-export declare function dosText(bytes: Uint8Array): string;
-/** The game's story screen ("*s.txt", "*story*"), else its instructions ("*i.txt"), else any text screen. */
-export declare function storyFile(names: string[]): string | undefined;
-/** The first lines of a text screen joined into a sentence or two. */
-export declare function blurbOf(text: string, max?: number): string | undefined;
-interface GameAbout {
-    /** From the game's story or instruction screen. */
-    blurb?: string;
-    /** Shareware: the author's notice, as text. */
-    notice?: string;
-}
-/** What a game's own files say about it (file names are matched in lower case). */
-export declare function gameAbout(entries: [string, Uint8Array][]): GameAbout;
-export {};

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

@@ -1,44 +0,0 @@
-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/web/src/formats/blocks.d.ts

@@ -1,52 +0,0 @@
-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/web/src/formats/character.d.ts

@@ -1,65 +0,0 @@
-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/web/src/formats/cmf.d.ts

@@ -1,33 +0,0 @@
-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/web/src/formats/fli.d.ts

@@ -1,45 +0,0 @@
-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/web/src/formats/fliLimits.d.ts

@@ -1,13 +0,0 @@
-type FliFaultKind = 'big' | 'packets' | 'black' | 'type';
-interface FliFault {
-    kind: FliFaultKind;
-    /** The frame it is in (0 the first; the last is the ring frame back to the start). */
-    frame: number;
-    /** The chunk's size with its header ('big'), the packet count ('packets') or the chunk type ('type'). */
-    value: number;
-}
-/** Every fault in an .FLI, the first of each kind per frame. A file that isn't an FLI has none. */
-export declare function fliFaults(bytes: Uint8Array): FliFault[];
-/** A fault in words, for a finding or a health issue. */
-export declare function describeFliFault(f: FliFault): string;
-export {};

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

@@ -1,72 +0,0 @@
-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/web/src/formats/gif.d.ts

@@ -1,15 +0,0 @@
-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/web/src/formats/graphicScripts.d.ts

@@ -1,18 +0,0 @@
-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/web/src/formats/highscore.d.ts

@@ -1,10 +0,0 @@
-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/web/src/formats/map.d.ts

@@ -1,24 +0,0 @@
-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;