@lewismoten/gamemaker-sandbox-tools 3.1.0 → 3.4.0

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

@@ -1,52 +0,0 @@
-import { Machine } from './machine.js';
-import { type Session, type SpeedSetting } from './scene.js';
-import type { PlayerPatches } from '../dosPlayer/patchRules.js';
-import { type Game } from '../formats/game.js';
-export interface RunOptions {
-    /** Called when the player picks Quit; return true to show the menu again. */
-    onQuit?: () => Promise<boolean> | boolean;
-    speakerOnly?: boolean;
-    /** No Sound Blaster (PLAYGAME's SoundCard() found none): no songs, every sound on the PC speaker. */
-    noSoundCard?: boolean;
-    joystick?: Session['joystick'];
-    /** Play a .rec demo immediately instead of showing the menu. */
-    playback?: Uint8Array;
-    /** Start playing at once, recording the keys (for making a demo); the menu is skipped. */
-    record?: boolean;
-    /** Receives the game session as it starts (e.g. to read the recording so far). */
-    onSession?: (s: Session) => void;
-    /** Called every frame while a level is being played. */
-    onFrame?: Session['onFrame'];
-    /** Emulated PC speed (shared object: change slowPc at any time). */
-    speed?: SpeedSetting;
-    /**
-     * Play as PLAYGAME.EXE, Game-Maker's own player: F1 shows this file (GMHELP.TXT from
-     * Game-Maker's directory) before the game's instructions. Left out, the game plays as
-     * XFERPLAY.EXE, the stand-alone player every transferred game runs on, whose F1 shows only
-     * the instructions (PLAYGAME.C HelpFiles: the gmhelp.txt part is #ifndef TRANSFER).
-     */
-    gmHelp?: Uint8Array;
-    /**
-     * The project's DOS player customizations (dosPlayer/): XFERPLAY's words, colors, frames,
-     * positions, times and F-keys as its patched .EXE shows them. Left out, the CD's player.
-     */
-    player?: PlayerPatches;
-    /** A touch changed a map cell while the player played (never during a demo's playback). */
-    onTouched?: Session['onTouched'];
-    /** Play ended with this score (never during a demo's playback; see Session.onPlayEnd). */
-    onPlayEnd?: Session['onPlayEnd'];
-    /**
-     * The editor's Play Level test only (never a saved, exported or DOS game): skip the title, its
-     * song and the menu, and start play at once by scene 0's first link (which the test copy points
-     * at the picked level and spot, editor/editors/integrator/startAt.ts) with a new game's
-     * character, as the menu's Play would. When that play ends (won, lost or Esc), the usual end
-     * follows (the won or dead picture, the high scores) and then the menu, as after any play.
-     */
-    skipTitle?: boolean;
-}
-export declare function gameNameOf(gamFile: string): string;
-export declare function loadGameFile(m: Machine, gamFile: string): Game;
-/** Runs a game until the player quits. */
-export declare function runGame(m: Machine, gamFile: string, opts?: RunOptions): Promise<void>;
-/** play(curlink): from scene 0's link to the end. */
-export declare function play(s: Session, startLink: number): Promise<void>;

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

@@ -1,17 +0,0 @@
-import { type Frame, type Sequence } from '../formats/character.js';
-import { type World } from './world.js';
-export declare function chrSeq(w: World): Sequence;
-/** CHRFRAME. cframe can be -1 between sequences; the original then read stray memory. */
-export declare function chrFrame(w: World): Frame;
-/**
- * SimKeyPress. A press starts the matching sequence only if the character isn't dying,
- * the running sequence can be interrupted (not `ground`), the sequence still has uses
- * (meter > 0) and is turned on (seqon, e.g. its inventory block is carried).
- */
-export declare function simKeyPress(w: World, key: number): void;
-/** PushKey. The overflow handling is the port's; the C pushed without a bounds check. */
-export declare function pushKey(w: World): void;
-/** PopKey: drop `key` from the stack and resume what is under it, or idle when empty. */
-export declare function popKey(w: World, key: number): void;
-/** The key down and key stack reset at the end of StartSceneInits (also used after F-keys). */
-export declare function resetKeys(w: World): void;

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

