@lewismoten/gamemaker-sandbox-tools 0.0.0-stage → 3.4.0

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

@@ -0,0 +1,169 @@
+import type { ExtrudedText } from './sdftext.js';
+export type V = [number, number, number];
+export declare const add: (a: V, b: V) => V;
+export declare const sub: (a: V, b: V) => V;
+export declare const scale: (a: V, k: number) => V;
+export declare const dot: (a: V, b: V) => number;
+export declare const cross: (a: V, b: V) => V;
+export declare const mix: (a: V, b: V, t: number) => V;
+export declare const clamp01: (v: number) => number;
+export declare function norm(v: V): V;
+/** A 3x3 rotation as rows (object to world). */
+type M3 = number[];
+export declare function rotX(a: number): M3;
+export declare function rotY(a: number): M3;
+/** a then b: the rotation that applies `b` first, then `a`. */
+export declare function mulM(a: M3, b: M3): M3;
+/** The rotation whose columns are these axes (object x, y, z in world space). */
+export declare const fromAxes: (x: V, y: V, z: V) => M3;
+export declare const apply: (m: M3, v: V) => V;
+/** Where a shape sits: object point p is at rot * (p * size) + pos in the world. */
+interface Place {
+    rot: M3;
+    pos: V;
+    size: number;
+}
+export declare const placed: (pos?: V, rot?: M3, size?: number) => Place;
+/** What a ray found, in object space (`p`, `n`) and the world (`n` is world). */
+interface LocalHit {
+    t: number;
+    /** Object-space normal. */
+    n: V;
+}
+export interface Hit {
+    t: number;
+    p: V;
+    /** The point in the shape's own coordinates (for textures). */
+    local: V;
+    /** World-space unit normal, facing the ray. */
+    n: V;
+    shape: Shape;
+}
+/** Surface look: the shader gets the hit and returns a base color and how shiny it is. */
+export interface Surface {
+    color: V;
+    /** Diffuse share of the light. */
+    kd: number;
+    /** Specular highlight strength and sharpness (Phong). */
+    ks: number;
+    shine: number;
+    /** How much of the sky the surface mirrors (0 = none). */
+    mirror: number;
+    /** Extra light the surface gives off (a highlight sweep). */
+    glow?: V;
+}
+export type Material = (h: Hit) => Surface;
+export declare abstract class Shape {
+    at: Place;
+    material: Material;
+    /** World-space bounding box, [min, max]. */
+    box: [V, V];
+    /** Whether the shape throws a shadow. */
+    shadows: boolean;
+    constructor(at: Place, material: Material);
+    /** The nearest hit of an object-space ray after EPS, or undefined. */
+    protected abstract local(o: V, d: V, tmax: number): LocalHit | undefined;
+    /** The shape's own bounding box in object space. */
+    protected abstract bounds(): [V, V];
+    /** Recomputes the world box after `at` changes. */
+    update(): this;
+    toWorld(p: V): V;
+    /** The world box's eight corners. */
+    corners(): V[];
+    hit(o: V, d: V, tmax: number): Hit | undefined;
+}
+export declare class Box extends Shape {
+    readonly mn: V;
+    readonly mx: V;
+    constructor(mn: V, mx: V, at: Place, material: Material);
+    protected bounds(): [V, V];
+    protected local(o: V, d: V, tmax: number): LocalHit | undefined;
+}
+/** A cone frustum (or cylinder when r0 = r1) around the object y axis, y0 to y1, its ends capped or open. */
+export declare class Cone extends Shape {
+    readonly r0: number;
+    readonly r1: number;
+    readonly y0: number;
+    readonly y1: number;
+    readonly caps: {
+        bottom?: boolean;
+        top?: boolean;
+    };
+    constructor(r0: number, r1: number, y0: number, y1: number, at: Place, material: Material, caps?: {
+        bottom?: boolean;
+        top?: boolean;
+    });
+    protected bounds(): [V, V];
+    protected local(o: V, d: V, tmax: number): LocalHit | undefined;
+}
+/** A flat ring (or disc when inner = 0) in the object's y = 0 plane. */
+export declare class Ring extends Shape {
+    readonly inner: number;
+    readonly outer: number;
+    constructor(inner: number, outer: number, at: Place, material: Material);
+    protected bounds(): [V, V];
+    protected local(o: V, d: V, tmax: number): LocalHit | undefined;
+}
+export declare class Sphere extends Shape {
+    readonly r: number;
+    constructor(r: number, at: Place, material: Material);
+    protected bounds(): [V, V];
+    protected local(o: V, d: V, tmax: number): LocalHit | undefined;
+}
+/** A rod with round ends from a to b. */
+export declare class Capsule extends Shape {
+    readonly a: V;
+    readonly b: V;
+    readonly r: number;
+    constructor(a: V, b: V, r: number, at: Place, material: Material);
+    protected bounds(): [V, V];
+    protected local(o: V, d: V, tmax: number): LocalHit | undefined;
+}
+/** A flat triangle, seen from both sides. */
+export declare class Tri extends Shape {
+    readonly a: V;
+    readonly b: V;
+    readonly c: V;
+    constructor(a: V, b: V, c: V, at: Place, material: Material);
+    protected bounds(): [V, V];
+    protected local(o: V, d: V, tmax: number): LocalHit | undefined;
+}
+/** Beveled 3D lettering (sdftext.ts), found by sphere tracing. */
+export declare class Lettering extends Shape {
+    readonly text: ExtrudedText;
+    constructor(text: ExtrudedText, at: Place, material: Material);
+    protected bounds(): [V, V];
+    protected local(o: V, d: V, tmax: number): LocalHit | undefined;
+}
+/** Shapes kept together behind one bounding box, so a ray that misses the box skips them all. */
+export declare class Group extends Shape {
+    readonly parts: Shape[];
+    constructor(parts: Shape[]);
+    protected bounds(): [V, V];
+    protected local(): LocalHit | undefined;
+    update(): this;
+    hit(o: V, d: V, tmax: number): Hit | undefined;
+}
+/** The nearest hit among shapes, or undefined. */
+export declare function nearest(shapes: Shape[], o: V, d: V, tmax?: number): Hit | undefined;
+/** Is anything between a point and the light along direction l? */
+export declare function blocked(shapes: Shape[], o: V, l: V, tmax?: number): boolean;
+/** A pinhole camera for a 320x200 screen shown 4:3 (tall pixels). */
+export declare class Camera {
+    readonly eye: V;
+    readonly focal: number;
+    readonly w: number;
+    readonly h: number;
+    readonly aspect: number;
+    readonly fw: V;
+    readonly right: V;
+    readonly up: V;
+    constructor(eye: V, target: V, focal: number, w?: number, h?: number, aspect?: number);
+    ray(sx: number, sy: number): V;
+    project(p: V): [number, number] | undefined;
+}
+export declare function noise(x: number, y: number, z: number): number;
+export declare function fbm(x: number, y: number, z: number, octaves?: number): number;
+/** A grainy hash in 0..1 for a point (sand). */
+export declare const grain: (x: number, y: number, z: number, k: number) => number;
+export {};

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

