@lewismoten/gamemaker-sandbox-tools 3.1.0 → 3.4.0

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

@@ -0,0 +1,72 @@
+import type { GameSim } from './gameSim.js';
+export type Dir = 'left' | 'right';
+export type Result = string | undefined;
+/** The keys every hopping game has: arrows, and Q/E to hop sideways. */
+interface HopKeys {
+    up: number;
+    down: number;
+    left: number;
+    right: number;
+    q: number;
+    e: number;
+}
+interface HopSetup<K extends HopKeys> {
+    /** The game's key scan codes (src/ids.ts SCAN). */
+    scan: K;
+    /** The level map's origin in scene blocks (src/levels/maps.ts ORIGIN). */
+    origin: number;
+    /** The meter BOT_HURT prints beside a hurt: its name and its number. */
+    meter: {
+        name: string;
+        n: number;
+    };
+    /** The scan codes BOT_TRACE lists when held (the arrows and Q/E unless said). */
+    traced?: number[];
+}
+export declare class HopBot<S extends GameSim = GameSim, K extends HopKeys = HopKeys> {
+    readonly sim: S;
+    log: string[];
+    readonly scan: K;
+    private readonly origin;
+    private readonly meterShown;
+    private readonly traced;
+    constructor(sim: S, setup: HopSetup<K>);
+    snapshot(): {
+        sim: import("./gameSim.js").State;
+        log: number;
+    };
+    restore(s: ReturnType<HopBot['snapshot']>): void;
+    /** The hero's position in level pixels (left/top of its bottom block). */
+    get px(): {
+        x: number;
+        y: number;
+    };
+    /** Its block (level coordinates), rounded to the nearest. */
+    get at(): {
+        x: number;
+        y: number;
+    };
+    say(s: string): void;
+    tick(): Promise<Result>;
+    wait(k: number): Promise<Result>;
+    /** Waits until the hero stops moving up or down (standing, or holding on to something). */
+    land(max?: number): Promise<Result>;
+    /** Before each step of a walk: a game's chance to stop for something (keys still held). */
+    protected beforeStep(_dir: Dir): Promise<Result>;
+    /** Before a hop (and before a walk hops what blocks it, `dir` still held): a game's chance to wait. */
+    protected beforeHop(_dir?: Dir): Promise<Result>;
+    /** Walks to level column `bx` (its left edge at bx * 20 px), hopping over whatever stops it. */
+    walk(bx: number, label?: string, max?: number): Promise<Result>;
+    /**
+     * A hop: Up (or Q/E sideways) held `hold` ticks; then `steer` held while it falls, until it
+     * lands or has gone `steerTo` columns (level block x).
+     */
+    hop(dir: Dir | 'up', hold?: number, steer?: Dir, steerTo?: number): Promise<Result>;
+    /** Holds a key for `ticks` (Down to climb down, Up to climb up, Space for the game's action). */
+    hold(key: keyof K, ticks: number): Promise<Result>;
+    /** Climbs (or walks) along one axis until the hero reaches level column/row `to`. */
+    dig(dir: 'left' | 'right' | 'up' | 'down', to: number, label?: string, max?: number): Promise<Result>;
+    /** Holds `key` until `check` says so (or `max` ticks: then it fails). */
+    until(key: keyof K | undefined, check: () => boolean, label: string, max?: number): Promise<Result>;
+}
+export {};

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

@@ -0,0 +1,16 @@
+import { type LaserSheet } from './laserSvg.js';
+export interface Element {
+    name: string;
+    from: number;
+    to: number;
+}
+export interface Close {
+    a: string;
+    b: string;
+    mm: number;
+}
+/**
+ * Every pair of elements closer than the gap: `gap` mm, or `holeGap` when either is a hole (its name starts "hole").
+ * The coin's own outline cut is not an element; pass it as part of a "hole" if it should count.
+ */
+export declare function tooClose(sheet: LaserSheet, elements: Element[], gap?: number, holeGap?: number): Close[];

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