@@ -1,99 +0,0 @@
-import { Screen } from '../gfx/screen.js';
-import { Keyboard, type TypedKey } from '../input/keyboard.js';
-import { AudioEngine } from '../audio/engine.js';
-import { GameFiles } from '../project/gameFiles.js';
-/** Thrown to unwind the game when the player is closed. */
-export declare class GameAborted extends Error {
-    constructor();
-}
-interface PointerState {
-    /** Screen coordinates (0..319, 0..199) of the last pointer position. */
-    x: number;
-    y: number;
-    clicks: number;
-}
-/** How a Machine is driven (the defaults are a live player's). */
-interface MachineOptions {
-    /**
-     * 'manual': no animation frame loop; whoever made the Machine calls presentFrame() for
-     * each frame, and now() is theirs too (a walkthrough steps the game on a clock of its own).
-     */
-    frames?: 'auto' | 'manual';
-    /** False: the pointer, the desk mouse and the keyboard never reach the game. */
-    input?: boolean;
-}
-export declare class Machine {
-    readonly screen: Screen;
-    readonly keyboard: Keyboard;
-    readonly audio: AudioEngine;
-    files: GameFiles;
-    readonly pointer: PointerState;
-    aborted: boolean;
-    private frameWaiters;
-    private raf;
-    /** The ball mouse on the desk moves the pointer and clicks too. */
-    private offDeskMouse;
-    /** The engine was made here (not passed in): it goes with the Machine. */
-    private ownsAudio;
-    constructor(canvas: HTMLCanvasElement, files: GameFiles, audio?: AudioEngine, opts?: MachineOptions);
-    private listen;
-    /** The time in ms the game goes by (waits, fades, animations, the game clock). */
-    now(): number;
-    /** One display frame: the screen is shown (unless `show` is false) and everything waiting for a frame goes on. */
-    presentFrame(show?: boolean): void;
-    /** How many are waiting for the next frame (a stepped Machine's game is idle when one is). */
-    get frameWaiting(): number;
-    private toScreen;
-    private onPointer;
-    private onMove;
-    destroy(): void;
-    /** Told when the game waits for files still on their way (true) and when they are in. */
-    onLoading?: (loading: boolean) => void;
-    /**
-     * Waits for game files still on their way from the site (a hosted game starts before
-     * all its files are in, project/streamGame.ts); a short wait shows no cue. Names the
-     * game doesn't have, or that are in already, return at once.
-     */
-    need(...names: (string | undefined)[]): Promise<void>;
-    /** Fetches these game files next, if they are still on their way, without waiting. */
-    want(...names: (string | undefined)[]): void;
-    checkAbort(): void;
-    /** Waits for the next animation frame (the screen is presented every frame). */
-    frame(): Promise<void>;
-    sleep(ms: number): Promise<void>;
-    takeClick(): boolean;
-    /**
-     * PauseTimeKey: waits up to `seconds` (forever if omitted) for a key or click.
-     * Returns the key, a pseudo key for a click (ascii 1, as the C returned 1 for a mouse
-     * button; scan 28 is Enter's), or undefined on time out (the C returned FALSE).
-     */
-    pauseTimeKey(seconds?: number): Promise<TypedKey | undefined>;
-    private waitDepth;
-    private polledAt;
-    /**
-     * Runs `fn` as PLAYGAME code that read keys through GetKey (key waits, pictures,
-     * animations, text pages): while it runs, each frame hands the demo recorder the polls
-     * the DOS PC would have made meanwhile (keyPoll). Gameplay itself stole the keyboard
-     * interrupt and never called GetKey, so it does not count.
-     */
-    waiting<T>(fn: () => Promise<T>): Promise<T>;
-    private pollKeys;
-    /**
-     * Demo playback: called while a screen waits for a key with how many GetKey polls the
-     * DOS PC would have made meanwhile; returns recorded keys that become pending.
-     */
-    keyPoll?: (polls: number) => number[];
-    /** Demo playback: a key-reading screen ended; returns recorded keys it must have taken. */
-    keyPollEnd?: () => number[];
-    /** Clears keyboard input (while (GetKey(1)) GetKey(0)). */
-    flushKeys(): void;
-    /**
-     * FadeTo: 65 retrace-synchronized steps from the current palette to `dest`. The C
-     * waited for one VGA vertical retrace (70 Hz in mode 13h) per step, hence steps/70 s;
-     * it stepped each channel Bresenham-style, which the truncated d*step/steps matches
-     * at every step.
-     */
-    fadeTo(dest: ArrayLike<number>, steps?: number): Promise<void>;
-    fadeAllTo(r: number, g: number, b: number, steps?: number): Promise<void>;
-}
-export {};

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