@@ -0,0 +1 @@
+export declare function recordedDemo(pairs: readonly number[], waitTicks?: number, releaseTicks?: number): Uint8Array;

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

@@ -0,0 +1,34 @@
+import { Pixels } from './pixels.js';
+/** The palette (6-bit VGA) faded toward black: light 0 is black, 1 is unchanged. */
+export declare function dimmed(pal: Uint8Array, light: number): Uint8Array;
+export declare class Reel {
+    /** The reel's palette (6-bit VGA, 768 bytes). */
+    readonly pal: Uint8Array;
+    readonly w: number;
+    readonly h: number;
+    readonly frames: Uint8Array[];
+    readonly palettes: Uint8Array[];
+    private last?;
+    constructor(
+    /** The reel's palette (6-bit VGA, 768 bytes). */
+    pal: Uint8Array, w?: number, h?: number);
+    /** Adds a picture for `hold` frames, its palette faded to `light`. */
+    add(p: Pixels, hold?: number, light?: number, pal?: Uint8Array<ArrayBufferLike>): this;
+    /** A picture drawn over a copy of `bg` (the actors over the scenery), for `hold` frames. */
+    frame(bg: Pixels, draw: (p: Pixels) => void, hold?: number, light?: number, pal?: Uint8Array<ArrayBufferLike>): this;
+    /** The picture fading in from black over `n` frames (the last at full light). */
+    fadeIn(p: Pixels, n: number, pal?: Uint8Array<ArrayBufferLike>): this;
+    /** The last picture fading out to black over `n` frames. */
+    fadeOut(n: number): this;
+    /**
+     * A cartoon's closing iris: black closes in on (cx, cy) over `n` frames from the last picture
+     * down to a circle `end` pixels across (round on a 4:3 screen: VGA's pixels are taller than
+     * wide), and holds there `hold` frames. Follow it with fadeOut. Gives an intro whose pictures
+     * are the title's art a last view that isn't the title.
+     */
+    irisOut(cx: number, cy: number, n: number, end?: number, hold?: number): this;
+    /** The .FLI: `speed` is the wait after each frame in 1/70 s (5 = 14 frames a second). */
+    fli(speed: number): Uint8Array;
+    /** How long it plays, in seconds. */
+    seconds(speed: number): number;
+}

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

