@lewismoten/gamemaker-sandbox-tools 3.1.0 → 3.4.0

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

@@ -1,48 +0,0 @@
-export declare const LASTMON = 64;
-export declare const LASTSL = 20;
-export declare const MAXMARCH = 10;
-export declare const MONSTER_SIZE = 300;
-export declare const NORMALMOVEMENT = 0;
-export declare const ATTACKMOVEMENT = 1;
-export interface March {
-    /** Block offset from the previous corner (first corner: from the start). */
-    x: number;
-    y: number;
-    /** Speed (pixels per tick) to move toward this corner; 0 ends the path. */
-    pic: number;
-    /** Picture orientation (0-7) while moving to this corner. */
-    orient: number;
-}
-export interface Monster {
-    used: number;
-    /** Non-zero: monster is not affected by gravity (unused by playgame). */
-    fly: number;
-    jump: number;
-    stick: number;
-    /** Higher power kills lower power; >= 100 (CHARPOWER) can't be killed by touching the character. */
-    power: number;
-    /** Non-zero: monster stops at solid blocks. */
-    thru: number;
-    /** Animation: [block number (>= 100 ends), ticks to show] x 21. */
-    pic: [number, number][];
-    lasttime: number;
-    /** Monster this becomes when it dies (64 = none). */
-    newmon: number;
-    /** Score bonus when killed by the character's weapons. */
-    upscore: number;
-    xtra: Uint8Array;
-    /** 0 no attack path, 1 attack path is absolute, 2 relative to the character. */
-    activate: number;
-    /** -2 never dies, -1 dies after path, 0 dies when killed, > 0 lifetime in ticks. */
-    end: number;
-    /** 0 follow path, 1..63 toward the character at this speed (negative: away), >= 64 random (speed = towards >> 6). */
-    towards: number;
-    close: [number, number];
-    /** [normal path, attack path], 10 corners each. */
-    march: [March[], March[]];
-    cur: March;
-}
-export declare function parseMonsters(bytes: Uint8Array): Monster[];
-export declare function serializeMonsters(mons: Monster[]): Uint8Array;
-export declare function emptyMonster(): Monster;
-export declare function newMonsterSet(): Monster[];

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

@@ -1,15 +0,0 @@
-export declare const PALETTE_SIZE: number;
-export type Palette = Uint8Array;
-export declare function parsePalette(bytes: Uint8Array): Palette;
-export declare function serializePalette(pal: Palette): Uint8Array;
-/** Expands 6-bit VGA components to packed 0xAABBGGRR values for ImageData/Uint32Array. */
-export declare function paletteToRGBA(pal: Palette): Uint32Array;
-export declare function vga8(v: number): number;
-export declare function paletteCss(pal: Palette, index: number): string;
-/**
- * Port of RGBdata::Match: the palette index whose color is closest to (r,g,b)
- * (6-bit components), by squared distance; first match wins ties.
- */
-export declare function matchColor(pal: Palette, r: number, g: number, b: number): number;
-/** Default palette GameMaker editors start with: a rainbow ramp plus grays (port of RainbowCols-ish). */
-export declare function defaultPalette(): Palette;

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

@@ -1,7 +0,0 @@
-export declare const RECLEN = 1000;
-export interface RecordedKey {
-    delta: number;
-    key: number;
-}
-export declare function parseRecording(bytes: Uint8Array): RecordedKey[];
-export declare function serializeRecording(keys: RecordedKey[]): Uint8Array;

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

@@ -1,13 +0,0 @@
-export declare const LASTSND = 30;
-export declare const NUMFREQ = 36;
-export declare const SOUND_NAMES: string[];
-export interface SoundSet {
-    /** freqs[n] has NUMFREQ frequencies in Hz (0 = silence). */
-    freqs: Uint16Array[];
-    /** Digital .voc file name (without extension) for each effect, '' = use PC speaker. */
-    digital: string[];
-    digitalRaw: Uint8Array[];
-}
-export declare function parseSoundSet(bytes: Uint8Array): SoundSet;
-export declare function serializeSoundSet(s: SoundSet): Uint8Array;
-export declare function newSoundSet(): SoundSet;

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