@@ -1,46 +0,0 @@
-import type { Machine } from './machine.js';
-import type { Screen } from '../gfx/screen.js';
-import { type PlayerLook } from './playerLook.js';
-import { type HighScore } from '../formats/highscore.js';
-/**
- * GVertMenu: a marker box left of `count` rows (`dy` pixels apart starting at y).
- * Returns 1..count, 0 for Esc, count+1 when idle for `idleSeconds`. The C timed the
- * idle wait in game ticks (IdleTime*18 of TimerCounter); this uses wall-clock time.
- *
- * The C cleared only the mouse buttons (mouclearbut), not the keyboard: a key typed
- * while the menu picture faded in (after the one ShowGraphic's PauseTimeKey(0) took)
- * was the menu's. `flushKeys` false keeps that; the default clears keys too, for menus
- * opened mid-level, where this port's keyboard also queues the keys gameplay used
- * (PLAYGAME's own keyboard interrupt kept those out of the BIOS buffer).
- */
-export declare function gVertMenu(m: Machine, x: number, y: number, dy: number, count: number, color: number, idleSeconds?: number, choice?: number, flushKeys?: boolean, 
-/** The marker's width minus 1 (the player's border.marker.width patch). */
-markerWidth?: number): Promise<number>;
-/** GGet: line editor with a blinking box cursor. Returns null on Esc. */
-export declare function gGet(m: Machine, x: number, y: number, col: number, bcol: number, initial: string, maxlen: number): Promise<string | null>;
-/** DrawDefaultScrn: concentric colored frames when a game has no menu graphic. */
-export declare function drawDefaultScreen(m: {
-    screen: Screen;
-}, colors: Uint8Array, rand?: () => number): void;
-export declare function highScoreFile(gamename: string): string;
-export declare function readHighScores(m: Machine, gamename: string): HighScore[];
-/** The main menu's words over the menu picture: the game's name and the six choices (DoGame). Returns their color. */
-export declare function drawMenu(screen: Screen, look: PlayerLook, colors: Uint8Array, title: string): number;
-/** The menu's GVertMenu call (x, first y, spacing, idle seconds, marker width), as the player's patches set them. */
-export declare function menuMarker(look: PlayerLook): {
-    x: number;
-    y: number;
-    dy: number;
-    idle: number;
-    width: number;
-};
-/** One of the menu's "No game-specific ..." lines (they share one GWrite: one position, one color). */
-export declare function drawNoFile(screen: Screen, look: PlayerLook, colors: Uint8Array, id: 'noInstructions' | 'noStoryline' | 'noCredits'): void;
-/** The high score table's words and rows; the rows get closer together further down. */
-export declare function drawHighScores(screen: Screen, look: PlayerLook, colors: Uint8Array, top: HighScore[], score: number): void;
-/** ShowHighScores (HISCOREL.C). */
-export declare function showHighScores(m: Machine, gamename: string, colors: Uint8Array, score?: number, look?: PlayerLook): Promise<void>;
-/** CheckHighScores' words for a new high score (place is 1-based); returns the name's color. */
-export declare function drawNewHighScore(screen: Screen, look: PlayerLook, colors: Uint8Array, place: number): number;
-/** CheckHighScores: asks for a name when the score makes the top ten; returns the 1-based place or 0. */
-export declare function checkHighScores(m: Machine, gamename: string, colors: Uint8Array, score: number, look?: PlayerLook): Promise<number>;

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