@@ -0,0 +1,71 @@
+import { Pixels } from './pixels.js';
+/** The road in perspective: half its width on each screen row, and where its lanes and lines run. */
+export interface RoadView {
+    /** The lane's half width at screen row y (its rails sit at vx +- this). */
+    halfWidth: (y: number) => number;
+    /** Where lane k (-1 left, 0 middle, 1 right) runs at screen row y: two thirds of the way out for the side lanes. */
+    laneX: (k: number, y: number) => number;
+    /** Where the lines between the lanes run (side -1 or 1). */
+    dividerX: (side: number, y: number) => number;
+}
+/** A three-lane road from the vanishing point (vx, horizon), its half width growing `spread` pixels a row. */
+export declare function roadView(horizon: number, vx: number, spread: number): RoadView;
+/** One entry of a timetable: [tick after the scene starts, lane, what comes]. */
+export type RoadEntry<K> = readonly [tick: number, lane: number, kind: K];
+/** A spawner block of a lane's chain: on the map from the last entry's tick until just after its own. */
+export interface SpawnBlock<K> {
+    name: string;
+    kind: K;
+    /** Its birth time: the entry's tick (its first birth is its only one on the map). */
+    birthTime: number;
+    /** The next block of the chain, and when it takes over. */
+    next: string;
+    ntime: number;
+}
+/** A lane's chain of spawner blocks, its first block (the one on the map) and the blank it ends on. */
+export interface SpawnChain<K> {
+    lane: number;
+    first: string;
+    blocks: SpawnBlock<K>[];
+    end: string;
+}
+/**
+ * The spawner chains for a timetable, one per lane: a block per entry, each giving birth once.
+ * Every block's clock starts with the scene, so a block whose birth time is its entry's tick, on
+ * the map only around that tick, gives birth exactly then. Blocks are named `${prefix}${lane}_${i}`
+ * and `${prefix}${lane}_end`.
+ */
+export declare function spawnChains<K>(waves: readonly RoadEntry<K>[], lanes: readonly number[], prefix?: string): SpawnChain<K>[];
+/** A path step: [blocks across, blocks down, pixels a tick]. */
+export type RoadStep = [dx: number, dy: number, speed: number];
+/** A Game-Maker path corner: [x, y] from the start, the speed, the orientation. */
+export type RoadCorner = [x: number, y: number, speed: number, orient: number];
+/** A path as steps from where the last one ended (Game-Maker stores corners from the start). */
+export declare function roadCorners(steps: RoadStep[], orient: number): RoadCorner[];
+/**
+ * Lane k's slide from the vanishing point: -1 left, 0 middle, 1 right, outward along its line
+ * and faster as it comes (a block in 20 ticks, the next in 10, then 4 and 5 pixels a tick).
+ */
+export declare const laneSlide: (k: number) => RoadStep[];
+/** Leap speed: more than any spawner is from the vanishing point, in pixels a tick. */
+export declare const ROAD_LEAP = 240;
+/** The first step, from a spawner's cell onto the vanishing point's in one tick. */
+export declare const leapTo: (from: [number, number], vp: [number, number]) => RoadStep;
+/** A monster's sizes in step with its slide: a dot while it crawls the first block, then nearer and nearer. */
+export declare const growPics: (name: string) => [string, number][];
+/** How big each size is, and the row of the sprite its bottom sits on (lower as it nears). */
+export declare const ROAD_SIZES: readonly [{
+    readonly scale: 0.25;
+    readonly bottom: 6;
+}, {
+    readonly scale: 0.45;
+    readonly bottom: 11;
+}, {
+    readonly scale: 0.72;
+    readonly bottom: 16;
+}, {
+    readonly scale: 1;
+    readonly bottom: 19;
+}];
+/** A full-size 20x20 picture shrunk (nearest pixel), centered, its bottom row on `bottom`; `clear` is transparent. */
+export declare function shrinkSprite(src: Pixels, scale: number, bottom: number, clear: number): Pixels;

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