@@ -0,0 +1,39 @@
+import type { Pt } from './laserSvg.js';
+/** x0, y0, x1, y1 */
+export type Rect = readonly [number, number, number, number];
+/** The single outer boundary of (union of `base`) minus (union of `minus`), as a polygon with no collinear points. */
+export declare function outlineFromRects(base: readonly Rect[], minus?: readonly Rect[]): Pt[];
+/** The polygon grown by `d` mm all round (negative shrinks it): mitered, any winding. Use +kerf/2 for a part, -kerf/2 for a hole. */
+export declare function offsetPoly(pts: readonly Pt[], d: number): Pt[];
+export interface EdgeSpec {
+    /** Which cells are set in: 'odd' leaves this panel flush on the even cells. */
+    parity: 'even' | 'odd';
+    /** Also set in the corner cubes at the ends (a panel that does not own them). */
+    ends?: boolean;
+    /** A corner cube of size t sits at the start / end of the edge, outside the cell row. */
+    cubeStart?: boolean;
+    cubeEnd?: boolean;
+    /** Wanted cell width in mm (default 9). */
+    target?: number;
+}
+/** The cell row of an edge of length E: where it starts, how wide each cell is, and how many (odd). */
+export declare function cellRow(E: number, t: number, s: Pick<EdgeSpec, 'cubeStart' | 'cubeEnd' | 'target'>): {
+    a0: number;
+    a1: number;
+    m: number;
+    cw: number;
+};
+/** The stretches [a, b] along an edge where the panel is set in by t, each widened by `fit` so the joint has a little play. */
+export declare function notchSpans(E: number, t: number, s: EdgeSpec, fit?: number): [number, number][];
+export interface Edges {
+    top?: EdgeSpec;
+    bottom?: EdgeSpec;
+    left?: EdgeSpec;
+    right?: EdgeSpec;
+}
+/** A w x h panel with joint notches on the edges given, minus `cuts` and plus `adds` (tabs for slots, etc.). */
+export declare function jointOutline(w: number, h: number, t: number, edges: Edges, fit?: number, cuts?: readonly Rect[], adds?: readonly Rect[]): Pt[];
+/** A rectangle as a polygon. */
+export declare const rectPoly: (r: Rect) => Pt[];
+/** A point turned about `c` by `deg` degrees (clockwise on the sheet, y down) . */
+export declare const rotate: (p: Pt, c: Pt, deg: number) => Pt;

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