@@ -1,19 +0,0 @@
-import { type MonInfo, type World } from './world.js';
-export declare function resetMonInfo(mi: MonInfo): void;
-export declare function monPicNum(w: World, mm: number): number;
-/** minfo::CalcDraw */
-export declare function calcDraw(w: World, mi: MonInfo): boolean;
-/** BirthMon: puts monster `mon` in slot mm (or the first empty slot when mm >= LASTMM). */
-export declare function birthMon(w: World, mm: number, mon: number, x: number, y: number): number;
-/** BlocBirthMon: blocks that give birth to monsters near the screen. */
-export declare function blockBirthMonsters(w: World): void;
-/** CharBirthMon: a character sequence frame that fires a monster (a shot, a bomb…). */
-export declare function charBirthMon(w: World, x: number, y: number, monNum: number): void;
-/**
- * PicChkTouch: pixel-exact overlap of two 20x20 sprites (255 = transparent).
- * Both positions are shifted so the overlap is measured from the nearer corner;
- * each of the four branches handles one relative placement of sprite 2.
- */
-export declare function picChkTouch(x1: number, y1: number, pic1: Uint8Array, x2: number, y2: number, pic2: Uint8Array): boolean;
-/** moveallmons: animate and move every live monster one game tick. */
-export declare function moveAllMonsters(w: World): void;

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

@@ -1,11 +0,0 @@
-export interface PlayGain {
-    /** Points from the stretches F6 closed. */
-    banked: number;
-    /** The score the current stretch started from (0, or the score a load put in place). */
-    base: number;
-}
-export declare const newPlayGain: () => PlayGain;
-/** F6 loaded a save: the score went from `before` to the save's `after`. */
-export declare function gainAtLoad(g: PlayGain, before: number, after: number): void;
-/** The points this play scored, ending on `score`. */
-export declare const gainAtEnd: (g: PlayGain, score: number) => number;

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

@@ -1,26 +0,0 @@
-import { type PlayerPatches } from '../dosPlayer/patchRules.js';
-type Rgb = [number, number, number];
-type Frame = [number, number, number, number];
-export interface PlayerLook {
-    /** A word or line (str.*). */
-    text(id: string): string;
-    /** A printf format (str.*) filled in as sprintf would. */
-    format(id: string, ...args: (number | string)[]): string;
-    /** The palette index a screen's color selector (color.select.*) matches in `pal`. */
-    color(pal: Uint8Array, select: string): number;
-    /** A color's levels (color.rgb.*, color.missing.*). */
-    rgb(id: string): Rgb;
-    frame(id: string): Frame;
-    /** A position or count (layout.*, border.marker.width). */
-    num(id: string): number;
-    /** A wait in seconds (timing.*); -1 is PauseTimeKey's unsigned 65535 (until a key). */
-    seconds(id: string): number;
-    /** False when the player's patches turned this F-key off. */
-    fkeyOn(key: number): boolean;
-}
-/** sprintf for the player's formats: %d, %ld, %s with a width and the 0 and - flags. */
-export declare function sprintf(format: string, args: (number | string)[]): string;
-export declare function playerLook(patches?: PlayerPatches): PlayerLook;
-/** The CD player's own look. */
-export declare const STOCK_LOOK: PlayerLook;
-export {};

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