@@ -0,0 +1,6 @@
+export declare function expectScene(bot: {
+    sim: {
+        scene: number;
+    };
+    log: readonly string[];
+}, scene: number, what: string): void;

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

@@ -0,0 +1,17 @@
+import type { Pixels } from './pixels.js';
+/** The dark strip under name i (0..9): the marker and the 20 letters with their margin. */
+export declare const SLOT: {
+    readonly x: 54;
+    readonly w: 196;
+    readonly h: 14;
+    readonly y: (i: number) => number;
+};
+/** The light strip under the message line. */
+export declare const STATUS: {
+    readonly x: 34;
+    readonly y: 181;
+    readonly w: 246;
+    readonly h: 15;
+};
+/** Paints the ten name strips in `fill` (an optional 1 pixel `edge` round each), and the message strip. */
+export declare function saveSlots(p: Pixels, fill: number, status: number, edge?: number): Pixels;

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

@@ -0,0 +1,11 @@
+import { type World } from '@lewismoten/gamemaker-sandbox-engine/engine/world';
+export { changeBlocks } from '@lewismoten/gamemaker-sandbox-engine/engine/scene';
+export declare function initializeScene(w: World, start: {
+    x: number;
+    y: number;
+}, spawnWhenMonstersDisabled?: boolean): void;
+/** Compatibility for simulators that kept block birth schedules even with monsters disabled. */
+export declare const legacySceneInits: (w: World, start: {
+    x: number;
+    y: number;
+}) => void;

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