@@ -1,13 +0,0 @@
-interface DecodedVoc {
-    sampleRate: number;
-    samples: Float32Array;
-}
-export declare function isVoc(bytes: Uint8Array): boolean;
-export declare function decodeVoc(bytes: Uint8Array): DecodedVoc;
-/**
- * Encodes mono samples (-1..1) as an 8-bit unsigned PCM Creative Voice File, the kind a
- * Sound Blaster plays. The rate is stored as a time constant, so it is rounded the way
- * the card did (11025 Hz is stored as 10,989 Hz: time constant 165, 1,000,000 / 91).
- */
-export declare function encodeVoc(samples: Float32Array, sampleRate?: number): Uint8Array;
-export {};

package/dist/types/web/src/gfx/cp437Glyphs.d.ts

@@ -1,2 +0,0 @@
-/** The whole CP437 8x8 font: FONT8X8's ASCII plus GLYPHS, with NUL blank (256 x 8 rows, LSB = leftmost pixel). */
-export declare const FONT_CP437: Uint8Array;

package/dist/types/web/src/gfx/font8x8.d.ts

@@ -1,2 +0,0 @@
-/** 256 glyphs x 8 rows; characters outside printable ASCII are drawn as a box. */
-export declare const FONT8X8: Uint8Array;

package/dist/types/web/src/gfx/levelPicture.d.ts

@@ -1,81 +0,0 @@
-import { type Game, type Point, type Scene } from '../formats/game.js';
-import { type Palette } from '../formats/palette.js';
-export interface LevelPicture {
-    width: number;
-    height: number;
-    /** One palette index per pixel. */
-    pixels: Uint8Array;
-    palette: Palette;
-}
-/** A game's files by name (GameFiles fits). */
-export interface FileSource {
-    get(name: string): Uint8Array | undefined;
-}
-/**
- * `cols` x `rows` blocks of a level's map centered on `at`, drawn the way the game draws
- * them: background blocks in the level's palette, placed monsters (first frame) and the
- * hero (first frame) standing on `at`. Undefined when the level has no map.
- */
-export declare function levelPixels(files: FileSource, scene: Scene, at: Point, cols?: number, rows?: number): LevelPicture | undefined;
-/**
- * The first few levels in the order the game reaches them, each with where the hero
- * arrives (some games begin with an "intro" level of lettering, or a dark one). A game
- * whose front end links nowhere: its first level, from the middle of the map.
- */
-export declare function firstLevels(game: Game, max?: number): Map<number, Point>;
-/** How interesting a picture is: plenty of colors, and not one color filling it (every 4th pixel looked at). */
-export declare function busyness(pic: LevelPicture): number;
-/** The most colorful of `pictures` (the first of equals), or undefined. */
-export declare function busiest(pictures: (LevelPicture | undefined)[]): LevelPicture | undefined;
-/** The pictures the build draws for each listed game (scripts/gameShots.ts): a home page tile's (8 x 5 blocks) and a screen's (16 x 10). */
-export declare const BUILT_SHOTS: readonly (readonly [number, number])[];
-/** Where the build puts a game's picture of `cols` x `rows` blocks. */
-export declare function builtShotPath(id: string, cols: number, rows: number): string;
-/** A game's picture: the most colorful of the first levels it reaches (renderShot's choice). */
-export declare function gamePicture(files: FileSource, game: Game, cols: number, rows: number): LevelPicture | undefined;
-/**
- * `w` x `h` blocks of a map from (`x`, `y`), as the game draws it: the background blocks in
- * the palette of the scene that uses the map, with its placed monsters on top (their first
- * animation frame). Undefined when no level uses the map, or its palette, map or blocks are missing.
- */
-export declare function mapPixels(files: FileSource, game: Game, mapName: string, x: number, y: number, w?: number, h?: number): LevelPicture | undefined;
-/**
- * `w` x `h` blocks of a scene's map from (`x`, `y`) in its own palette and blocks, with its
- * placed monsters (first frame). `cells` stands in for the map's background blocks (the
- * printed Level Maps draw the ground over what they hide). Undefined when the palette, map
- * or blocks are missing.
- */
-export declare function scenePixels(files: FileSource, scene: Scene, x: number, y: number, w?: number, h?: number, cells?: Uint8Array): LevelPicture | undefined;
-/** A view of a map: its name, the top-left block and the size in blocks. */
-export type MapView = [map: string, x: number, y: number, w: number, h: number];
-/**
- * The map views the build draws for an original game, from its box's screenshot spots: each
- * as a VGA screen (the box, the Game-Maker box, the manual cover) and the first as its disk
- * label's strip (desk/disks/diskLabel.ts).
- */
-export declare function builtMapViews(shots: readonly [string, number, number][] | undefined): MapView[];
-/** Where the build puts a map view's picture. */
-export declare function builtMapShotPath(id: string, [map, x, y, w, h]: MapView): string;
-/** A hero as a character file draws him: chr, cbl and pal file names, and which sequence (manual/printables Portrait). */
-export interface HeroSpec {
-    chr: string;
-    cbl: string;
-    pal: string;
-    seq?: number;
-}
-/** The hero an original game's paper shows (its hero sticker, else its ID card's portrait): the disk label and manual cover draw him. */
-export declare function heroOf(original: {
-    printables?: {
-        stickers?: {
-            hero?: HeroSpec;
-        }[];
-        items?: {
-            kind: string;
-            portrait?: HeroSpec;
-        }[];
-    };
-} | undefined): HeroSpec | undefined;
-/** The hero as he stands in his first frame: top and bottom block, 20 x 40, TRANSPARENT around him. */
-export declare function heroPixels(files: FileSource, p: HeroSpec): LevelPicture | undefined;
-/** Where the build puts a game's hero (heroOf), when it drew him. */
-export declare function builtHeroPath(id: string): string;

