@lewismoten/gamemaker-sandbox-tools 3.1.0 → 3.4.0

package/dist/types/kit/align.d.ts

@@ -0,0 +1,93 @@
+import { type Block } from '@lewismoten/gamemaker-sandbox-engine/formats/blocks';
+/** What a map cell holds, by block name ('' or undefined for unnamed). */
+export type NameAt = (x: number, y: number) => string | undefined;
+/** A wanted part: its name, or a test (a RegExp, or { test, toString } for the report). */
+type Want = string | {
+    test(got: string): boolean;
+    toString(): string;
+};
+/** Where a part wants its neighbors: [dx, dy, wanted]. */
+export type Need = [number, number, Want][];
+/** A part and the parts that must sit beside it. `need` may be a function of the part's regex
+ * match; with several needs (a part that can stand in more than one place of its object) one
+ * of them must hold. */
+export interface PartRule {
+    part: string | {
+        test(name: string): boolean;
+    };
+    need: Need | Need[] | ((m: RegExpExecArray) => Need);
+    /** Name for the report (default: the part's name). */
+    what?: string;
+    /** false: the neighbors it checks are not parts of its object (no art join to measure). */
+    joins?: boolean;
+}
+/** Every part whose neighbors are wrong: "name at x,y: wanted W at dx,dy, found G". Parts must
+ * not run off the map's edge either (playgame's maps wrap, so the other side is wrong too).
+ * Right-hand and lower neighbors that are right go into `joined` (JSON [left or upper, right or
+ * lower, 'h' or 'v']), the pairs whose art must join up. */
+export declare function checkParts(at: NameAt, rules: PartRule[], w?: number, h?: number, joined?: Set<string>): string[];
+/** Rules for objects whose parts are named by column and row (house:0,1 or cat12): every part
+ * wants every other part of its object. `sizes` gives each object's columns and rows; `name`
+ * turns object, column and row back into a part name. `alias` lets an animation frame stand
+ * in for a part. */
+export declare function gridParts(re: RegExp, sizes: Map<string, [number, number]>, name: (obj: string, c: number, r: number) => string, alias?: (got: string) => string): PartRule;
+/** Rules for an object drawn as rows of parts (null: any block): each part wants every other
+ * part of the object at its place (a part found at several places: at one of them). */
+export declare function shape(what: string, rows: (Want | null)[][]): PartRule[];
+/** Pairs: every `a` has a `b` at dx, dy and every `b` an `a` the other way. */
+export declare const pair: (what: string, a: Want, b: Want, dx: number, dy: number) => PartRule[];
+/** Rules read off the maps themselves, for a game whose objects are numbered parts (sign0
+ * sign1 sign2, or sign00 sign01 down a column): where part n mostly stands (`share` of the
+ * time) with part n+1 just right of it (or just below it), that is how the object goes
+ * together, and every part n and n+1 must be so. Numbered animation frames and patterns don't
+ * stand that way, so they get no rule.
+ * `skip` leaves out stems that only look like objects. */
+export declare function autoParts(maps: NameAt[], names: Iterable<string>, skip?: RegExp, share?: number): PartRule[];
+/** A block book's names by block number. */
+export declare function namesOf(index: Map<string, number>): string[];
+/** Object sizes (columns, rows) from a block set's part names matched by `re` (object, col, row). */
+export declare function sizesOf(names: Iterable<string>, re: RegExp): Map<string, [number, number]>;
+/** A block's picture: palette index at x, y (0..19). */
+type Pic = (x: number, y: number) => number;
+interface Seam {
+    a: string;
+    b: string;
+    dir: 'h' | 'v';
+    /** Mean color distance across the shared edge. */
+    across: number;
+    /** Draws the pair joined (scaled up) into a PNG, for a look. */
+    draw?: (file: string, s?: number) => void;
+    /** Mean color distance one pixel in from the edge, on the busier side (the art's own texture,
+     * so a pattern with a line on its edge, like tile grout, is not a break). */
+    within: number;
+}
+/** How sharply each joined pair's art changes across its shared edge ('h': b right of a,
+ * 'v': b below a), next to how much it changes one pixel either side of the edge. A seam
+ * whose `across` is far above `within` is where the art breaks (an outline, a jump). */
+export declare function seams(pic: (name: string) => Pic, pal: Uint8Array, pairs: [string, string, 'h' | 'v'][]): Seam[];
+/** Seams that look broken: the colors jump across the edge much more than beside it. */
+export declare function brokenSeams(s: Seam[], factor?: number, floor?: number): Seam[];
+/** One adventure scene of a built disk: its name, palette, map and background blocks. */
+export interface DiskScene {
+    desc: string;
+    map: string;
+    pal: Uint8Array;
+    blocks: Uint8Array;
+    bbl: Block[];
+}
+/** Every adventure scene on a built disk (the .gam's scenes, by their files). */
+export declare function diskScenes(disk: string): DiskScene[];
+/** A PNG of map cells x..x+w, y..y+h of a disk scene (wrapping like playgame), scaled `s`
+ * times; `blocks` overrides the scene's block pictures (to show art before a fix). */
+export declare function writeArea(file: string, sc: DiskScene, x: number, y: number, w: number, h: number, s?: number, blocks?: Block[]): void;
+/** Checks a built disk: every map's multi-block objects (names: each map file's block names by
+ * number, undefined to skip the map) by the rules (or each map's own rules), and the art of every pair the maps join. */
+export declare function auditDisk(disk: string, names: (map: string) => string[] | undefined, rules: PartRule[] | ((map: string) => PartRule[]), opts?: {
+    factor?: number;
+    floor?: number;
+}): {
+    maps: [string, string[]][];
+    seams: Seam[];
+    broken: Seam[];
+};
+export {};