@@ -1,60 +0,0 @@
-import { type RecordedKey } from '../formats/recording.js';
-export declare const RECORD = 1;
-export declare class Recorder {
-    mode: number;
-    private keys;
-    private index;
-    private timer;
-    private lastKeyPress;
-    private paused;
-    initRecord(): void;
-    /**
-     * Whether waits for a key count toward playback time. PLAYGAME's GetKey called
-     * DoPlayBack on every poll, so while a "hit any key" screen waited the timer raced
-     * ahead (thousands of polls a second), and a demo recorded in DOS stores those polls
-     * as one huge DeltaTime before the key that dismissed the screen (Nebula's 26058).
-     * Demos recorded here count game ticks only, so for them waits must not count.
-     */
-    countsWaits: boolean;
-    initPlayback(bytes: Uint8Array | undefined): boolean;
-    stop(): void;
-    restart(): void;
-    pause(): void;
-    unpause(): void;
-    /** Game ticks counted since the recording or playback (re)started; the playback position. */
-    get tick(): number;
-    get playing(): boolean;
-    /** Paused: play has left the levels (the won/lost pictures and score table follow). */
-    get halted(): boolean;
-    /** DoPlayBack: advance one tick; returns the keys that become pending now. */
-    doPlayback(): number[];
-    /**
-     * GetKey polls while a screen waits for a key: `polls` calls to DoPlayBack at once.
-     * Returns the recorded keys that become pending (only for recordings made in DOS).
-     */
-    advanceWait(polls: number): number[];
-    /**
-     * A screen that read keys has finished. In DOS the next key may have come during it
-     * (the recording shows a gap of many thousands of polls), however fast that PC polled;
-     * catch up to it, and to keys a poll or two behind it (taken by the keyboard flush that
-     * follows every screen), so gameplay resumes in step. Only for DOS recordings.
-     */
-    finishWait(): number[];
-    /**
-     * DoRecord: called when a key is actually applied to the character (keys held back
-     * while a sequence can't be interrupted are recorded on the tick they take effect).
-     * DeltaTime is a 16-bit uint in the C, and at most RECLEN keys are kept.
-     */
-    doRecord(key: number): void;
-    /** The recording so far, in .rec format. */
-    save(): Uint8Array;
-    /** For save games (the C wrote the Recording object and its keys into the .sav). */
-    snapshot(): unknown;
-    restore(s: {
-        mode: number;
-        keys: RecordedKey[];
-        index: number;
-        timer: number;
-        lastKeyPress: number;
-    }): void;
-}

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

@@ -1,8 +0,0 @@
-import type { Screen } from '../gfx/screen.js';
-import { type World } from './world.js';
-/** CropScreen: the CRTC was reprogrammed to show only 312x196 pixels while playing. */
-export declare const VISIBLE_W = 312;
-export declare const VISIBLE_H = 196;
-/** drawchars' bookkeeping without the drawing: whether top/bottom blocks are shown (used by GetTouchbl). */
-export declare function updateCharDrawState(w: World): void;
-export declare function renderWorld(screen: Screen, w: World): void;

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