package/dist/types/web/src/gfx/screen.d.ts

@@ -1,46 +0,0 @@
-export declare const SIZEX = 320;
-export declare const SIZEY = 200;
-export declare class Screen {
-    readonly pixels: Uint8Array<ArrayBuffer>;
-    /** Palette currently shown by the "DAC" (6-bit components). */
-    readonly palette: Uint8Array<ArrayBuffer>;
-    readonly canvas: HTMLCanvasElement;
-    private ctx;
-    private image;
-    private rgba;
-    private lut;
-    private dirty;
-    constructor(canvas: HTMLCanvasElement);
-    setPalette(pal: ArrayLike<number>): void;
-    /** SetAllPalTo: every entry the same color. */
-    setPaletteTo(r: number, g: number, b: number): void;
-    setColor(index: number, r: number, g: number, b: number): void;
-    private updateLut;
-    markDirty(): void;
-    present(): void;
-    clear(col?: number): void;
-    point(x: number, y: number, col: number): void;
-    getCol(x: number, y: number): number;
-    /** BoxFill: inclusive corners. */
-    boxFill(x: number, y: number, x1: number, y1: number, col: number): void;
-    /** Box: rectangle outline. */
-    box(x: number, y: number, x1: number, y1: number, col: number): void;
-    line(x0: number, y0: number, x1: number, y1: number, col: number): void;
-    /**
-     * GPutChar: transparent background, 8x8 glyph from the BIOS font (GetROMFont). That ROM font
-     * holds only characters 0-127, and GPutChar takes a signed char (code/GM/GRAPHC.C), so 128-255
-     * read whatever lies before the font: scribbles on a real VGA card. They draw nothing here.
-     * (Text read from a file with TextDecoder('latin1') brings 0x80-0x9F as code points above 255.)
-     */
-    putChar(x: number, y: number, col: number, code: number): void;
-    /** GWrite: '\n' moves to the next line at the starting column. */
-    write(x: number, y: number, col: number, text: string): void;
-    /** drawblk / BufDrawBlk: opaque 20x20 block, clipped. */
-    drawBlock(x: number, y: number, pixels: Uint8Array): void;
-    /** BufDrawSpBlk: transparent (255) sprite with one of 8 orientations, clipped. */
-    drawSprite(x: number, y: number, orient: number, pixels: Uint8Array): void;
-    /** Copies an indexed image (e.g. a GIF) with its top-left at (-sx, -sy). */
-    drawImage(pixels: Uint8Array, width: number, height: number, sx?: number, sy?: number): void;
-    snapshot(): Uint8Array;
-    restore(snap: Uint8Array): void;
-}