package/dist/types/kit/audioEvents.d.ts

@@ -0,0 +1,26 @@
+export type AudioEvent = {
+    t: number;
+    kind: 'song';
+    bytes?: Uint8Array;
+} | {
+    t: number;
+    kind: 'stopSong';
+} | {
+    t: number;
+    kind: 'pause';
+    paused: boolean;
+} | {
+    t: number;
+    kind: 'speaker';
+    freqs: ArrayLike<number>;
+} | {
+    t: number;
+    kind: 'stopSpeaker';
+} | {
+    t: number;
+    kind: 'voc';
+    bytes?: Uint8Array;
+} | {
+    t: number;
+    kind: 'stopVoc';
+};

package/dist/types/kit/blit.d.ts

@@ -0,0 +1,20 @@
+import { Pixels } from './pixels.js';
+export declare const CLEAR = 255;
+/** Copies src over dst, skipping clear pixels. */
+export declare function over(dst: Pixels, src: Pixels, x?: number, y?: number): Pixels;
+/** Recolors every pixel through a lookup (palette swaps for variants and hurt flashes). */
+export declare function recolor(src: Pixels, fn: (c: number) => number): Pixels;
+/** Nearest-neighbor scaled copy (for big sprites on screens). */
+export declare function scaleBlit(dst: Pixels, src: Pixels, x: number, y: number, s: number, flip?: boolean, transparent?: number): void;
+/** Adds a 1 pixel outline in `ink` around every opaque pixel. */
+export declare function outline(src: Pixels, ink: number, options?: {
+    transparent?: number;
+    ignoreInk?: boolean;
+}): Pixels;
+export declare function asciiSprite(rows: string[], key: Record<string, number>, dx?: number, dy?: number, w?: number, h?: number): Pixels;
+/** Draw ASCII art through the indexed canvas. */
+export declare const asciiArt: (p: Pixels, x: number, y: number, rows: string[], key: Record<string, number>) => Pixels;
+/** Scale with an explicit transparent color and no mirroring. */
+export declare const scaleBlitTransparent: (dst: Pixels, src: Pixels, x: number, y: number, scale: number, transparent?: number) => void;
+/** In-place variant for existing sprite canvases. */
+export declare function outlineInPlace(p: Pixels, ink: number, transparent?: number): Pixels;

