@typeonce/ritmo-browser 0.10.0 → 0.11.0

package/dist/Gamepad.d.ts

@@ -0,0 +1,375 @@
+/**
+ * Gamepad input as caller-named actions, plus the sticks and triggers.
+ *
+ * Games bind actions to buttons once and read one snapshot per update, as
+ * with `Keyboard`. The module owns the plumbing every game rewrites: polling
+ * (the Gamepad API has no button events), press/release edges, a radial dead
+ * zone on the sticks, following the pad that was used last when several are
+ * connected, and releasing everything held when a pad disconnects. It does
+ * not know about the ECS; `InputCapture.system(...)` copies snapshots from a
+ * service into a resource.
+ *
+ * Buttons are named by their place in the browser's standard mapping
+ * (`"south"` is A on Xbox, Cross on PlayStation, B on Nintendo), so bindings
+ * stay the same on every pad. A pad whose `mapping` is not `"standard"` is
+ * read by the same indices, which may not match its labels: let players
+ * remap (`rebind`). The snapshot also reports every `button` by name,
+ * whatever the bindings, for fixed menu navigation and for a settings screen
+ * that waits for the button to bind; `parseRebinding(...)` validates
+ * bindings saved as JSON.
+ *
+ * The Gamepad API has no button events, so the pads are read on every
+ * animation frame and on every `snapshot()`; a tap that starts and ends
+ * between two updates still counts. Browsers expose a pad only after
+ * a button is pressed on it, and only in a secure context (HTTPS or
+ * localhost); elsewhere, or when a permission policy blocks the API, the
+ * live actions read no pad and report `connected: false`.
+ *
+ * `actions(...)` is one player on whichever pad is used. For local
+ * multiplayer, `pads(host, bindings, max)` reads every pad on its own for
+ * `Controls.players(...).pool(...)` (`scriptedPads(...)` in tests).
+ *
+ * @module Gamepad
+ * @docGroup browser
+ *
+ * @example
+ * ```ts
+ * const pad = Gamepad.actions(window, {
+ *   move: Gamepad.vector({ stick: "left", up: ["dpadUp"], down: ["dpadDown"], left: ["dpadLeft"], right: ["dpadRight"] }),
+ *   attack: ["west"],
+ *   pause: ["start"]
+ * })
+ *
+ * // Once per update:
+ * const snapshot = pad.snapshot()
+ * move(snapshot.vectors.move) // the stick's tilt, or the d-pad's direction
+ * if (snapshot.actions.attack.pressed) attack()
+ *
+ * // In a settings screen, rebinding keeps the action names:
+ * pad.rebind({ move: Gamepad.vector({ stick: "right" }), attack: ["north"], pause: ["start"] })
+ * ```
+ *
+ * For tests, replays, and headless runs, `scripted(...)` plays a timeline of
+ * button presses, releases, and stick moves instead of polling a host, and
+ * `recording(...)` wraps live actions to capture the timeline a session
+ * produced. `parseTimeline(...)` validates a timeline loaded from JSON.
+ */
+import type * as System from "@typeonce/ritmo/System";
+import * as Result from "@typeonce/ritmo/Result";
+import type * as BrowserTickSource from "./BrowserTickSource.ts";
+import type { ActionState } from "./Keyboard.ts";
+import * as ButtonsInternal from "./internal/buttons.ts";
+/**
+ * The buttons of the browser's standard mapping, in index order: face
+ * buttons by compass position, bumpers and triggers, the two small center
+ * buttons, the stick clicks, the d-pad, and the home button.
+ */
+export declare const buttonNames: readonly ["south", "east", "west", "north", "leftBumper", "rightBumper", "leftTrigger", "rightTrigger", "select", "start", "leftStick", "rightStick", "dpadUp", "dpadDown", "dpadLeft", "dpadRight", "home"];
+/** One button of the standard mapping, see {@link buttonNames}. */
+export type Button = (typeof buttonNames)[number];
+/** The buttons of one action: at least one. */
+export type Buttons = readonly [Button, ...Array<Button>];
+/** The two sticks a vector action can read. */
+export type StickName = "left" | "right";
+/**
+ * A vector action (movement) on the pad, built with {@link vector}: a
+ * stick, buttons for the four directions (the d-pad), or both.
+ */
+export interface VectorBinding {
+    readonly _tag: "Vector";
+    readonly stick?: StickName;
+    readonly up?: Buttons;
+    readonly down?: Buttons;
+    readonly left?: Buttons;
+    readonly right?: Buttons;
+}
+/**
+ * Action name to the buttons that trigger it (at least one), or to a
+ * {@link vector} binding for a direction such as movement.
+ */
+export type Bindings = Readonly<Record<string, Buttons | VectorBinding>>;
+/** The bound button actions: the names bound to buttons. */
+export type ButtonNames<B> = {
+    [K in keyof B]: B[K] extends VectorBinding ? never : K;
+}[keyof B] & string;
+/** The bound vector actions: the names bound with {@link vector}. */
+export type VectorNames<B> = {
+    [K in keyof B]: B[K] extends VectorBinding ? K : never;
+}[keyof B] & string;
+/**
+ * Binds a vector action to a stick, to buttons for its four directions, or
+ * to both. The snapshot's `vectors` reports the longer of the two: the
+ * stick keeps its tilt (after the dead zone), and the buttons give length 1
+ * (a diagonal is not faster).
+ *
+ * @example
+ * ```ts
+ * const bindings = {
+ *   move: Gamepad.vector({ stick: "left", up: ["dpadUp"], down: ["dpadDown"], left: ["dpadLeft"], right: ["dpadRight"] }),
+ *   jump: ["south"]
+ * } as const
+ * ```
+ */
+export declare const vector: (binding: {
+    readonly stick: StickName;
+} | {
+    readonly stick?: StickName;
+    readonly up: Buttons;
+    readonly down: Buttons;
+    readonly left: Buttons;
+    readonly right: Buttons;
+}) => VectorBinding;
+/**
+ * New buttons for the same actions, for {@link Actions.rebind}: buttons for
+ * a button action, a {@link vector} for a vector action. Load saved ones
+ * with {@link parseRebinding}.
+ */
+export type Rebinding<B extends Bindings> = {
+    readonly [Action in keyof B]: B[Action] extends VectorBinding ? VectorBinding : Buttons;
+};
+/** One button's reading, the subset of the browser's `GamepadButton` the module reads. */
+export interface ButtonReading {
+    readonly pressed: boolean;
+    readonly value: number;
+}
+/** One pad's reading, the subset of the browser's `Gamepad` the module reads. */
+export interface PadReading {
+    readonly id: string;
+    readonly index: number;
+    readonly connected: boolean;
+    readonly mapping: string;
+    readonly buttons: ReadonlyArray<ButtonReading>;
+    readonly axes: ReadonlyArray<number>;
+}
+/** Where pads are read from, the subset of the browser's `navigator` the module reads. */
+export interface GamepadNavigator {
+    getGamepads(): ReadonlyArray<PadReading | null>;
+}
+/**
+ * What live actions need from the window: the pads, and animation frames to
+ * read them on, since the Gamepad API has no button events.
+ */
+export interface GamepadHost extends BrowserTickSource.Host {
+    readonly navigator: GamepadNavigator;
+}
+/**
+ * A direction and strength, length at most 1, `y` growing down as on
+ * screen: a stick's tilt (dead zone removed, zero at rest, 1 at full tilt)
+ * or a vector action's direction.
+ */
+export interface Vector {
+    readonly x: number;
+    readonly y: number;
+}
+/**
+ * The followed pad's state, with the same core as the other devices'
+ * snapshots (`actions`, `vectors`, and `used`) so `Controls` can merge it.
+ * With no pad everything is idle and `connected` is `false`.
+ */
+export interface Snapshot<B extends Bindings> {
+    /** Every bound button action's state. */
+    readonly actions: {
+        readonly [Action in ButtonNames<B>]: ActionState;
+    };
+    /** Each vector action's direction, length at most 1, `y` growing down. */
+    readonly vectors: {
+        readonly [Action in VectorNames<B>]: Vector;
+    };
+    /** Every button's state by name, whatever the bindings. */
+    readonly buttons: {
+        readonly [Name in Button]: ActionState;
+    };
+    /** The left stick's tilt, whatever the bindings. */
+    readonly left: Vector;
+    /** The right stick's tilt, whatever the bindings. */
+    readonly right: Vector;
+    /** How far the left trigger is pulled, 0 to 1. */
+    readonly leftTrigger: number;
+    /** How far the right trigger is pulled, 0 to 1. */
+    readonly rightTrigger: number;
+    /**
+     * Some button was pressed in this window or is held, or a stick is past
+     * the dead zone: the player is using the pad.
+     */
+    readonly used: boolean;
+    /** Whether a pad is being followed. */
+    readonly connected: boolean;
+    /** The followed pad's `id` (it names the maker, for button labels), or `null`. */
+    readonly id: string | null;
+}
+/**
+ * Rejects actions a rebinding names that the bindings do not have, so
+ * {@link Actions.rebind} takes exactly the actions it was made with.
+ */
+export type OnlyActionsOf<R, B extends Bindings> = {
+    readonly [Name in Exclude<keyof R, keyof B>]: `${Name & string} is not an action of these bindings`;
+};
+/**
+ * A pad bound to actions, built with {@link actions} (live), {@link scripted},
+ * or {@link recording}. Capture it with `InputCapture.system(...)`, or merge
+ * it with `Controls`.
+ */
+export interface Actions<B extends Bindings> extends System.Consumes<"snapshot"> {
+    /** Returns the input state and starts a new press/release window. */
+    snapshot(): Snapshot<B>;
+    /**
+     * Binds the same actions to new buttons, from the next snapshot, for a
+     * settings screen where players remap controls (capture the button to bind
+     * from the snapshot's `buttons`). An action held only through buttons it
+     * lost reports `released`. A button held across the rebind holds a newly
+     * bound action only once it is pressed again, so an action never turns
+     * held without a press. It takes exactly the actions the source was made
+     * with.
+     */
+    rebind<const R extends Rebinding<B>>(bindings: R & OnlyActionsOf<R, B>): void;
+    /** Stops reading pads and cancels the animation frame. */
+    dispose(): void;
+}
+/** Options for {@link actions} and {@link pads}. */
+export interface ActionsOptions {
+    /** Fraction of a stick's tilt that reads as zero. Defaults to 0.15. */
+    readonly deadZone?: number;
+    /** How far a trigger is pulled before it counts as held. Defaults to 0.5. */
+    readonly triggerThreshold?: number;
+}
+/**
+ * A snapshot with nothing held and no pad, for initializing an input
+ * resource before the first capture.
+ */
+export declare const idle: <const B extends Bindings>(bindings: B) => Snapshot<B>;
+/**
+ * Starts reading pads from `host`, usually `window`, on every animation
+ * frame until `dispose()`. With several pads connected it follows the one
+ * used last; switching pads, or the followed pad disconnecting, releases
+ * everything it held. Use {@link pads} to give each pad its own player.
+ */
+export declare const actions: <const B extends Bindings>(host: GamepadHost, bindings: B, options?: ActionsOptions) => Actions<B>;
+/**
+ * Every pad connected to the browser, each one on its own: what
+ * `Controls.players(...).pool(...)` hands to the player who joins with it.
+ * Use {@link actions} for one player, which follows whichever pad is used.
+ */
+export interface Pads<B extends Bindings> extends System.Consumes<"snapshot"> {
+    readonly _tag: "Pads";
+    /** The most pads read at once: their places in the list run from 0 to `max - 1`. */
+    readonly max: number;
+    /**
+     * One snapshot per pad seen so far, in the order they appeared, and
+     * starts a new press/release window on each. An unplugged pad stays in
+     * the list with `connected: false` and its last `id`, so a player keeps
+     * it until it comes back.
+     */
+    snapshot(): ReadonlyArray<Snapshot<B>>;
+    /** Binds the same actions to new buttons on every pad, as {@link Actions.rebind}. */
+    rebind<const R extends Rebinding<B>>(bindings: R & OnlyActionsOf<R, B>): void;
+    /** Stops reading pads and cancels the animation frame. */
+    dispose(): void;
+}
+/**
+ * Starts reading every pad on `host`, usually `window`, up to `max` of
+ * them, each with its own presses and sticks; pads beyond `max` are
+ * ignored. A pad keeps its place in the list while unplugged; one that comes
+ * back at the same browser index continues it, and a different pad at that
+ * index takes the place over with nothing held.
+ */
+export declare const pads: <const B extends Bindings>(host: GamepadHost, bindings: B, max: number, options?: ActionsOptions) => Pads<B>;
+/**
+ * Pads driven by timelines instead of a host, one timeline per pad (as
+ * {@link scripted}), each with the id `scripted <n>` (from `scripted 1`)
+ * and `max` the number of timelines: for tests of games where every player
+ * has a pad.
+ */
+export declare const scriptedPads: <const B extends Bindings>(bindings: B, timelines: ReadonlyArray<Timeline>) => Pads<B>;
+/**
+ * Input changes applied just before one snapshot: the buttons, then the
+ * sticks and triggers, which keep their value until set again, then
+ * `connected`. `frame` is the snapshot's index, counting from 0 at the first
+ * `snapshot()` call. A button in both `press` and `release` changed twice
+ * within the frame: a tap shorter than a frame when it was up, a release and
+ * a new press when it was held.
+ */
+export interface TimelineEntry {
+    readonly frame: number;
+    /**
+     * Connects or disconnects the pad from this frame on. The first entry
+     * connects it unless it says otherwise. A disconnect releases every held
+     * button and zeroes the sticks and triggers, as with a live pad.
+     */
+    readonly connected?: boolean;
+    readonly press?: ReadonlyArray<Button>;
+    readonly release?: ReadonlyArray<Button>;
+    readonly left?: Vector;
+    readonly right?: Vector;
+    readonly leftTrigger?: number;
+    readonly rightTrigger?: number;
+}
+/**
+ * Input changes by snapshot index. Plain data, so it round-trips through
+ * JSON; load it back with `parseTimeline`. It names buttons, not actions, so
+ * a replay follows the bindings as live play does.
+ */
+export type Timeline = ReadonlyArray<TimelineEntry>;
+/** Actions driven by a timeline instead of a host. */
+export interface Scripted<B extends Bindings> extends Actions<B> {
+    /** Number of snapshots taken so far, which is the next frame index. */
+    readonly frames: () => number;
+}
+/**
+ * Plays `timeline`: before the snapshot at index `frame`, every entry for
+ * that frame is applied. A pad counts as connected (with the id
+ * `"scripted"`) from the first entry on, until an entry says
+ * `connected: false`; `scripted(bindings, [])` is a pad that never connects.
+ * Buttons stay held from their press until their release; pressing a held
+ * button is not a new press.
+ */
+export declare const scripted: <const B extends Bindings>(bindings: B, timeline: Timeline) => Scripted<B>;
+/** Live actions that also record the timeline they produce. */
+export interface Recording<B extends Bindings> extends Actions<B> {
+    /** The recorded timeline; `scripted(bindings, timeline)` replays it exactly. */
+    readonly timeline: () => Timeline;
+}
+/**
+ * Wraps `actions` and records, for every snapshot, the buttons pressed and
+ * released since the previous one and the sticks and triggers that moved.
+ */
+export declare const recording: <B extends Bindings>(actions: Actions<B>) => Recording<B>;
+/**
+ * Why loaded data is not a timeline. `path` points at the offending value,
+ * for example `[3].press[0]`.
+ */
+export interface InvalidTimeline {
+    readonly _tag: "InvalidTimeline";
+    readonly path: string;
+    readonly message: string;
+}
+/** Whether `name` is a button of the standard mapping, for validating stored bindings. */
+export declare const isButton: (name: unknown) => name is Button;
+/**
+ * Validates untrusted data, such as a parsed JSON file, as a timeline: an
+ * array of entries with a non-negative integer `frame`, optional
+ * `press`/`release` arrays of button names, optional `left`/`right` vectors
+ * of length at most 1, optional triggers from 0 to 1, and an optional
+ * boolean `connected`.
+ */
+export declare const parseTimeline: (data: unknown) => Result.Result<Timeline, InvalidTimeline>;
+/**
+ * Why loaded data is not a rebinding for the bindings. `path` points at the
+ * offending value, for example `attack[1]`.
+ */
+export type InvalidRebinding = ButtonsInternal.InvalidRebinding;
+/**
+ * Validates untrusted data, such as saved settings parsed from JSON, as new
+ * buttons for `bindings`: an object with exactly the same action names, each
+ * mapped to a non-empty array of button names (for a vector action, an
+ * object with an optional `stick` and buttons for all four directions or
+ * none, as `Gamepad.vector` saves). Pass the result to
+ * {@link Actions.rebind}; on failure, keep the defaults.
+ *
+ * @example
+ * ```ts
+ * const saved = Gamepad.parseRebinding(bindings, JSON.parse(stored))
+ * if (saved.ok) pad.rebind(saved.value)
+ * ```
+ */
+export declare const parseRebinding: <const B extends Bindings>(bindings: B, data: unknown) => Result.Result<Rebinding<B>, InvalidRebinding>;
+//# sourceMappingURL=Gamepad.d.ts.map

package/dist/Gamepad.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Gamepad.d.ts","sourceRoot":"","sources":["../src/Gamepad.ts"],"names":[],"mappings":"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"}