@@ -1,156 +0,0 @@
-import type { Machine } from './machine.js';
-import type { Recorder } from './recorder.js';
-import { type PlayerLook } from './playerLook.js';
-import { type CharInfo, type Coord, type World } from './world.js';
-import { type SoundSet } from '../formats/sound.js';
-import { type Game } from '../formats/game.js';
-import { type PcCosts } from './slowPc.js';
-import { type PlayGain } from './playGain.js';
-/** How a play ended: the Game Won scene, no lives left, or Esc (or a scene that could not load). */
-type PlayEnd = 'won' | 'lost' | 'quit';
-/** Everything that lives across scenes (playgame's globals outside a level). */
-export interface Session {
-    m: Machine;
-    game: Game;
-    gameName: string;
-    ci: CharInfo;
-    /** The `colors` global: the palette of the current scene or menu screen. */
-    colors: Uint8Array;
-    rec: Recorder;
-    sndClock: number;
-    timerCounter: number;
-    soundOn: boolean;
-    musicOn: boolean;
-    /** Use the PC speaker even when a .voc name is given (no Sound Blaster). */
-    speakerOnly: boolean;
-    joystick?: () => {
-        pos: number;
-        buttons: number;
-    } | null;
-    /** Called every rendered frame with the live world (for HUD overlays, touch controls…). */
-    onFrame?: (w: World) => void;
-    /** Emulated PC speed; read every tick so it can change while playing. */
-    speed: SpeedSetting;
-    /** RunOptions.gmHelp: Game-Maker's own GMHELP.TXT, which F1 shows first (PLAYGAME.EXE only). */
-    gmHelp?: Uint8Array;
-    /** RunOptions.player as the screens use it (engine/playerLook.ts); left out, the CD player's look. */
-    look?: PlayerLook;
-    /** The random numbers a level's monsters get as it loads (default Math.random; a walkthrough seeds them). */
-    rand?: () => () => number;
-    /** Told the scene number each time play() enters a scene (before its picture). */
-    onScene?: (scene: number) => void;
-    /** Not PLAYGAME's: a touch in `scene` changed map cell (x, y), shown as block `bnum` (World.onTouched). */
-    onTouched?: (scene: number, x: number, y: number, bnum: number) => void;
-    /**
-     * Not PLAYGAME's: play ended (won, lost, or left with Esc) with this score, just before the
-     * high score table. Never told during a demo's playback. It only listens: nothing changes.
-     * `gained` is the points the play scored itself, leaving out those F6 loaded (playGain.ts).
-     */
-    onPlayEnd?: (score: number, how: PlayEnd, gained: number) => void;
-    /** Not PLAYGAME's: the stretches of this play between F6 loads (playGain.ts). */
-    gain?: PlayGain;
-    /**
-     * The last level played. loadscene loads into globals, so a level that leaves its
-     * palette, block or character slot blank keeps the previous level's (PLAYGAME.C 4239).
-     */
-    lastWorld?: World;
-}
-/**
- * How fast the emulated PC is. The game clock always runs at 18.2 Hz, but playgame
- * skips (rather than catches up) ticks its main loop was too slow to handle, and loses
- * the scroll steps of interrupts that went by while it was busy. `slowPc` (see slowPc.ts)
- * charges each pass of the loop what it cost on a slower PC; left out, the PC is fast
- * enough for every pass (a 486 in turbo).
- */
-export interface SpeedSetting {
-    slowPc?: PcCosts;
-}
-export declare function sceneFile(game: Game, scene: number, slot: number): string | undefined;
-interface LoadedScene {
-    world: World;
-    sounds?: SoundSet;
-    song?: Uint8Array;
-}
-/**
- * loadscene: returns the names of missing files on failure. Scene file slots are
- * 0 palette, 1 map, 2 background blocks, 3 monsters, 4 monster blocks, 5 character,
- * 6 character blocks, 7 sound set, 8 song. In the C a slot left blank keeps whatever
- * the previous scene loaded into the globals; `prev` stands in for those globals.
- */
-export declare function loadScene(s: Pick<Session, 'game' | 'rand' | 'onTouched'> & {
-    m: {
-        files: {
-            get(name: string): Uint8Array | undefined;
-        };
-    };
-}, scnum: number, prev?: World): LoadedScene | string[];
-/** StartGameInits */
-export declare function startGameInits(s: Session): void;
-/** StartSceneInits */
-export declare function startSceneInits(w: World, start: Coord): void;
-/**
- * keydn[CHRSEQ.key] = 1 at the end of the C's scene inits (PLAYGAME.C). keydn is a 128 byte
- * array indexed by scan code, but a sequence's key is the whole 16 bit word (scan code in the
- * high byte, ASCII in the low byte, CHAR.H), so the C only set a keydn entry when the key had
- * no scan code: key 0 (no key, which every idle sequence on the CD has) sets keydn[0], and
- * the idle sequence's "quit if key lifted" test (keydn[key>>8]==0) then reads it as held.
- * For a real key the write landed key bytes past keydn (DGROUP:4C4E in PLAYGAME.MAP), never
- * on another keydn entry: scan 1..4 in dirtrect.c's DirtyBoxes, scan 5 in the next modules'
- * buffers, scan 5..0x48 in gifc.c's decoder tables, 0x49..0x4A in the atexit table and higher
- * in the far end of the 15000 byte stack. Those are all written before they are read, so the
- * stray byte had no effect: the key does not read as held (keydn[scan] stays 0).
- */
-export declare function setStartKey(keydn: Uint8Array, key: number): void;
-/** changeblks: animate background blocks. */
-export declare function changeBlocks(w: World): void;
-interface SceneResult {
-    ok: boolean;
-    link: number;
-    /**
-     * The level played at the end and the one before it: another level's after F6 loaded a game
-     * saved there (LoadGame sets play's curscene and oldscene, globals in the C).
-     */
-    doscene?: number;
-    prevscene?: number;
-}
-/** What F5 writes to game<n>.sav (this port's JSON in place of SaveGame's binary records). */
-export interface Saved {
-    version: 1;
-    prevscene: number;
-    doscene: number;
-    linkin: number;
-    sndClock: number;
-    world: Pick<World, 'nxtchg' | 'ci' | 'mx' | 'my' | 'mi' | 'mm' | 'noMons' | 'blkMon'> & {
-        blkmap: number[];
-        map: number[];
-        mapMon: number[];
-        chr: {
-            x: number[];
-            y: number[];
-            cframe: number;
-            cseq: number;
-        };
-    };
-    rec: ReturnType<Recorder['snapshot']>;
-}
-/** playscene: plays one level. link in/out follows the original's conventions. */
-export declare function playScene(s: Session, dosc: number, prev: number, linkIn: number): Promise<SceneResult>;
-/** The save of a game at this moment (F5; project/saveData's newGameSave makes one at the start). */
-export declare function savedState(w: World, where: {
-    prevscene: number;
-    doscene: number;
-    linkin: number;
-}, sndClock: number, rec: Pick<Recorder, 'snapshot'>): Saved;
-/**
- * F6's LoadGame once the save is read: the saved level loaded fresh, then the saved state put
- * over it (also how project/saveData's tests check a save it made). Undefined when the
- * level's files are missing.
- */
-export declare function restoreSaved(s: Pick<Session, 'game' | 'rand' | 'ci' | 'rec' | 'sndClock' | 'onTouched'> & {
-    m: {
-        files: {
-            get(name: string): Uint8Array | undefined;
-        };
-    };
-}, w: World | undefined, data: Saved): LoadedScene | undefined;
-export {};

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