package/dist/types/kit/blockRoles.d.ts

@@ -0,0 +1,243 @@
+import { type Block } from '@lewismoten/gamemaker-sandbox-engine/formats/blocks';
+export type RoleGroup = 'Ground' | 'Doors' | 'Loot' | 'Furniture' | 'Spawn';
+export interface RoleInfo {
+    id: string;
+    label: string;
+    group: RoleGroup;
+    hint: string;
+}
+export declare const ROLES: readonly [{
+    readonly id: "floor";
+    readonly label: "Floor";
+    readonly group: "Ground";
+    readonly hint: "Something to walk on";
+}, {
+    readonly id: "wall";
+    readonly label: "Wall";
+    readonly group: "Ground";
+    readonly hint: "Solid on every side";
+}, {
+    readonly id: "wall-top";
+    readonly label: "Wall top";
+    readonly group: "Ground";
+    readonly hint: "The top edge of a wall";
+}, {
+    readonly id: "wall-edge";
+    readonly label: "Wall edge or corner";
+    readonly group: "Ground";
+    readonly hint: "An edge or corner piece of a wall set";
+}, {
+    readonly id: "path";
+    readonly label: "Path or road";
+    readonly group: "Ground";
+    readonly hint: "A path, road or trail";
+}, {
+    readonly id: "water";
+    readonly label: "Water";
+    readonly group: "Ground";
+    readonly hint: "Water to cross or swim";
+}, {
+    readonly id: "shore";
+    readonly label: "Shore";
+    readonly group: "Ground";
+    readonly hint: "Where land meets water";
+}, {
+    readonly id: "tree";
+    readonly label: "Tree";
+    readonly group: "Ground";
+    readonly hint: "A tree";
+}, {
+    readonly id: "rock";
+    readonly label: "Rock";
+    readonly group: "Ground";
+    readonly hint: "A rock or boulder";
+}, {
+    readonly id: "sky";
+    readonly label: "Sky";
+    readonly group: "Ground";
+    readonly hint: "Open air behind a platform level";
+}, {
+    readonly id: "decoration";
+    readonly label: "Decoration";
+    readonly group: "Ground";
+    readonly hint: "Looks nice, does nothing";
+}, {
+    readonly id: "hazard";
+    readonly label: "Hazard";
+    readonly group: "Ground";
+    readonly hint: "Hurts the hero";
+}, {
+    readonly id: "platform";
+    readonly label: "Platform";
+    readonly group: "Doors";
+    readonly hint: "Solid on top only: stand on it from above";
+}, {
+    readonly id: "ladder";
+    readonly label: "Ladder";
+    readonly group: "Doors";
+    readonly hint: "Pulls the hero up or down";
+}, {
+    readonly id: "door";
+    readonly label: "Door";
+    readonly group: "Doors";
+    readonly hint: "Open; turns into another block when touched";
+}, {
+    readonly id: "locked-door";
+    readonly label: "Locked door";
+    readonly group: "Doors";
+    readonly hint: "Needs a key (same lock number)";
+}, {
+    readonly id: "exit";
+    readonly label: "Exit";
+    readonly group: "Doors";
+    readonly hint: "Leads out of the level";
+}, {
+    readonly id: "entry";
+    readonly label: "Entry";
+    readonly group: "Doors";
+    readonly hint: "Where the hero comes in";
+}, {
+    readonly id: "stairs-up";
+    readonly label: "Stairs up";
+    readonly group: "Doors";
+    readonly hint: "Stairs going up";
+}, {
+    readonly id: "stairs-down";
+    readonly label: "Stairs down";
+    readonly group: "Doors";
+    readonly hint: "Stairs going down";
+}, {
+    readonly id: "chest";
+    readonly label: "Chest";
+    readonly group: "Loot";
+    readonly hint: "A chest that holds something";
+}, {
+    readonly id: "treasure";
+    readonly label: "Treasure";
+    readonly group: "Loot";
+    readonly hint: "Money or score when picked up";
+}, {
+    readonly id: "key";
+    readonly label: "Key";
+    readonly group: "Loot";
+    readonly hint: "Opens a locked door with the same lock number";
+}, {
+    readonly id: "life";
+    readonly label: "Heart or life";
+    readonly group: "Loot";
+    readonly hint: "Adds a life";
+}, {
+    readonly id: "powerup";
+    readonly label: "Power-up";
+    readonly group: "Loot";
+    readonly hint: "Picked up to help the hero";
+}, {
+    readonly id: "chair";
+    readonly label: "Chair";
+    readonly group: "Furniture";
+    readonly hint: "Faces one way";
+}, {
+    readonly id: "table";
+    readonly label: "Table";
+    readonly group: "Furniture";
+    readonly hint: "A table or desk";
+}, {
+    readonly id: "bed";
+    readonly label: "Bed";
+    readonly group: "Furniture";
+    readonly hint: "A bed";
+}, {
+    readonly id: "counter";
+    readonly label: "Counter";
+    readonly group: "Furniture";
+    readonly hint: "A shop counter or bar";
+}, {
+    readonly id: "shelf";
+    readonly label: "Shelf";
+    readonly group: "Furniture";
+    readonly hint: "A shelf or bookcase";
+}, {
+    readonly id: "rug";
+    readonly label: "Rug";
+    readonly group: "Furniture";
+    readonly hint: "A rug on the floor";
+}, {
+    readonly id: "lamp";
+    readonly label: "Lamp";
+    readonly group: "Furniture";
+    readonly hint: "A lamp or torch";
+}, {
+    readonly id: "stove";
+    readonly label: "Stove";
+    readonly group: "Furniture";
+    readonly hint: "A stove or fireplace";
+}, {
+    readonly id: "plant";
+    readonly label: "Plant";
+    readonly group: "Furniture";
+    readonly hint: "A pot plant or flower";
+}, {
+    readonly id: "monster-spawn";
+    readonly label: "Monster spawn";
+    readonly group: "Spawn";
+    readonly hint: "Gives birth to monsters";
+}, {
+    readonly id: "hero-start";
+    readonly label: "Hero start";
+    readonly group: "Spawn";
+    readonly hint: "Where the hero begins";
+}];
+export type Role = (typeof ROLES)[number]['id'];
+export declare const ROLE_IDS: readonly Role[];
+export declare const ROLE_GROUPS: readonly RoleGroup[];
+export declare const FACINGS: readonly ["N", "E", "S", "W"];
+export type Facing = (typeof FACINGS)[number];
+export declare const FACING_NAMES: Record<Facing, string>;
+export declare const MAX_PAIR = 10;
+export declare const hasFacing: (roles: readonly Role[]) => boolean;
+export declare const hasPair: (roles: readonly Role[]) => boolean;
+/** What is kept for one block. */
+export interface BlockRole {
+    roles: Role[];
+    /** Which way a furniture block faces. */
+    facing?: Facing;
+    /** The lock number (1..MAX_PAIR) a locked door and its key share. */
+    pair?: number;
+}
+/** Roles by block number; blocks with no roles are left out. */
+export type RoleMap = Record<number, BlockRole>;
+/** Stored roles made safe to use: unknown roles and numbers out of range dropped, no repeats, extras only where they apply. */
+export declare function cleanRoles(raw: unknown, count: number): RoleMap;
+/** The map to store: only blocks that have roles, in block order (undefined when there are none). */
+export declare function packRoles(map: RoleMap): Record<string, BlockRole> | undefined;
+/** The blocks that hold a role (with a lock number, only those with that pair). */
+export declare function blocksWithRole(map: RoleMap, role: Role, pair?: number): number[];
+export interface RoleSuggestion {
+    role: Role;
+    /** Why, in a few words, for the chip's tooltip. */
+    why: string;
+    /** The lock number a door or key suggestion implies. */
+    pair?: number;
+}
+export interface SuggestContext {
+    /** The set's palette (768 bytes, 6-bit), to read the picture's colors. Without it the picture is not looked at. */
+    palette?: Uint8Array;
+    /** Whether the block is already in one of the set's terrains (edge sets), which suggests an edge piece. */
+    inTerrain?: boolean;
+}
+/** The share of the picture that is blue, and its average brightness (0..1), or undefined with no palette. */
+export declare function pictureBlue(pixels: Uint8Array, palette: Uint8Array): {
+    blue: number;
+    light: number;
+} | undefined;
+/**
+ * Roles a background block seems to have. Pure and never applied by itself: the block editor shows
+ * these as dim chips. Rules (the design note's table): solid all round is a wall; solid on top only a
+ * platform; touching turns it into another block, a door; a negative counter 20..29 a lock; a
+ * pick-up that adds money or score is treasure, that adds to a counter 20..29 a key, that adds a life
+ * a life; hurting on touch a hazard; an upward pull a ladder; births monsters a spawn; a mostly
+ * blue picture water or sky.
+ */
+export declare function suggestRoles(b: Block, index: number, ctx?: SuggestContext): RoleSuggestion[];
+/** Suggestions not yet chosen (what the editor shows as dim chips). */
+export declare function pendingSuggestions(have: readonly Role[], s: RoleSuggestion[]): RoleSuggestion[];

