js-game-zero 0.0.0-stage → 0.4.0

package/dist/input.d.ts

@@ -0,0 +1,200 @@
+export declare const keys: Readonly<{
+    ENTER: 13;
+    BACKSPACE: 8;
+    TAB: 9;
+    CLEAR: 12;
+    RETURN: 13;
+    PAUSE: 19;
+    ESCAPE: 27;
+    SPACE: 32;
+    EXCLAIM: 33;
+    QUOTEDBL: 34;
+    HASH: 35;
+    DOLLAR: 36;
+    AMPERSAND: 38;
+    QUOTE: 39;
+    LEFTPAREN: 40;
+    RIGHTPAREN: 41;
+    ASTERISK: 42;
+    PLUS: 43;
+    COMMA: 44;
+    MINUS: 45;
+    PERIOD: 46;
+    SLASH: 47;
+    K_0: 48;
+    K_1: 49;
+    K_2: 50;
+    K_3: 51;
+    K_4: 52;
+    K_5: 53;
+    K_6: 54;
+    K_7: 55;
+    K_8: 56;
+    K_9: 57;
+    COLON: 58;
+    SEMICOLON: 59;
+    LESS: 60;
+    EQUALS: 61;
+    GREATER: 62;
+    QUESTION: 63;
+    AT: 64;
+    LEFTBRACKET: 91;
+    BACKSLASH: 92;
+    RIGHTBRACKET: 93;
+    CARET: 94;
+    UNDERSCORE: 95;
+    BACKQUOTE: 96;
+    A: 97;
+    B: 98;
+    C: 99;
+    D: 100;
+    E: 101;
+    F: 102;
+    G: 103;
+    H: 104;
+    I: 105;
+    J: 106;
+    K: 107;
+    L: 108;
+    M: 109;
+    N: 110;
+    O: 111;
+    P: 112;
+    Q: 113;
+    R: 114;
+    S: 115;
+    T: 116;
+    U: 117;
+    V: 118;
+    W: 119;
+    X: 120;
+    Y: 121;
+    Z: 122;
+    DELETE: 127;
+    KP0: 1073741922;
+    KP1: 1073741913;
+    KP2: 1073741914;
+    KP3: 1073741915;
+    KP4: 1073741916;
+    KP5: 1073741917;
+    KP6: 1073741918;
+    KP7: 1073741919;
+    KP8: 1073741920;
+    KP9: 1073741921;
+    KP_PERIOD: 1073741923;
+    KP_DIVIDE: 1073741908;
+    KP_MULTIPLY: 1073741909;
+    KP_MINUS: 1073741910;
+    KP_PLUS: 1073741911;
+    KP_ENTER: 1073741912;
+    KP_EQUALS: 1073741927;
+    UP: 1073741906;
+    DOWN: 1073741905;
+    RIGHT: 1073741903;
+    LEFT: 1073741904;
+    INSERT: 1073741897;
+    HOME: 1073741898;
+    END: 1073741901;
+    PAGEUP: 1073741899;
+    PAGEDOWN: 1073741902;
+    F1: 1073741882;
+    F2: 1073741883;
+    F3: 1073741884;
+    F4: 1073741885;
+    F5: 1073741886;
+    F6: 1073741887;
+    F7: 1073741888;
+    F8: 1073741889;
+    F9: 1073741890;
+    F10: 1073741891;
+    F11: 1073741892;
+    F12: 1073741893;
+    F13: 1073741928;
+    F14: 1073741929;
+    F15: 1073741930;
+    NUMLOCK: 1073741907;
+    CAPSLOCK: 1073741881;
+    SCROLLOCK: 1073741895;
+    RSHIFT: 1073742053;
+    LSHIFT: 1073742049;
+    RCTRL: 1073742052;
+    LCTRL: 1073742048;
+    RALT: 1073742054;
+    LALT: 1073742050;
+    RMETA: 1073742055;
+    LMETA: 1073742051;
+    LSUPER: 1073742051;
+    RSUPER: 1073742055;
+    MODE: 1073742081;
+    HELP: 1073741941;
+    PRINT: 1073741894;
+    SYSREQ: 1073741978;
+    BREAK: 1073741896;
+    MENU: 1073741942;
+    POWER: 1073741926;
+    EURO: 1073742004;
+    LAST: 1073742106;
+}>;
+export declare const keymods: Readonly<{
+    NONE: 0;
+    LSHIFT: 1;
+    RSHIFT: 2;
+    SHIFT: 3;
+    LCTRL: 64;
+    RCTRL: 128;
+    CTRL: 192;
+    LALT: 256;
+    RALT: 512;
+    ALT: 768;
+    LMETA: 1024;
+    RMETA: 2048;
+    META: 3072;
+    NUM: 4096;
+    CAPS: 8192;
+    MODE: 16384;
+}>;
+export declare const mouse: Readonly<{
+    LEFT: 1;
+    MIDDLE: 2;
+    RIGHT: 3;
+    WHEEL_UP: 4;
+    WHEEL_DOWN: 5;
+}>;
+/** Where the mouse (or a touch) last was over the canvas, and what's held. */
+export declare class MouseState {
+    pos: readonly [number, number] | null;
+    buttons: ReadonlySet<number>;
+    clearButtons(): void;
+}
+/**
+ * The `mouse` a game sees: the button constants, plus where the mouse is now
+ * and which buttons are held, for code in `update()` that follows or aims at
+ * the mouse. Before the mouse first moves over the game, `pos` is the center
+ * of the screen. `down` is true while any button or a finger is down, for
+ * code that acts as long as the learner holds on.
+ */
+export type LiveMouse = typeof mouse & {
+    readonly pos: [number, number];
+    readonly x: number;
+    readonly y: number;
+    readonly buttons: Set<number>;
+    readonly down: boolean;
+};
+export declare function createLiveMouse(state: MouseState, center: () => readonly [number, number]): LiveMouse;
+export declare class KeyboardState {
+    [key: string]: unknown;
+    [key: number]: unknown;
+    readonly _pressed: Set<number>;
+    constructor();
+    press(key: number): void;
+    release(key: number): void;
+    clear(): void;
+    isPressed(key: number): boolean;
+    pressed(): number[];
+}
+export declare function setActiveKeyboard(nextKeyboard: KeyboardState | null): KeyboardState | null;
+export declare function getActiveKeyboard(): KeyboardState;
+export declare const keyboard: KeyboardState;
+export declare function isKeyConstant(value: unknown): value is number;
+export declare function assertKeyConstant(value: unknown): asserts value is number;
+export declare function keyAttributeName(name: string): string;