@@ -0,0 +1,84 @@
+import { type CharInfo, type World } from '@lewismoten/gamemaker-sandbox-engine/engine/world';
+import { type Block } from '@lewismoten/gamemaker-sandbox-engine/formats/blocks';
+import type { Character } from '@lewismoten/gamemaker-sandbox-engine/formats/character';
+import type { GameMap } from '@lewismoten/gamemaker-sandbox-engine/formats/map';
+import type { Monster } from '@lewismoten/gamemaker-sandbox-engine/formats/monster';
+export interface SimScene {
+    map: GameMap;
+    bbl: Block[];
+    mbl?: Block[];
+    mon?: Monster[];
+    chr: Character;
+    cbl: Block[];
+    links?: {
+        from: {
+            x: number;
+            y: number;
+        };
+        to: {
+            x: number;
+            y: number;
+        };
+    }[];
+    /** Monster names by number (for bots that look for one). */
+    names?: string[];
+}
+/** What Sim.snapshot() keeps. */
+interface SimState {
+    w: Omit<World, 'sound' | 'rand' | 'joystick' | 'bg' | 'mblk' | 'cblk' | 'mon' | 'palette' | 'chr'>;
+    chr: Character;
+    randA: number;
+    held: number[];
+    pending: number[];
+    doScroll: boolean;
+    sounds: number;
+    ticks: number;
+    link: number;
+    dead: boolean;
+}
+export declare class Sim {
+    readonly scene: SimScene;
+    readonly w: World;
+    private held;
+    private doScroll;
+    sounds: number[];
+    /** Ticks played so far. */
+    ticks: number;
+    /** Called with every key event (scan, bit 7 = released), e.g. to record a demo. */
+    onKey?: (key: number) => void;
+    /** Link index reached (-1 = none yet). */
+    link: number;
+    dead: boolean;
+    constructor(scene: SimScene, start: {
+        x: number;
+        y: number;
+    }, ci?: CharInfo, seed?: number, 
+    /** False for games whose scenes never scroll (one screen each): the scroll window is shut. */
+    scroll?: boolean);
+    /** kit/pixels.ts rng() (mulberry32), with its state out where a snapshot can keep it. */
+    private randA;
+    private rand;
+    /** Everything that changes as the scene plays, to try a move and take it back with restore(). */
+    snapshot(): SimState;
+    restore(s: SimState): void;
+    press(scan: number): void;
+    release(scan: number): void;
+    private pending;
+    private event;
+    /** One 18.2 Hz game tick (8 scroll steps + tick()). */
+    tick(): Promise<void>;
+    run(ticks: number, each?: (t: number) => void | boolean): Promise<void>;
+    /** Live monsters called `name`, with their block positions. */
+    monsters(name: string): {
+        x: number;
+        y: number;
+    }[];
+    /** Character position in pixels (x of its column, y of its bottom block). */
+    get pos(): {
+        x: number;
+        y: number;
+        bx: number;
+        by: number;
+    };
+}
+export {};

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

@@ -0,0 +1,3 @@
+import { Pixels } from './pixels.js';
+export declare const page: (lines: string[], pages?: number) => string;
+export declare const sprite: (set: Map<string, Pixels>, name: string) => Pixels;

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

@@ -0,0 +1,34 @@
+/** A stroke piece: x0, y0, x1, y1 (center line) and its radius. */
+export type Seg = [number, number, number, number, number];
+/**
+ * One line of text as stroke pieces, centered on x = 0 with its baseline at `y`.
+ * `height` is the cap height; `gap` the space between letters (in cap heights).
+ */
+export declare function textStrokes(text: string, height: number, y: number, gap?: number): Seg[];
+/** Distances to the strokes' outsides on a grid (negative inside), capped at `cap`. */
+export declare class DistanceGrid {
+    readonly cell: number;
+    readonly cap: number;
+    readonly x0: number;
+    readonly y0: number;
+    readonly x1: number;
+    readonly y1: number;
+    readonly nx: number;
+    readonly ny: number;
+    readonly d: Float32Array;
+    constructor(segs: Seg[], cell?: number, cap?: number);
+    /** The distance at (x, y), bilinear between cells; outside the grid, a safe lower bound. */
+    at(x: number, y: number): number;
+}
+/** The letters as a solid: the 2D outline pushed `depth` deep (z from -depth/2 to depth/2), its edges rounded by `bevel`. */
+export declare class ExtrudedText {
+    readonly grid: DistanceGrid;
+    readonly bevel: number;
+    readonly half: number;
+    constructor(grid: DistanceGrid, depth: number, bevel: number);
+    sdf(x: number, y: number, z: number): number;
+    /** Where a ray (object space, unit direction) first meets the letters, or -1. */
+    trace(ox: number, oy: number, oz: number, dx: number, dy: number, dz: number): number;
+    /** The surface normal at a point (object space), from the field's gradient. */
+    normal(x: number, y: number, z: number): [number, number, number];
+}

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