package/dist/types/{games/kit → kit}/clips.d.ts

@@ -1,4 +1,4 @@
-import type { AudioEvent } from '../../web/src/walkthrough/runtime.js';
+import type { AudioEvent } from './audioEvents.js';
 export interface ClipCut {
     kind: 'end' | 'start';
     /** The scene the clip started in. */

package/dist/types/kit/coverPaint.d.ts

@@ -0,0 +1,7 @@
+type RGB = [number, number, number];
+export declare const mixc: (a: RGB, b: RGB, t: number) => RGB;
+export declare const clamp: (v: number) => number;
+export declare const smooth: (e0: number, e1: number, x: number) => number;
+/** Value noise (smooth, seeded) for textures. */
+export declare function noise2(seed: number): (x: number, y: number) => number;
+export {};

package/dist/types/kit/disk.d.ts

@@ -0,0 +1,15 @@
+export declare class Disk {
+    readonly dir: string;
+    readonly files: Map<string, Uint8Array<ArrayBufferLike>>;
+    constructor(dir: string);
+    /** Adds a file (8.3 name, lower case on disk). */
+    put(name: string, bytes: Uint8Array | string): void;
+    /**
+     * Replace the selected output directory's contents with the collected native files. Each file
+     * is written beside its place and renamed over it, and leftovers go last, so a server reading
+     * the folder during a rebuild never finds a file missing or half written.
+     */
+    write(dir?: string): number;
+}
+/** Legacy eight-bit text with CR LF line endings; out-of-range characters become question marks. */
+export declare function dosText(s: string): Uint8Array;

package/dist/types/kit/fadeOut.d.ts

@@ -0,0 +1,12 @@
+import { encodeFli } from '@lewismoten/gamemaker-sandbox-engine/formats/fli';
+/** Frames in a fade at `speed` (1/70 s per frame): about `seconds` long, and at least 4. */
+export declare function fadeOutLength(speed: number, seconds?: number): number;
+type FliOpts = NonNullable<Parameters<typeof encodeFli>[2]>;
+/**
+ * encodeFli with a fade to black after the last frame: `fade` palette-only frames (by default
+ * about half a second at the FLI's speed). `palettes`, when given, is a palette per frame.
+ */
+export declare function encodeFliFadeOut(frames: Uint8Array[], palette: Uint8Array, opts?: FliOpts & {
+    fade?: number;
+}): Uint8Array;
+export {};

package/dist/types/kit/fliClips.d.ts

@@ -0,0 +1,32 @@
+import { type ShrinkStep } from './fliShrink.js';
+import { type SlideEntry } from '@lewismoten/gamemaker-sandbox-engine/formats/graphicScripts';
+/** How long an FLI plays, in seconds (FLI::View waits `speed` 1/70 s after each frame). */
+export declare function fliSeconds(fli: Uint8Array): number;
+/** How cartoons are cut and written (both off by default, so other games' bytes stay the same). */
+export interface ClipOptions {
+    /** Each clip without encodeFli's closing ring frame, which nothing plays. */
+    noLoopFrame?: boolean;
+    /** Cut where opening on a whole frame costs the fewest extra bytes, not where least changes. */
+    cheapCuts?: boolean;
+    /** Shrink steps (fliShrink.ts) run on every FLI's frames before it is cut and written. */
+    shrink?: ShrinkStep[];
+}
+/**
+ * The FLI as clips of at most `seconds` each, by file name in play order. One that plays no
+ * longer than a quarter more than `seconds` stays whole, under its own name.
+ */
+export declare function fliClips(name: string, source: Uint8Array, seconds?: number, opts?: ClipOptions): Record<string, Uint8Array>;
+/** The clips' slide-list entries: no pause between them, `pause` after the last. */
+export declare function clipEntries(clips: Record<string, Uint8Array>, pause?: number): SlideEntry[];
+/**
+ * On a whole disk (lower-case file name to bytes, as Disk keeps them): every long FLI the
+ * lists named in `lists` play is cut into clips, and every slide list on the disk that plays it
+ * plays the clips instead, the entry's pause after the last. For a build whose lists are
+ * written in several places.
+ */
+export declare function clipLists(files: Map<string, Uint8Array>, lists: string[], seconds?: number, opts?: ClipOptions): void;
+/**
+ * `clipLists` on every slide list on the disk: the title's, story's and help's, and the
+ * game's own (endings, game over, cut scenes), so Esc answers within a few seconds anywhere.
+ */
+export declare function clipEveryList(files: Map<string, Uint8Array>, seconds?: number, opts?: ClipOptions): void;

package/dist/types/kit/fliShrink.d.ts

@@ -0,0 +1,149 @@
+/** An FLI's frames as the player shows them: pixels and the (6-bit) palette per frame. */
+export interface FliFrames {
+    frames: Uint8Array[];
+    palettes: Uint8Array[];
+    width: number;
+    height: number;
+    /** The wait after each frame, in 1/70 s. */
+    speed: number;
+}
+/** How the encoder writes the frames (set by steps, passed to encodeFrames). */
+export interface FliEncodeOptions {
+    sparsePalettes?: boolean;
+}
+/** How much a step changes what shows, frame for frame against the frames the step was given (0 to 255 per color channel). */
+export interface Visibility {
+    /** The mean over every pixel of every frame (0 = identical). */
+    mean: number;
+    /** The biggest single difference. */
+    worst: number;
+    /** How many pixels differ at all, as a share of all of them (0 to 1). */
+    changedShare: number;
+}
+export interface StepResult {
+    name: string;
+    /** True when what shows is exactly the same. */
+    lossless: boolean;
+    frames: FliFrames;
+    encode: FliEncodeOptions;
+    bytesBefore: number;
+    bytesAfter: number;
+    savedBytes: number;
+    visibility: Visibility;
+}
+/** Every frame's pixels and palette, as FLI::View leaves the screen after it (the ring frame is not one). */
+export declare function decodeFli(fli: Uint8Array): FliFrames;
+/** The frames as an FLI (no ring frame, run packets on). */
+export declare function encodeFrames(f: FliFrames, opts?: FliEncodeOptions): Uint8Array;
+export interface FrameReport {
+    frame: number;
+    bytes: number;
+    /** Bytes by chunk type name (the frame header's 16 bytes under 'header'). */
+    chunks: Record<string, number>;
+    /** Pixels that differ from the frame before. */
+    changedPixels: number;
+}
+export interface FliReport {
+    totalBytes: number;
+    frames: FrameReport[];
+    /** Bytes by chunk type name over every frame. */
+    byChunk: Record<string, number>;
+    /** Plain-words reasons the file is big, biggest first; suggestions, not verdicts. */
+    findings: string[];
+}
+/** Bytes per chunk type for every frame, and why the file is the size it is. */
+export declare function fliReport(fli: Uint8Array): FliReport;
+/** What shows, original against `result` (frame i of the original is `map(i)` of the result). */
+export declare function visibilityOf(orig: FliFrames, result: FliFrames, map?: (i: number) => number): Visibility;
+/**
+ * Lossy: a pixel alone between two pixels (left and right, or above and below) of one other
+ * color within `tolerance` takes that color, so dithering and speckle between close shades
+ * flatten into runs. Gradients show as bands; edges and sprites keep their shape.
+ */
+export declare function flattenDitherStep(orig: FliFrames, opts: {
+    tolerance: number;
+}, base?: FliEncodeOptions): StepResult;
+/** Lossless: palette changes only for the colors a frame draws. */
+export declare function sparsePalettesStep(orig: FliFrames, base?: FliEncodeOptions): StepResult;
+/**
+ * Lossy: a pixel whose color is within `tolerance` (0 to 255 per channel) of what it was the
+ * frame before keeps the old index, so dither or noise that shifts a little stops costing
+ * bytes. Frames whose palette changes (fades) are left alone.
+ */
+export declare function holdStillStep(orig: FliFrames, opts: {
+    tolerance: number;
+}, base?: FliEncodeOptions): StepResult;
+/**
+ * Lossy: colors within `tolerance` of a more used color in the first frame's palette are
+ * merged into it in every frame, so near-identical shades stop making changes.
+ */
+export declare function snapColorsStep(orig: FliFrames, opts: {
+    tolerance: number;
+}, base?: FliEncodeOptions): StepResult;
+/** Lossy: at most `colors` different colors drawn in the whole animation; the least used are replaced by their nearest kept one. */
+export declare function maxColorsStep(orig: FliFrames, opts: {
+    colors: number;
+}, base?: FliEncodeOptions): StepResult;
+/**
+ * Lossy: every other frame is dropped and the wait doubles, so the cartoon lasts as long.
+ * The result is steppier. Fades keep their last frames; a wait over 255 is not offered.
+ */
+export declare function dropFramesStep(orig: FliFrames, base?: FliEncodeOptions): StepResult;
+export type ShrinkStep = {
+    step: 'sparsePalettes';
+} | {
+    step: 'holdStill';
+    tolerance: number;
+} | {
+    step: 'snapColors';
+    tolerance: number;
+} | {
+    step: 'flattenDither';
+    tolerance: number;
+} | {
+    step: 'maxColors';
+    colors: number;
+} | {
+    step: 'onePalette';
+    colors: number;
+} | ({
+    step: 'frame';
+} & FrameOptions) | {
+    step: 'dropFrames';
+};
+/** Runs the steps in order, each on the one before's frames; the last result's `frames` and `encode` make the file. */
+export declare function shrinkFrames(orig: FliFrames, steps: ShrinkStep[]): StepResult[];
+/** What shows over a whole chain of steps: the end result against the original, exactly (a dropped frame's picture stands for the two it replaces). */
+export declare function chainVisibility(orig: FliFrames, last: FliFrames): Visibility;
+/**
+ * Lossy (lossless when the animation already draws no more than `colors` shades): one palette
+ * for the whole animation, the `colors` (up to 256) that best stand for every shade it shows, and
+ * every frame redrawn in it. No COLOR chunk follows the first frame, so a fade becomes pixel
+ * changes, which often cost more than the palette changes did. The numbers say which way it went.
+ */
+export declare function onePaletteStep(orig: FliFrames, opts: {
+    colors: number;
+}, base?: FliEncodeOptions): StepResult;
+/** How `frameStep` frames the picture; every number is in pixels except `zoom`. */
+export interface FrameOptions {
+    /** Solid bands left at each edge. */
+    top: number;
+    bottom: number;
+    left: number;
+    right: number;
+    /** The picture's scale inside the bands: 1 = its own pixels, under 1 shrinks it, over 1 magnifies it. */
+    zoom: number;
+    /** Where the picture's center sits in the original's pixels, from the middle (0 = centered). */
+    panX: number;
+    panY: number;
+}
+/** The palette entry bands are drawn in: color 0 when the first palette makes it black, else its darkest color. */
+export declare function bandColor(pal: Uint8Array): number;
+/**
+ * Lossy (lossless when nothing is set): the picture stays the same size, but only the area inside
+ * the bands shows it. The bands are one solid color (`bandColor`) and never change after the first
+ * frame, so they cost next to nothing. At zoom 1 the bands just cover the picture's edges. Otherwise the picture is scaled by `zoom` about its center, moved by
+ * the pan, into the middle of that area: smaller by averaging the pixels it covers into the nearest
+ * color of the frame's own palette, larger by repeating pixels (no new colors, edges stay crisp).
+ */
+export declare function frameStep(orig: FliFrames, o: FrameOptions, base?: FliEncodeOptions): StepResult;

package/dist/types/{games/kit → kit}/gameSim.d.ts

@@ -1,6 +1,6 @@
-import { type CharInfo, type World } from '../../web/src/engine/world.js';
-import { type Game } from '../../web/src/formats/game.js';
-import type { RecordedKey } from '../../web/src/formats/recording.js';
+import { type CharInfo, type World } from '@lewismoten/gamemaker-sandbox-engine/engine/world';
+import { type Game } from '@lewismoten/gamemaker-sandbox-engine/formats/game';
+import type { RecordedKey } from '@lewismoten/gamemaker-sandbox-engine/formats/recording';
 /** PLAYGAME's game clock. */
 export declare const TICKS_PER_SECOND = 18.2;
 /** A built disk's files (in games/<id>/disk), by lower-case name. */
@@ -10,7 +10,7 @@ interface SceneKeys {
     scene: number;
     keys: RecordedKey[];
 }
-interface State {
+export interface State {
     w: World;
     rand: number;
     scene: number;
@@ -55,6 +55,8 @@ export declare class GameSim {
     private rand;
     ended: 'won' | 'lost' | undefined;
     deaths: number;
+    /** The inventory slot the drop picker answers with once (set it before pressing the drop key; -1, the default, is Esc). */
+    dropSlot: number;
     /**
      * The .VOC clip the Sound Blaster is playing (PlaySbVocFile: a new one cuts it off), with
      * the game clock tick it ends on; a scene's exit or intro picture cuts it too (ShowGraphic).
@@ -72,6 +74,8 @@ export declare class GameSim {
     releaseAll(): void;
     isHeld(scan: number): boolean;
     private event;
+    /** Writes key `k` into the segment (without playing it in this sim): the drop picker's own keys, which the real engine reads. */
+    private record;
     /** One game tick; returns 'link' (into another scene), 'dead' or 'end'. */
     tick(): Promise<'link' | 'dead' | 'end' | undefined>;
     /** Game ticks until the clip playing now ends (0 when none is). */
@@ -95,7 +99,7 @@ export declare class GameSim {
     /** The block number at (x, y) as it is now (a block taken or pushed is a new block number). */
     blockAt(x: number, y: number): number;
     /** The block's attributes as shown now (timed blocks change by themselves). */
-    shown(x: number, y: number): import("../../web/src/formats/blocks.js").Block;
+    shown(x: number, y: number): import("@lewismoten/gamemaker-sandbox-engine/formats/blocks").Block;
     solidAt(x: number, y: number): boolean;
     snapshot(): State;
     restore(s: State): void;