@@ -0,0 +1,54 @@
+import { type FontName } from './laserPixels.js';
+import { type Close, type Element } from './laserClearance.js';
+import { LaserSheet, type Pt } from './laserSvg.js';
+/** The Glowforge bed's usable area in mm, and the room left between parts on a sheet. */
+export declare const BED: {
+    readonly w: 495;
+    readonly h: 279;
+};
+export declare const PART_GAP = 4;
+export declare class Part {
+    readonly name: string;
+    readonly w: number;
+    readonly h: number;
+    readonly kerf: number;
+    readonly sheet: LaserSheet;
+    readonly elements: Element[];
+    readonly texts: {
+        text: string;
+        capMm: number;
+    }[];
+    constructor(name: string, w: number, h: number, kerf: number);
+    private el;
+    private shift;
+    /** The part's outline: grown by half a kerf. */
+    outline(pts: readonly Pt[]): void;
+    /** A hole or slot through the part: shrunk by half a kerf. */
+    hole(label: string, pts: readonly Pt[]): void;
+    holeRound(label: string, cx: number, cy: number, r: number): void;
+    outlineRound(cx: number, cy: number, r: number): void;
+    /** Engraving: convex polygons only (the preview and spacing check assume it). */
+    engrave(label: string, shapes: readonly (readonly Pt[])[]): void;
+    engraveRound(label: string, cx: number, cy: number, r: number): void;
+    text(s: string, font: FontName, cx: number, cy: number, px: number): void;
+    /** Pairs of elements nearer than `gap` mm (holes: `holeGap`). */
+    close(gap?: number, holeGap?: number): Close[];
+    get size(): {
+        w: number;
+        h: number;
+    };
+}
+export interface Placed {
+    name: string;
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+/** Rows of parts on one sheet (left to right, each row below the last). Throws if it does not fit the bed. */
+export declare function packRows(title: string, rows: Part[][], w?: 495, gap?: number): {
+    sheet: LaserSheet;
+    placed: Placed[];
+    w: number;
+    h: number;
+};

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

@@ -0,0 +1,52 @@
+import { LaserSheet, type Pt } from './laserSvg.js';
+export type Rect = readonly [x: number, y: number, w: number, h: number];
+export interface Bitmap {
+    w: number;
+    h: number;
+    on: (x: number, y: number) => boolean;
+}
+export type FontName = 'pc' | 'micro';
+/** Pixels across and down a capital letter, and the step from one letter to the next, in each font. */
+export declare const FONTS: {
+    readonly pc: {
+        readonly cap: 7;
+        readonly adv: 8;
+        readonly gw: 7;
+    };
+    readonly micro: {
+        readonly cap: 5;
+        readonly adv: 4;
+        readonly gw: 3;
+    };
+};
+/** Lit pixels as rectangles: a row's runs, joined by identical runs on the rows below. */
+export declare function mergeRuns(b: Bitmap): Rect[];
+/** Engrave every rectangle, its corners mapped from pixel space to millimeters by `map`. */
+export declare function engraveRects(sheet: LaserSheet, rects: Rect[], map: (x: number, y: number) => Pt): void;
+/** Only what a font can draw, in capitals (anything else is dropped, so a name never throws). */
+export declare const drawable: (font: FontName, s: string) => string;
+/** The width of `s` in pixels (the last letter's trailing gap left out). */
+export declare const textPixels: (font: FontName, s: string) => number;
+/** One line of text, centered on (cx, cy), each pixel `px` mm. Returns the text's width and height in mm. */
+export declare function lineText(sheet: LaserSheet, s: string, font: FontName, cx: number, cy: number, px: number): {
+    w: number;
+    h: number;
+};
+/**
+ * Text set round a circle about (cx, cy): `top` reads left to right over the top with its feet at radius `r`; otherwise
+ * it runs along the bottom, left to right, with its feet at the outer radius `r` and its heads toward the middle.
+ * Each pixel is `px` mm. Returns the angle the line spans in degrees.
+ */
+export declare function arcText(sheet: LaserSheet, s: string, font: FontName, cx: number, cy: number, r: number, px: number, top: boolean): number;
+export type Rgb = readonly [number, number, number];
+/**
+ * A picture engraved by tone from its own colors (0 to 1 per channel; `rgb` gives undefined where clear): dark colors solid,
+ * mid colors (clothes, hair, hats) as a checker or lines coarse enough to read at coin size, skin and very light colors left
+ * as wood. Every edge pixel stays solid, and so does a mid pixel that touches skin or light wood, so collars, sleeves, belts
+ * and hems read as outlines and a figure never looks bare.
+ */
+export declare function toneBitmap(w: number, h: number, rgb: (x: number, y: number) => Rgb | undefined): Bitmap;
+/** The angle in degrees `s` would span round a circle: what arcText returns, without drawing. */
+export declare function arcSpanDeg(s: string, font: FontName, r: number, px: number, top: boolean): number;
+/** The columns and rows holding lit pixels: [x0, y0, x1, y1] (end exclusive), or undefined when none. */
+export declare function inkBox(b: Bitmap): [number, number, number, number] | undefined;

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

@@ -0,0 +1,9 @@
+import { type LaserSheet } from './laserSvg.js';
+/** RGB bytes, `pxPerMm` pixels to the millimeter, each pixel averaged from `ss` x `ss` samples. */
+export declare function renderPreview(sheet: LaserSheet, pxPerMm: number, ss?: number): {
+    w: number;
+    h: number;
+    rgb: Uint8Array;
+};
+/** A truecolor PNG from RGB bytes. */
+export declare function pngFromRgb(w: number, h: number, rgb: Uint8Array): Uint8Array;

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

@@ -0,0 +1,35 @@
+export declare const CUT = "#ff0000";
+export declare const SCORE = "#ff00ff";
+export declare const ENGRAVE = "#0000ff";
+export declare const HAIRLINE = 0.1;
+export type Pt = readonly [number, number];
+export type Op = 'cut' | 'score' | 'engrave';
+export type Item = {
+    op: Op;
+    k: 'circle';
+    cx: number;
+    cy: number;
+    r: number;
+} | {
+    op: Op;
+    k: 'poly';
+    pts: Pt[];
+} | {
+    op: 'engrave';
+    k: 'ring';
+    cx: number;
+    cy: number;
+    r0: number;
+    r1: number;
+};
+export declare class LaserSheet {
+    readonly w: number;
+    readonly h: number;
+    readonly items: Item[];
+    constructor(w: number, h: number);
+    add(item: Item): this;
+    /** Copy another sheet's items onto this one, moved by (dx, dy) millimeters. */
+    place(other: LaserSheet, dx: number, dy: number, only?: Op[]): this;
+    count(op: Op): number;
+    svg(title: string): string;
+}

package/dist/types/kit/levelGen/castle.d.ts

@@ -0,0 +1,17 @@
+import { type Area, type Stream } from './grid.js';
+export declare const CASTLE_MIN: {
+    w: number;
+    h: number;
+};
+export interface Castle {
+    area: Area;
+    /** Inside the gate. */
+    entry: number;
+    /** The far end of the keep. */
+    exit: number;
+}
+/** A castle filling a w by h area (at least 30 by 24). `path` draws a road from the gate to the keep door; `decorate` scatters decoration in the courtyard. */
+export declare function castle(w: number, h: number, r: Stream, o: {
+    path: boolean;
+    decorate: boolean;
+}): Castle;

package/dist/types/kit/levelGen/dungeon.d.ts

@@ -0,0 +1,11 @@
+import { type Area, type Stream } from './grid.js';
+export interface Dungeon {
+    area: Area;
+    entry: number;
+    exit: number;
+    rooms: number;
+    /** Whether decoration was placed (needs the role). */
+    decorated: boolean;
+}
+/** A dungeon filling a w by h area (at least 12 by 12). `decorate` sprinkles decoration cells in the rooms. */
+export declare function dungeon(w: number, h: number, r: Stream, decorate: boolean): Dungeon;

package/dist/types/kit/levelGen/forest.d.ts

@@ -0,0 +1,17 @@
+import { type Area, type Stream } from './grid.js';
+/** The cheapest route over per-cell costs (Dijkstra with a binary heap). */
+export declare function route(a: Area, from: number, to: number, cost: Float32Array): number[];
+export interface Forest {
+    area: Area;
+    entry: number;
+    exit: number;
+    open: number;
+    trail: boolean;
+}
+export interface ForestUses {
+    path: boolean;
+    rock: boolean;
+    decor: boolean;
+}
+/** A forest filling a w by h area (at least 12 by 12). The uses switch on the trail, rocks and flowers. */
+export declare function forest(w: number, h: number, r: Stream, uses: ForestUses): Forest;

package/dist/types/kit/levelGen/furnish.d.ts

@@ -0,0 +1,31 @@
+import type { Facing, Role } from '../blockRoles.js';
+import { type Area, type Stream } from './grid.js';
+export declare const DIR: Record<Facing, readonly [number, number]>;
+export interface Item {
+    cell: number;
+    role: Role;
+    /** Which way the front looks (the block with this facing is chosen). */
+    facing?: Facing;
+    /** A rug: walkable, drawn over the floor. */
+    open?: boolean;
+}
+export interface Room {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+/** The facings each role has a block for (all four when a block of the role says none); a missing role has no entry. */
+export type Avail = Partial<Record<Role, readonly Facing[]>>;
+export declare function furnisher(area: Area, entry: number, avail: Avail, r: Stream, keep: Set<number>): {
+    items: Item[];
+    skipped: Set<string>;
+    commit: (list: Item[]) => boolean;
+    against: (room: Room, role: Role, len: number, walls?: readonly Facing[]) => boolean;
+    table: (room: Room, chairs: boolean, len: number) => number[] | undefined;
+    corner: (room: Room, role: Role) => boolean;
+    rug: (cells: number[]) => void;
+    free: (c: number) => boolean;
+    at: (x: number, y: number) => number;
+    shuffle: <T>(list: readonly T[]) => T[];
+};

package/dist/types/kit/levelGen/grid.d.ts

@@ -0,0 +1,46 @@
+/** Seeded random numbers (mulberry32): the same seed always gives the same stream. */
+export declare function stream(seed: number): {
+    next: () => number;
+    /** An integer from lo to hi, both included. */
+    int: (lo: number, hi: number) => number;
+    chance: (p: number) => boolean;
+    pick: <T>(list: readonly T[]) => T;
+};
+export type Stream = ReturnType<typeof stream>;
+/** What a cell of a generated area is, before blocks are chosen. */
+export declare const WALL = 0;
+export declare const FLOOR = 1;
+export declare const PATH = 2;
+export declare const TREE = 3;
+export declare const ROCK = 4;
+export declare const DECOR = 5;
+/** Cells the props pass adds (open to walk on): a locked door, its key, treasure, a heart. */
+export declare const LOCK = 6;
+export declare const KEY = 7;
+export declare const TREASURE = 8;
+export declare const LIFE = 9;
+/** Furniture a person cannot walk through (interiors); a door cell in a wall (open: the entry and exit of an interior, a gate). */
+export declare const FURN = 10;
+export declare const DOORC = 11;
+/** Water (overworlds) and a house's roof row (towns); neither can be walked on. */
+export declare const WATER = 12;
+export declare const ROOF = 13;
+/** Side views (platform): open air, a ladder, spikes (hurt), and a ledge that is solid on top only. */
+export declare const SKY = 14;
+export declare const LADDER = 15;
+export declare const HAZARD = 16;
+export declare const PLAT = 17;
+/** Cells a person or monster cannot stand on. */
+export declare const closed: (c: number) => c is 0 | 12 | 4 | 10 | 3 | 13;
+export interface Area {
+    w: number;
+    h: number;
+    cells: Uint8Array;
+}
+export declare const newArea: (w: number, h: number, fill: number) => Area;
+/** Steps from `from` to every open cell (-1 where it cannot be reached), moving along the four sides. */
+export declare function distances(a: Area, from: number): Int32Array;
+/** True when every one of the eight neighbors (and the cell) is open and inside the area. */
+export declare function openAround(a: Area, x: number, y: number): boolean;
+/** The open cell farthest from `from` by steps (the first of any tie in reading order). */
+export declare function farthest(a: Area, from: number): number;

package/dist/types/kit/levelGen/index.d.ts

@@ -0,0 +1,138 @@
+import { type RoleMap } from '../blockRoles.js';
+import { type GenKind } from './needs.js';
+import { type LockInfo } from './props.js';
+import { type SceneLink } from './town.js';
+import { type PlatformProof } from './platform.js';
+import type { Character } from '@lewismoten/gamemaker-sandbox-engine/formats/character';
+import { type Item } from './furnish.js';
+export { type Item as Furniture } from './furnish.js';
+export { type SceneLink } from './town.js';
+export { heroPhysics, weaker, type HeroPhysics } from './jumpModel.js';
+export { capability, type Capability } from './platformCap.js';
+export { reachFrom, type Step } from './platformReach.js';
+export { LADDER as LADDER_CELL } from './grid.js';
+export { closed as closedCell, DOORC as DOOR_CELL, FLOOR as FLOOR_CELL, LOCK as LOCK_CELL, PATH as PATH_CELL } from './grid.js';
+export { type PlatformProof } from './platform.js';
+export { type LockInfo } from './props.js';
+export { KINDS, checkNeeds, kindInfo, type GenKind, type KindInfo, type NeedItem, type NeedsReport } from './needs.js';
+export interface Rect {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+export interface GenParams {
+    kind: GenKind;
+    seed: number;
+    /** The part of the map to draw in (cells). */
+    rect: Rect;
+    /** Monster numbers (from the game's .mon file) that may be placed; none or left out: no monsters. */
+    monsters?: number[];
+    /** The map wraps over its edges (overworld land then lines up across the seam). */
+    wrap?: boolean;
+    /** The hero's character file: a platform layout is sized to his real jump (the other kinds ignore it). */
+    hero?: Character;
+    /** Platform: how much of the hero's most the layout asks of him, in percent (10 to 100; 80 when left out). */
+    difficulty?: number;
+}
+export declare const MIN_SIDE = 10;
+/** What the cells of a result are, for edges: which cells (area-local indexes) belong to a role's terrain. */
+export type TerrainRole = 'wall' | 'tree' | 'path' | 'water';
+export interface GenResult {
+    rect: Rect;
+    /** A block number per cell of the rectangle, in reading order. */
+    blocks: Uint8Array;
+    /** The same cells as a plain kind (0 wall, 1 floor, 2 path, 3 tree, 4 rock, 5 decoration). */
+    kinds: Uint8Array;
+    /** Cells (rectangle-local indexes) a terrain brush should give edges and corners to. */
+    terrainCells: Partial<Record<TerrainRole, number[]>>;
+    /** Where the hero could come in, and a far cell for an exit, as rectangle-local indexes. Proposals only. */
+    entry: number;
+    exit: number;
+    /** Locked doors with the cell of the key that opens each (rectangle-local), nearest the entry first. Dungeons only. */
+    locks: LockInfo[];
+    /** Cells of treasure, and of a heart or extra life if one was placed (rectangle-local). */
+    treasure: number[];
+    life?: number;
+    /** Monsters to place as map monsters: a monster number and a rectangle-local start cell. */
+    monsters: {
+        cell: number;
+        monnum: number;
+    }[];
+    /** Furniture (interiors): the cell, the role, which way the front looks, and the block chosen. Rugs are walkable. */
+    furniture: (Item & {
+        block: number;
+    })[];
+    /** Where the shopkeeper could stand (shops), a proposal like the entry. */
+    shopkeeper?: number;
+    /** Doors and sites a person could link to other scenes (towns and overworlds): proposals only, nothing is linked. */
+    links: SceneLink[];
+    /** Platform only: what was proven by jump math, the difficulty drawn and what the hero can do (cells). */
+    platform?: {
+        proof: PlatformProof;
+        difficulty: number;
+        can: {
+            rise: number;
+            gap: number;
+        };
+        asked: {
+            rise: number;
+            gap: number;
+        };
+    };
+    /** What was left out, in plain words. */
+    notes: string[];
+}
+export type GenOutcome = {
+    ok: true;
+    result: GenResult;
+} | {
+    ok: false;
+    message: string;
+};
+/** The seed of offer `i` (0..3) from a base seed: four different layouts that stay the same every time. */
+export declare const offerSeed: (base: number, i: number) => number;
+/** Draws one layout into `params.rect`. Fails with a plain message when a needed role is missing or the area is small. */
+export declare function generate(roles: RoleMap, params: GenParams): GenOutcome;
+/** Whether every open cell of a result can be reached from its entry (a check the generators should always pass). */
+export declare function verifyReach(result: GenResult): {
+    ok: boolean;
+    open: number;
+    reached: number;
+};
+export interface Proof {
+    /** Every open cell can be reached from the entry (locks opened by their keys). */
+    reach: boolean;
+    /** Each key can be reached before its own lock (and every lock after it). */
+    keysFirst: boolean;
+    /** Every key, treasure and the exit can be collected by playing the keys out. */
+    collectable: boolean;
+    /** Furniture: every piece has a reachable open side, each chair looks at a table and the door's inside is open. True with none. */
+    furnished: boolean;
+    /** Every proposed door and site (towns, overworlds) can be reached from the entry. True with none. */
+    linked: boolean;
+}
+/** The generator's own proof for a result: reach, key-before-lock and that everything can be collected. */
+export declare function proveResult(result: GenResult): Proof;
+export declare const PROP_KINDS: {
+    LOCK: number;
+    KEY: number;
+    TREASURE: number;
+    LIFE: number;
+};
+export interface PlatformParams {
+    /** The block set's roles (needs wall and sky; ladder, platform, hazard, wall-top, treasure, life, a lock and key pair and decoration are used when set). */
+    roles: RoleMap;
+    /** The hero's character file (hero.chr, parsed): his walk, jump and climb size the layout. */
+    hero: Character;
+    /** The same seed always draws the same layout. */
+    seed: number;
+    /** Where in the map to draw: at least 40 by 20 cells (more than 120 by 24 is drawn in the middle). */
+    rect: Rect;
+    /** How much of the hero's most (pit width, step height) it asks, in percent: 10 to 100, 80 when left out. */
+    difficulty?: number;
+    /** Monster numbers to stand on the long stretches. */
+    monsters?: number[];
+}
+/** A side view layout for a game's build.ts: `generate` with the platform kind. See the tools README. */
+export declare function generatePlatform(p: PlatformParams): GenOutcome;

package/dist/types/kit/levelGen/interior.d.ts

@@ -0,0 +1,18 @@
+import { type Area, type Stream } from './grid.js';
+import { type Avail, type Item } from './furnish.js';
+export interface Interior {
+    area: Area;
+    entry: number;
+    exit: number;
+    items: Item[];
+    /** Where the shopkeeper could stand (shops, behind the counter). */
+    shopkeeper?: number;
+    /** Roles whose pieces were left out because no block faced the right way. */
+    skipped: string[];
+}
+export declare const INTERIOR_MIN: {
+    w: number;
+    h: number;
+};
+/** An interior filling at most a 24 (home) or 26 (shop) by 16 or 14 part of the middle of a w by h area. */
+export declare function interior(w: number, h: number, r: Stream, kind: 'home' | 'shop', avail: Avail): Interior;

package/dist/types/kit/levelGen/jumpModel.d.ts

@@ -0,0 +1,78 @@
+import { type Character } from '@lewismoten/gamemaker-sandbox-engine/formats/character';
+export interface HeroPhysics {
+    /** Pixels a tick when walking (and when steering in the air). */
+    vx: number;
+    /** The jump's pushes: the upward push (negative) added to his speed on each tick it lasts, from tick 0. */
+    push: number[];
+    /** Whether he can steer in the air (the jump is not a sequence the walk key cannot interrupt). */
+    steer: boolean;
+    /** A climbing sequence exists (up key moves him up while the block holds him). */
+    climb: boolean;
+    /** The highest a jump takes him, in pixels (straight up). */
+    rise: number;
+    /** The keys (PC scan codes) of his moves, as the character file sets them. A bot presses these. */
+    keys: {
+        right: number;
+        left?: number;
+        jump: number;
+        up?: number;
+        down?: number;
+    };
+}
+export type PhysicsOutcome = {
+    ok: true;
+    physics: HeroPhysics;
+} | {
+    ok: false;
+    message: string;
+};
+/** Reads the hero's walk, jump and climb from a character file; a plain message when a side view cannot be made for him. */
+export declare function heroPhysics(chr: Character): PhysicsOutcome;
+/** A copy of the physics made weaker (0..1 of the walk speed and of the jump push), for checking with margin. */
+export declare function weaker(p: HeroPhysics, speed: number, push: number): HeroPhysics;
+/** Longest arc played (ticks). */
+export declare const ARC_TICKS = 90;
+/**
+ * One jump (the push at once) or a fall (no push) played a tick at a time: `dir` is -1, 0 or 1, and he steers that
+ * way for `steerTicks` ticks (then lets go). `step` gives the pixels moved on a tick (x to the right, y down), before
+ * anything is in the way; `bump` is a ceiling stopping the rise.
+ */
+export declare class Flight {
+    private readonly p;
+    private readonly kind;
+    private readonly dir;
+    private readonly steerTicks;
+    private vy;
+    private t;
+    constructor(p: HeroPhysics, kind: 'jump' | 'fall', dir: -1 | 0 | 1, steerTicks: number);
+    step(): {
+        dx: number;
+        dy: number;
+    };
+    /**
+     * A block with no gravity holds him (engine/character.ts onGround): the tick he reaches it his speed fades to 5/6 once; after
+     * that `slide` moves him by his speed and fades it twice a tick (the ground check runs after the sideways move and again
+     * after the vertical one), while the walk key goes on steering him for its ticks.
+     */
+    fade(): void;
+    slide(): {
+        dx: number;
+        dy: number;
+        done: boolean;
+    };
+    /** He has landed (the ground check stopped his fall): his speed is gone, and the gravity clock runs on. */
+    land(): void;
+    bump(): void;
+}
+/** The pixels moved on each tick of a jump or fall in the open. */
+export declare function arcOf(p: HeroPhysics, kind: 'jump' | 'fall', dir: -1 | 0 | 1, steerTicks: number): {
+    dx: number[];
+    dy: number[];
+};
+export interface ArcVariant {
+    kind: 'jump' | 'fall';
+    dir: -1 | 0 | 1;
+    steerTicks: number;
+}
+/** The arcs the reach search tries: a jump or a fall, either way or straight up, steering for different lengths. */
+export declare function arcVariants(): ArcVariant[];