@@ -0,0 +1,23 @@
+import { Pixels } from './pixels.js';
+/** A shade between ramp[lo] and ramp[hi] for level 0..1, ordered-dithered at (x, y). */
+export declare function shadeAt(ramp: number[], lo: number, hi: number, level: number, x: number, y: number): number;
+/**
+ * A vertical gradient across a rectangle. With `rows`, the blend between two ramp steps is
+ * dithered by whole rows (each row one color) instead of the 4x4 pattern: it reads as fine
+ * horizontal lines, and a GIF of it is far smaller, because a row of one color packs into a
+ * few LZW codes while a dither pattern costs codes all along the row.
+ */
+export declare function gradient(p: Pixels, x0: number, y0: number, w: number, h: number, ramp: number[], lo: number, hi: number, rows?: boolean): Pixels;
+/** A lit ellipsoid lump, light from the upper left. */
+export declare function blob(p: Pixels, cx: number, cy: number, rx: number, ry: number, ramp: number[], lo?: number, hi?: number, light?: number): Pixels;
+/** A raised box: light top/left edge, dark bottom/right edge. */
+export declare function bevel(p: Pixels, x: number, y: number, w: number, h: number, ramp: number[], face: number, depth?: number, edges?: readonly [number, number, number, number]): Pixels;
+/** Fills a rectangle with a speckled texture from ramp[lo..hi]. */
+export declare function speckle(p: Pixels, x0: number, y0: number, w: number, h: number, ramp: number[], base: number, spread: number, seed: number, density?: number): Pixels;
+/**
+ * Steps every pixel that belongs to one of `ramps` by `steps` along its own ramp (negative darkens, positive
+ * lightens), where `level(x, y)` (0..1) is ordered-dithered in: a cast shadow, or a painted pool of light, that
+ * keeps the colors of whatever it falls on. Pixels in no ramp are left alone.
+ */
+export declare function rampShift(p: Pixels, ramps: number[][], steps: number, level: (x: number, y: number) => number): Pixels;
+export declare function pool(p: Pixels, cx: number, cy: number, rx: number, ry: number, r: number[], lo: number, hi: number): Pixels;

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

@@ -0,0 +1,20 @@
+import { type Block } from '@lewismoten/gamemaker-sandbox-engine/formats/blocks';
+import type { GameMap } from '@lewismoten/gamemaker-sandbox-engine/formats/map';
+export interface SceneBlocks {
+    blocks: Block[];
+    map: GameMap;
+}
+export interface SharedBlocks {
+    /** The shared set, BACKBL blocks (empty ones after the used). */
+    blocks: Block[];
+    /** Per scene, local block number to the shared one (-1: unused). */
+    numbers: number[][];
+    /** Per scene, its map with the shared numbers. */
+    maps: GameMap[];
+}
+/**
+ * One set for `scenes`. Scene 0's block 0 stays block 0; a block at a number listed in `pin`
+ * (such as a felt egg the desk knows by number) keeps that number. Throws when the used blocks
+ * don't fit BACKBL or two different blocks want one pinned number.
+ */
+export declare function shareBlocks(scenes: SceneBlocks[], pin?: number[]): SharedBlocks;

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