package/dist/inspection.d.ts

@@ -0,0 +1,58 @@
+import type { GameHandle } from "./runtime.js";
+import { type Screen } from "./rendering.js";
+import type { SourceInspector } from "./runtime-source.js";
+/** A value as inspection reports it: JSON, with `$type` tags for the rest. */
+export type JsonSafe = null | boolean | number | string | JsonSafe[] | {
+    readonly [key: string]: JsonSafe;
+};
+/**
+ * A game value as JSON: numbers, strings, booleans, arrays and plain objects
+ * as they are (objects with sorted keys); anything else tagged with `$type`,
+ * such as `{ $type: "Actor", x, y, … }`, `{ $type: "Undefined" }` or
+ * `{ $type: "Number", value: "NaN" }`. Deep, long or circular values are cut
+ * short with `{ $type: "Truncated" }` or `{ $type: "Circular" }`.
+ */
+export declare function serializeGameValue(value: unknown): JsonSafe;
+/** A binding and the property names and indexes under it: `fish[0].y`. */
+export type StatePath = {
+    readonly source: string;
+    readonly binding: string;
+    readonly segments: readonly (string | number)[];
+};
+/**
+ * Reads a state path: a top-level binding, then `.name` for a property and
+ * `[n]` for an index, as in `player.x` or `fish[0].y`. Throws a TypeError for
+ * anything else, and for `__proto__`, `prototype` and `constructor`.
+ */
+export declare function parseStatePath(source: string): StatePath;
+/** Host access to a zero-boilerplate game's live top-level bindings. */
+export type GameInspector = {
+    /** Non-function top-level declarations and assignments, in source order. */
+    bindings(): readonly string[];
+    /** Top-level function declarations and function-valued bindings. */
+    functions(): readonly string[];
+    /** The live value at a binding or a path (`score`, `fish[0].y`), as it is. */
+    read(path: string | StatePath): unknown;
+    /**
+     * The value at a path as JSON (`serializeGameValue`), as the CLI's `inspect`
+     * reports it; with no path, every binding's value by name.
+     */
+    inspect(path?: string | StatePath): JsonSafe;
+};
+/**
+ * The name a path starts with to read what the game's last `draw()` drew,
+ * rather than one of its bindings: `$drawn`, a list of things, each with its
+ * `kind` and what it is and where (`{ kind: "actor", image: "robot", x, y }`).
+ */
+export declare const DRAWN = "$drawn";
+/**
+ * The host inspector over a game's source bindings, and, given its screen,
+ * what it drew (`$drawn`).
+ */
+export declare function createGameInspector(source: SourceInspector, screen?: Screen): GameInspector;
+/**
+ * A live inspector for a running zero-boilerplate game, or null for an
+ * import-mode game and a stopped one (a failed game keeps its inspector, so a
+ * host can read the state at the crash).
+ */
+export declare function getGameInspector(handle: GameHandle): GameInspector | null;