package/dist/types/web/src/gfx/titlePicture.d.ts

@@ -1,21 +0,0 @@
-import { type Game } from '../formats/game.js';
-import { type FileSource, type LevelPicture } from './levelPicture.js';
-/**
- * The picture a graphic file shows: a GIF, a backdrop's window of one, an animation's last
- * frame, or the slide a slide list holds longest (its title, after the logos); text pages
- * (.txt) draw over whatever is up, so they have none. Splash screens and blank pictures are left out.
- */
-export declare function graphicPixels(files: FileSource, name: string, depth?: number): LevelPicture | undefined;
-/**
- * A game's title screen, 320 x 200: its title graphic (a slide list's title slide), or its
- * menu screen when it has none of its own (many shareware games show only a menu backdrop).
- * Undefined when it has neither, or they can't be read.
- */
-export declare function titlePixels(files: FileSource, game: Game): LevelPicture | undefined;
-/** Where the build puts a listed game's title screen (scripts/gameShots.ts). */
-export declare function builtTitlePath(id: string): string;
-/**
- * The files a game's title screen needs, fetched one by one (a slide list's slides, a
- * backdrop's GIF): for a page that has only the .gam so far.
- */
-export declare function titleSource(game: Game, fetch: (name: string) => Promise<Uint8Array | undefined>): Promise<FileSource>;

package/dist/types/web/src/input/chords.d.ts

@@ -1,22 +0,0 @@
-/** The DOM key codes of the four arrow keys (the keypad's own 8 4 6 2 never chord). */
-export declare const ARROW_CODES: Record<string, number>;
-/**
- * Turns the arrow keys physically held into the keys the game should see held.
- * `bound` says whether the game uses a key; chords whose key it doesn't use stay plain arrows.
- */
-export declare function chordKeys(held: ReadonlySet<number>, bound: (scan: number) => boolean): Set<number>;
-/**
- * Tracks the arrows held and the keys the game was told about, and returns the scan code
- * events (bit 7 set = released) that take the game from what it saw to what it should see.
- * Releases come before presses, so the game never sees a chord and its arrows held at once.
- */
-export declare class ArrowChords {
-    bound: (scan: number) => boolean;
-    private held;
-    private shown;
-    constructor(bound?: (scan: number) => boolean);
-    /** An arrow key went down or up; returns the events for the game. */
-    arrow(scan: number, pressed: boolean): number[];
-    /** Forgets everything (focus lost: the keyboard lets go of every key). */
-    reset(): void;
-}

package/dist/types/web/src/input/deskMouse.d.ts

@@ -1,14 +0,0 @@
-/** dx, dy in 320x200 screen pixels (fractions allowed); buttons: 1 = left, 2 = right. */
-type DeskMouseListener = (dx: number, dy: number, buttons: number) => void;
-/** Listens to the desk mouse; returns the function that stops listening. */
-export declare function listenDeskMouse(f: DeskMouseListener): () => void;
-/** The desk mouse rolled by (dx, dy) screen pixels with these buttons down. */
-export declare function deskMouse(dx: number, dy: number, buttons: number): void;
-/** Moves a pointer by whole pixels, keeping the fractions for next time. */
-export declare class Mickeys {
-    private rx;
-    private ry;
-    /** Whole pixels to move now for a roll of (dx, dy). */
-    take(dx: number, dy: number): [number, number];
-}
-export {};

package/dist/types/web/src/input/keyboard.d.ts