@@ -0,0 +1,89 @@
+import { type CmfEvent } from '@lewismoten/gamemaker-sandbox-engine/formats/cmf';
+/** A reedy, slightly bleating lead with vibrato (the singer). */
+export declare const VOICE: Uint8Array<ArrayBufferLike>;
+/** Oboe-ish double reed. */
+export declare const REED: Uint8Array<ArrayBufferLike>;
+/** Gospel drawbar organ for the comping. */
+export declare const ORGAN: Uint8Array<ArrayBufferLike>;
+/** A soft flute. */
+export declare const FLUTE: Uint8Array<ArrayBufferLike>;
+/** A plucked "oud". */
+export declare const OUD: Uint8Array<ArrayBufferLike>;
+/** Celesta / music box. */
+export declare const CELESTA: Uint8Array<ArrayBufferLike>;
+/** Electric piano for comping. */
+export declare const EPIANO: Uint8Array<ArrayBufferLike>;
+/** A rounder fingered bass. */
+export declare const BASS: Uint8Array<ArrayBufferLike>;
+export interface Section {
+    /** One chord per bar, or two ("D A": half a bar each). */
+    chords: string[];
+    /** One string of notes per bar (4 beats each), "G4 q, r e, ..." as in kit/music. */
+    tune: string[];
+}
+/** Bars of one section, sliced (e.g. the chorus without its pickup). */
+export declare const slice: (s: Section, from: number, to?: number) => Section;
+/** A section with its last bar's tune replaced (to change the pickup into the next part). */
+export declare const ending: (s: Section, last: string) => Section;
+/** Bars of band alone, one per chord. */
+export declare const vamp: (chords: string[], tune?: string) => Section;
+/** How the band voices chords: three comping tones (MIDI, low to high) and the bass root. */
+interface ChordBook {
+    voicing: (chord: string) => number[];
+    root: (chord: string) => number;
+}
+/** A chord book from tables of note names and bass roots (a song's own hand-picked voicings). */
+export declare function chordTable(voicing: Record<string, string[]>, root: Record<string, number>): ChordBook;
+type Drum = 'k' | 's' | 't' | 'c' | 'h';
+/** One bar of drums: per drum an 8th-note (8 chars) or 16th-note (16 chars) grid; 'x' hits, 'X' accents, '.' rests. */
+export type Groove = Partial<Record<Drum, string>>;
+export interface Part {
+    section: Section;
+    /** Melody patch on channel 0 (and the optional double on channel 1). */
+    lead: Uint8Array;
+    leadVel?: number;
+    /** Transpose the whole part (semitones). */
+    shift?: number;
+    /** Play the tune this much higher than written (12 for the flute and celesta). */
+    up?: number;
+    /** Channel 1: 'double' the tune an octave under the lead, 'octave' an octave over it, or none. */
+    second?: 'double' | 'octave' | 'none';
+    secondPatch?: Uint8Array;
+    secondVel?: number;
+    bass: 'whole' | 'half' | 'pump' | 'walk' | 'eighths';
+    bassPatch?: Uint8Array;
+    bassVel?: number;
+    /** Comping rhythm for one bar: 'x' chord, 'r' rest, each with a length, e.g. 'r e, x e, r e, x e, ...'. */
+    comp: string;
+    compPatch: Uint8Array;
+    compVel?: number;
+    /** A groove name per bar (the last one repeats). */
+    drums: string[];
+    drumVel?: number;
+    /** Leave the tune out (bars of band only). */
+    noTune?: boolean;
+}
+export declare class Writer {
+    private chords;
+    readonly tpb: number;
+    readonly events: CmfEvent[];
+    readonly instruments: Uint8Array[];
+    bar: number;
+    private current;
+    constructor(bpm: number, chords?: ChordBook);
+    private tick;
+    /** A note from beat `at` lasting `len` beats; it lets go a little early so the next one retriggers. */
+    note(ch: number, at: number, len: number, n: number, vel: number, legato?: number): void;
+    /** Plays a note string from beat `at`; returns its length in beats. */
+    line(ch: number, at: number, s: string, vel: number, shift?: number, legato?: number): number;
+    drums(at: number, g: Groove, vel: number): void;
+    /** The bass for `beats` beats from `at` under one chord. */
+    private bassLine;
+    /** Writes a section's bars: tune, second voice, bass, three comping voices and drums. */
+    part(p: Part): this;
+    /** Puts each melodic channel's patch in place for a part: the first part's are the file's instruments 0-5; later changes add an instrument and a program change. */
+    private patches;
+    /** The .CMF: ends exactly on the bar line, so PLAYGAME's restart keeps time. */
+    cmf(): Uint8Array;
+}
+export {};