@@ -1,16 +0,0 @@
-import { type World } from './world.js';
-/**
- * Scene setup: Scroll.up/down/left/right are stored mirrored in the .gam file (the
- * flags here name the way the map moves, e.g. `left` lets the map slide left as the
- * character walks right). 0xff means that direction is allowed.
- */
-export declare function initScroll(w: World, s: {
-    up: number;
-    down: number;
-    left: number;
-    right: number;
-}): void;
-/** ChangeScroll: decide scrolling speed from how far the character is from center. */
-export declare function changeScroll(w: World): number;
-/** DrawScroll: one 1/145.6 s scroll step. Returns how many new 4 pixel edge strips it took. */
-export declare function drawScroll(w: World): number;

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

@@ -1,39 +0,0 @@
-import type { Machine } from './machine.js';
-import { type PlayerLook } from './playerLook.js';
-export declare const RGB_RED: [number, number, number];
-export declare const RGB_BLUE: [number, number, number];
-export declare const RGB_YELLOW: [number, number, number];
-export declare const RGB_PURPLE: [number, number, number];
-export declare const match: (pal: Uint8Array, c: [number, number, number]) => number;
-interface GraphicOptions {
-    /** Receives the palette of the shown picture (the NewCols argument). */
-    cols?: Uint8Array;
-    /** Seconds to wait for a key; -1 = the default for the file type. */
-    pause?: number;
-    /** The game's current palette, used to pick text colors (`colors` global). */
-    gamePalette: Uint8Array;
-    /** The player's look (RunOptions.player): text page colors, default times. */
-    look?: PlayerLook;
-}
-/** Returns false when the player pressed Esc (which aborts slide shows). */
-export declare function showGraphic(m: Machine, file: string, opts: GraphicOptions): Promise<boolean>;
-/**
- * FLI::View: every frame once, `speed` vertical retraces (1/70 s) apart. The C drew
- * straight onto the VGA screen, so the animation starts over whatever is shown.
- *
- * A speed of 0 waits no retrace at all: the C's delay loop is
- *   for (uint Delay=0;Delay<Head.FrameSpd;Delay++) { wait out retrace; wait for retrace; }
- * so with FrameSpd 0 the next frame was decoded into video memory straight away, as fast
- * as the PC could read and draw it, and the monitor showed whatever was in video memory at
- * each refresh (frames in between were never seen). The port does the same: it draws the
- * next frame at once, only yielding to the event loop (no frame wait) so the page stays
- * responsive, and each browser repaint shows the frame that is current then. Speed 0 FLIs
- * on the CD (black.fli, menubkg.fli, textbkg.fli, ...) are one or two frame backgrounds.
- */
-export declare function playFli(m: Machine, file: string): Promise<boolean>;
-/**
- * Display_File: text pages over the current picture, 16 lines (rows 5..20 of 8 pixels)
- * per page. fgets(…, 32) read at most 31 characters at a time, so long lines wrap.
- */
-export declare function displayFile(m: Machine, file: string, col: number, pause: number, gamePalette: Uint8Array, bytes?: Uint8Array<ArrayBufferLike> | undefined, look?: PlayerLook): Promise<boolean>;
-export {};

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