@@ -1,39 +0,0 @@
-import { ArrowChords } from './chords.js';
-export interface TypedKey {
-    scan: number;
-    /** ASCII code (0 for extended keys such as arrows). */
-    ascii: number;
-    /** The DOM key, for text entry. */
-    key: string;
-}
-export declare class Keyboard {
-    /** Scan code events; bit 7 set = released. */
-    readonly events: number[];
-    readonly typed: TypedKey[];
-    readonly down: Set<number>;
-    private target?;
-    private waiters;
-    /** Two arrows held together stand for the keypad key between them when the game binds it. */
-    readonly chords: ArrowChords;
-    /** Which keys the game binds, for arrow chords (none: arrows stay arrows). */
-    set chordable(bound: ((scan: number) => boolean) | undefined);
-    private onDown;
-    private onUp;
-    private onBlur;
-    attach(target?: EventTarget): void;
-    detach(): void;
-    private handle;
-    /** One scan code event for the game (an arrow chord's press or release). */
-    private apply;
-    /** Simulates a key event (touch controls, gamepad, demo playback). */
-    inject(scan: number, pressed: boolean): void;
-    /** Queues a recorded scan code as-is (demo playback while a screen waits for a key). */
-    feed(scan: number): void;
-    releaseAll(): void;
-    /** bioskey(1)/bioskey(0): peek or take the next typed key. */
-    peekKey(): TypedKey | undefined;
-    readKey(): TypedKey | undefined;
-    clear(): void;
-    /** Resolves on the next key press. */
-    nextPress(): Promise<void>;
-}

package/dist/types/web/src/input/scancodes.d.ts

@@ -1,3 +0,0 @@
-export declare const SCAN: Record<string, number>;
-export declare function scanToAscii(scan: number): number;
-export declare function scanName(scan: number): string;

package/dist/types/web/src/manual/printables/types.d.ts

@@ -1,277 +0,0 @@
-/** Extras every game gets, made from its catalog entry, manual and disk files. */
-export type GeneratedKind = 'postcard' | 'keycard' | 'catalog' | 'bbs' | 'warranty' | 'newsletter' | 'hintoffer' | 'stickers' | 'worldmap' | 'levelmaps';
-/** A spot on a map, in blocks (0-99), with a label. */
-interface MapMark {
-    x: number;
-    y: number;
-    label: string;
-    /** 'secret' marks print as a red star; 'start' as a green arrow; anything else a numbered dot. */
-    kind?: 'secret' | 'start' | 'goal' | 'shop' | 'note';
-}
-/** A window onto one of the game's .map files, drawn from the real blocks. */
-export interface MapPanel {
-    map: string;
-    x: number;
-    y: number;
-    w: number;
-    h: number;
-    caption?: string;
-    marks?: MapMark[];
-    /** The map is a course through the wrap: drawn as the run the player rides, in columns (levelCoursePoster.ts), not as the window. */
-    course?: boolean;
-}
-interface ItemBase {
-    /** The name in the "What's in the box" tray. */
-    title: string;
-    /** True when the manual promises it to registered players (it shows a "Registered" seal). */
-    promised?: boolean;
-    /** One line under the title in the tray. */
-    note?: string;
-}
-/** A printed map or poster: one or more map windows with marks and a legend. */
-export interface MapItem extends ItemBase {
-    kind: 'map';
-    heading?: string;
-    intro?: string;
-    /** The first panel spans the sheet; the rest sit `columns` to a row (default 2). */
-    panels: MapPanel[];
-    columns?: 1 | 2;
-    /** Footnotes under the map. */
-    legend?: string[];
-    landscape?: boolean;
-}
-/** A hint book. Answers are printed under red noise; read them through the red film. */
-export interface HintBookItem extends ItemBase {
-    kind: 'hintbook';
-    intro?: string;
-    /** What the cover shows, when the automatic pick (hintCoverArt.ts) is poor. */
-    cover?: HintCover;
-    sections: {
-        head: string;
-        hints: {
-            q: string;
-            a: string;
-            sketch?: HintSketch;
-        }[];
-    }[];
-}
-/**
- * A hint book cover's art. `hero`: a character file (its scene's blocks and palette are
- * found), or the three files. `scene`: "title" (the title screen), a GIF of the game's, or a
- * map window [map, x, y] (16 x 10 blocks). Colors are CSS colors; the box's are the default.
- */
-export interface HintCover {
-    hero?: string | Portrait;
-    scene?: string | [map: string, x: number, y: number];
-    background?: string;
-    accent?: string;
-}
-/**
- * A little drawing printed under the red film below a hint's answer: `rows` of cells, one
- * character each (see SKETCH_GLYPHS in redFilm.ts: # wall, = brick, : faint seam, X the
- * spot, @ you, T tree, o round thing, ~ water, . path, > < v ^ arrows, - | lines, space
- * nothing), and `labels` written in at a cell (x across, y down).
- */
-export interface HintSketch {
-    rows: string[];
-    labels?: {
-        x: number;
-        y: number;
-        text: string;
-    }[];
-}
-/** A typed or handwritten letter. body is simple HTML (<p>, <b>, <i>). */
-export interface LetterItem extends ItemBase {
-    kind: 'letter';
-    letterhead?: string;
-    /** Second line of the letterhead (an address in the game's world). */
-    address?: string;
-    date?: string;
-    to?: string;
-    body: string;
-    signature: string;
-    /** 'type' (typewriter), 'hand' (handwriting) or 'print' (laser printer, the default). */
-    style?: 'type' | 'hand' | 'print';
-}
-/** A newspaper front page from the game's world. */
-export interface NewspaperItem extends ItemBase {
-    kind: 'newspaper';
-    masthead: string;
-    date: string;
-    price?: string;
-    headline: string;
-    deck?: string;
-    /** Simple HTML, one entry per column. */
-    columns: string[];
-    /** An optional photo: a window onto a map. */
-    photo?: MapPanel;
-    /** Small stories along the bottom: [headline, text]. */
-    briefs?: [string, string][];
-}
-/** Diary or ledger pages. */
-export interface JournalItem extends ItemBase {
-    kind: 'journal';
-    heading?: string;
-    entries: {
-        date: string;
-        html: string;
-    }[];
-}
-/** The hero from a .CHR file: the first frame of a sequence (0 = standing). */
-export interface Portrait {
-    chr: string;
-    cbl: string;
-    pal: string;
-    seq?: number;
-}
-/** An ID card, license or membership card from the game's world. */
-export interface IdCardItem extends ItemBase {
-    kind: 'idcard';
-    org: string;
-    name: string;
-    role: string;
-    fields: [string, string][];
-    /** Card color and ink. */
-    color?: string;
-    ink?: string;
-    /** Photo: a map window centered on the hero (2x2 blocks works well). */
-    photo?: MapPanel;
-    /** Or the hero himself, from his character file (drawn over `photo` if both are given). */
-    portrait?: Portrait;
-    /** Text on the back of the card. */
-    back?: string;
-}
-/** Tables on paper: a chart, a price list, a world list. */
-export interface ChartItem extends ItemBase {
-    kind: 'chart';
-    heading?: string;
-    intro?: string;
-    tables: {
-        head: string;
-        note?: string;
-        columns: string[];
-        rows: string[][];
-    }[];
-}
-/** A fold-out star chart: a hub, sectors around it, worlds in each sector. */
-export interface StarChartItem extends ItemBase {
-    kind: 'starchart';
-    heading: string;
-    hub: {
-        name: string;
-        note?: string;
-    };
-    sectors: {
-        name: string;
-        /** What opens the sector (e.g. "Ruby + Amber"). */
-        gate?: string;
-        color?: string;
-        worlds: {
-            name: string;
-            kind?: string;
-            holds?: string;
-        }[];
-    }[];
-    /** Extra notes in the margin. */
-    notes?: string[];
-    /** A map window printed as an inset ("as seen from the pod"). */
-    inset?: MapPanel;
-}
-/**
- * A recipe card: a ruled index card in a cook's hand, its lines numbered (a footnote mark
- * where a line has a note), the notes on the back, an optional rubber stamp across the front.
- * `blank` lines print as a numbered rule with nothing on it.
- */
-export interface RecipeItem extends ItemBase {
-    kind: 'recipe';
-    heading: string;
-    serves?: string;
-    lines: {
-        n: number;
-        name: string;
-        line: string;
-        note?: string;
-    }[];
-    blank?: number[];
-    stamp?: string;
-    /** A last line on the back, under the notes. */
-    back?: string;
-}
-export type PrintableItem = MapItem | HintBookItem | LetterItem | NewspaperItem | JournalItem | IdCardItem | ChartItem | StarChartItem | RecipeItem;
-/** A sticker on the sticker sheet. */
-export interface StickerSpec {
-    text: string;
-    /** Small text under the main text. */
-    sub?: string;
-    /**
-     * circle, rect, star (a seal), badge, heart, burst (a comic-book bang), bubble (a speech
-     * balloon), or cut: cut out round the picture's own outline, its words on a plate under it.
-     */
-    shape?: 'circle' | 'rect' | 'star' | 'badge' | 'heart' | 'burst' | 'bubble' | 'cut';
-    color?: string;
-    ink?: string;
-    /** A picture from a map (a few blocks). */
-    shot?: MapPanel;
-    /** A monster or thing drawn from the game's own block file. */
-    sprite?: SpriteArt;
-    /** A character from his .CHR file, standing (drawn instead of `sprite`). */
-    hero?: Portrait;
-    /** A die-cut's size: each pixel of its picture prints this many 1/150 inch (default: about 1.3" tall). */
-    px?: number;
-    /** Leave it out of the little cut-outs that fill the sheet's gaps. */
-    noMini?: boolean;
-}
-/** Blocks from a .mbl, .cbl or .bbl file laid out in a grid: rows of block numbers (-1 = empty). */
-export interface SpriteArt {
-    blocks: string;
-    pal: string;
-    grid: number[][];
-    /**
-     * The plain ground block a background thing is drawn on (or a grid of them, like `grid`): its
-     * pixels round the thing are cut away. "edge" cuts away the colors along the picture's edge instead
-     * (for a thing on speckled ground).
-     */
-    under?: number | number[][] | 'edge';
-    /** Facing the other way. */
-    flip?: boolean;
-}
-/** A story for The Sandbox Scoop newsletter. */
-interface NewsStory {
-    head: string;
-    html: string;
-    /** Also run it in the other games' newsletters (it doesn't talk about this box). */
-    everywhere?: boolean;
-}
-/**
- * How the player's World Map groups scenes into places. Each group's first scene is the place;
- * the rest are folded into it (no picture of their own) and listed on its land. A scene is a
- * number, a range ("9-18"), or a name only one scene has. Scenes shown under an all-black
- * palette fold into their place without being named here (worldMapGroups.ts).
- */
-export interface WorldMapHints {
-    groups?: {
-        scenes: (number | string)[];
-        /** The place's name on the map (default: its scene's). */
-        name?: string;
-        /** What its land lists (default: the folded scenes' numbers and names). */
-        labels?: string[];
-    }[];
-}
-/** games/<id>/printables.json */
-export interface PrintablesFile {
-    /** Generated extras this game does without. */
-    skip?: GeneratedKind[];
-    /** The game's own extras, in tray order (after the manual). */
-    items?: PrintableItem[];
-    /** Key card wording, by key as Game-Maker names it ("Space", "Z", "Up", "F2"). */
-    keys?: Record<string, string>;
-    /** Stickers added to the sticker sheet. */
-    stickers?: StickerSpec[];
-    /** Stories this game adds to The Sandbox Scoop. */
-    news?: NewsStory[];
-    /** A one-line pitch for the publisher catalog (defaults to the blurb). */
-    pitch?: string;
-    /** The World Map's places (see WorldMapHints). */
-    worldMap?: WorldMapHints;
-}
-export {};

package/dist/types/web/src/project/bizarre.d.ts

@@ -1,28 +0,0 @@
-/** The artist and publisher on the Bard's games. */
-export declare const BARD = "The Bard of Bizarre";
-/** How many of the Bard's games it takes for them to get a collection of their own. */
-export declare const BIZARRE_MIN = 4;
-interface Listed {
-    original?: unknown;
-    series?: string;
-    company?: string;
-}
-/** One of the Bard's games: marked "series": "bizarre", or (a catalog built before the field) published under his name. */
-export declare const isBizarreGame: (g: Listed) => boolean;
-/** Whether the Bard's games have a collection of their own in this catalog. */
-export declare const hasBizarreTab: (catalog: readonly Listed[]) => boolean;
-/** The Bard's collections in order (the flyer's and the home tab's), each game with its one-line pitch for the flyer. */
-export declare const COLLECTIONS: {
-    name: string;
-    tag: string;
-    games: Record<string, string>;
-}[];
-/** The Bard's games sorted into his collections (in the collection's order); games not filed yet last, under `More song-games`. */
-export declare function byCollection<G extends {
-    id: string;
-}>(games: readonly G[]): {
-    name: string;
-    tag?: string;
-    games: G[];
-}[];
-export {};