@@ -1,62 +0,0 @@
-/**
- * The emulated slow PC behind the desk's TURBO button (turbo off).
- *
- * A 486DX2-66's turbo switch did not make it a 286. On most boards turbo off turned off
- * the CPU cache (some also dropped the bus or core clock), which left the machine at
- * roughly 286-16 to 386-25 speed, depending on the board. So turbo off here is "about a
- * fast 286": the PC Lewis played these games on, where they ran fine.
- *
- * Why they ran fine: playgame's main loop (PLAYGAME.C playscene) does two kinds of work.
- *  - Once per NewTimer interrupt (8 per game tick, 145.6 Hz), DrawScroll while the view
- *    scrolls. On a VGA/SVGA card this is hardware scrolling: it moves the CRTC start
- *    address, draws only the new 4 pixel strips at the edge (drawhorizside/
- *    drawvertside: 320x4 or 4x200 pixels each) and erases/redraws the character. It never
- *    redraws the whole screen.
- *  - Once per 18.2 Hz game tick: move and redraw the character and the monsters on screen,
- *    animate blocks, copy the dirty rectangles to the screen, check links.
- * On a 286-class PC a still tick costs about 15 ms plus a millisecond or so per monster on
- * screen, well under the 55 ms a tick lasts, so the game keeps full pace. Scrolling only
- * runs once per pass of the loop, and the pass that runs the game tick takes several
- * interrupts' worth of time; DrawScroll is called with a step of 1 however many
- * interrupts went by (its `speed` argument is commented out), so those scroll steps are
- * simply lost and the view trails the character a little more. Only a crowded screen
- * that is also scrolling can take longer than a tick, and then playgame skips the missed
- * tick (OldClock jumps to TimerCounter) instead of catching up.
- *
- * The figures below are estimates for that machine, in milliseconds. They are kept
- * deliberately simple and deterministic (no wall clock): the same keys give the same
- * game, and recordings replay the same way.
- */
-export interface PcCosts {
-    /** A game tick with nothing on screen but the character. */
-    tickMs: number;
-    /** Each monster drawn on screen that tick (move, erase, masked draw, dirty rect). */
-    monsterMs: number;
-    /** One DrawScroll call (Bresenham step, CRTC update, character erase/redraw). */
-    scrollPassMs: number;
-    /** Each new 4 pixel edge strip DrawScroll draws and copies to the screen. */
-    stripMs: number;
-}
-/** A 486DX2-66 with turbo off: about a 286-16. */
-export declare const TURBO_OFF: PcCosts;
-/**
- * Keeps track of the time the slow PC still owes on work it started, counted in NewTimer
- * interrupts. While it owes a whole interrupt or more, that loop pass never happens.
- */
-export declare class SlowCpu {
-    private readonly interruptMs;
-    /** Milliseconds of work still running. */
-    owed: number;
-    constructor(interruptMs: number);
-    /**
-     * Called once per NewTimer interrupt: true when the PC is still busy with earlier work
-     * and this interrupt's pass of the main loop (scroll step, game tick) is lost.
-     */
-    busy(): boolean;
-    spend(ms: number): void;
-    reset(): void;
-}
-/** What one game tick costs with `monsters` drawn on screen. */
-export declare function tickCost(pc: PcCosts, monsters: number): number;
-/** What one DrawScroll call costs when it drew `strips` new 4 pixel strips. */
-export declare function scrollCost(pc: PcCosts, strips: number): number;