@nice2dev/game-engine 1.0.28 → 1.1.6

package/dist/types/systems/NiceInput.d.ts

@@ -0,0 +1,280 @@
+export type ActionId = string;
+export type AxisId = string;
+export type InputDevice = 'keyboard' | 'mouse' | 'gamepad' | 'touch';
+export type KeyCode = string;
+export type MouseButton = 'left' | 'right' | 'middle' | 'back' | 'forward';
+export type GamepadButton = 'a' | 'b' | 'x' | 'y' | 'lb' | 'rb' | 'lt' | 'rt' | 'back' | 'start' | 'ls' | 'rs' | 'dpad-up' | 'dpad-down' | 'dpad-left' | 'dpad-right';
+export type GamepadAxis = 'left-x' | 'left-y' | 'right-x' | 'right-y' | 'lt' | 'rt';
+export interface KeyBinding {
+    type: 'keyboard';
+    key: KeyCode;
+    modifiers?: {
+        ctrl?: boolean;
+        alt?: boolean;
+        shift?: boolean;
+        meta?: boolean;
+    };
+}
+export interface MouseBinding {
+    type: 'mouse';
+    button: MouseButton;
+    modifiers?: {
+        ctrl?: boolean;
+        alt?: boolean;
+        shift?: boolean;
+    };
+}
+export interface GamepadButtonBinding {
+    type: 'gamepad-button';
+    button: GamepadButton;
+    gamepadIndex?: number;
+}
+export interface GamepadAxisBinding {
+    type: 'gamepad-axis';
+    axis: GamepadAxis;
+    direction: 'positive' | 'negative';
+    deadzone?: number;
+    gamepadIndex?: number;
+}
+export interface TouchBinding {
+    type: 'touch';
+    gesture: 'tap' | 'double-tap' | 'hold' | 'swipe-up' | 'swipe-down' | 'swipe-left' | 'swipe-right';
+    fingers?: number;
+}
+export type InputBinding = KeyBinding | MouseBinding | GamepadButtonBinding | GamepadAxisBinding | TouchBinding;
+export interface ActionDefinition {
+    id: ActionId;
+    name: string;
+    description?: string;
+    bindings: InputBinding[];
+    /** Can be held */
+    holdable: boolean;
+    /** Input buffer time (ms) */
+    bufferTime?: number;
+    /** Group for UI organization */
+    group?: string;
+    /** Tags */
+    tags?: string[];
+}
+export interface AxisDefinition {
+    id: AxisId;
+    name: string;
+    description?: string;
+    positiveBindings: InputBinding[];
+    negativeBindings: InputBinding[];
+    /** Dead zone (0-1) */
+    deadzone: number;
+    /** Smoothing factor (0-1) */
+    smoothing: number;
+    /** Invert axis */
+    inverted: boolean;
+    /** Sensitivity multiplier */
+    sensitivity: number;
+    /** Group */
+    group?: string;
+}
+export interface ActionState {
+    actionId: ActionId;
+    /** Currently pressed */
+    pressed: boolean;
+    /** Just pressed this frame */
+    justPressed: boolean;
+    /** Just released this frame */
+    justReleased: boolean;
+    /** How long held (ms) */
+    heldTime: number;
+    /** Last trigger time */
+    lastTrigger: number;
+    /** Buffered press */
+    buffered: boolean;
+}
+export interface AxisState {
+    axisId: AxisId;
+    /** Current value (-1 to 1) */
+    value: number;
+    /** Raw value before smoothing */
+    rawValue: number;
+    /** Previous frame value */
+    previousValue: number;
+    /** Delta this frame */
+    delta: number;
+}
+export interface MouseState {
+    position: {
+        x: number;
+        y: number;
+    };
+    delta: {
+        x: number;
+        y: number;
+    };
+    buttons: Set<MouseButton>;
+    wheel: {
+        x: number;
+        y: number;
+    };
+    locked: boolean;
+}
+export interface TouchState {
+    touches: Map<number, {
+        id: number;
+        position: {
+            x: number;
+            y: number;
+        };
+        startPosition: {
+            x: number;
+            y: number;
+        };
+        delta: {
+            x: number;
+            y: number;
+        };
+        startTime: number;
+    }>;
+    gestures: string[];
+}
+export interface GamepadState {
+    index: number;
+    connected: boolean;
+    id: string;
+    buttons: Map<GamepadButton, boolean>;
+    axes: Map<GamepadAxis, number>;
+    vibrating: boolean;
+}
+export interface InputFrame {
+    timestamp: number;
+    actions: Map<ActionId, boolean>;
+    axes: Map<AxisId, number>;
+    mouse?: {
+        position: {
+            x: number;
+            y: number;
+        };
+        buttons: number;
+    };
+}
+export interface InputRecording {
+    id: string;
+    name: string;
+    startTime: number;
+    duration: number;
+    frames: InputFrame[];
+}
+export type InputEventType = 'action-pressed' | 'action-released' | 'action-held' | 'axis-changed' | 'gamepad-connected' | 'gamepad-disconnected' | 'binding-changed' | 'context-changed';
+export interface InputEvent {
+    type: InputEventType;
+    timestamp: number;
+    data: unknown;
+}
+export type InputEventCallback = (event: InputEvent) => void;
+export interface InputContext {
+    id: string;
+    name: string;
+    actions: ActionId[];
+    axes: AxisId[];
+    priority: number;
+}
+export interface InputConfig {
+    /** Mouse sensitivity */
+    mouseSensitivity: number;
+    /** Gamepad deadzone */
+    gamepadDeadzone: number;
+    /** Input buffer time (ms) */
+    defaultBufferTime: number;
+    /** Enable gamepad */
+    enableGamepad: boolean;
+    /** Enable touch */
+    enableTouch: boolean;
+    /** Storage key for bindings */
+    storageKey: string;
+}
+export declare const DEFAULT_INPUT_CONFIG: InputConfig;
+export declare class NiceInput {
+    private config;
+    private actions;
+    private axes;
+    private actionStates;
+    private axisStates;
+    private contexts;
+    private activeContexts;
+    private keysPressed;
+    private keysPressedThisFrame;
+    private keysReleasedThisFrame;
+    private mouse;
+    private touch;
+    private gamepads;
+    private recordings;
+    private currentRecording;
+    private playingRecording;
+    private eventListeners;
+    private lastUpdateTime;
+    private element;
+    constructor(config?: Partial<InputConfig>);
+    init(element?: HTMLElement): void;
+    on(event: InputEventType, callback: InputEventCallback): () => void;
+    private emit;
+    registerAction(action: ActionDefinition): void;
+    registerActions(actions: ActionDefinition[]): void;
+    registerAxis(axis: AxisDefinition): void;
+    registerAxes(axes: AxisDefinition[]): void;
+    registerContext(context: InputContext): void;
+    pushContext(contextId: string): void;
+    popContext(contextId: string): void;
+    isContextActive(contextId: string): boolean;
+    private isActionInActiveContext;
+    private handleKeyDown;
+    private handleKeyUp;
+    private handleMouseDown;
+    private handleMouseUp;
+    private handleMouseMove;
+    private handleWheel;
+    private handleTouchStart;
+    private handleTouchMove;
+    private handleTouchEnd;
+    private handleGamepadConnected;
+    private handleGamepadDisconnected;
+    private getMouseButton;
+    update(deltaTime: number): void;
+    private updateGamepads;
+    private checkBindings;
+    private checkBinding;
+    private getGamepadAxisValue;
+    isPressed(actionId: ActionId): boolean;
+    isJustPressed(actionId: ActionId): boolean;
+    isJustReleased(actionId: ActionId): boolean;
+    isBuffered(actionId: ActionId): boolean;
+    consumeBuffer(actionId: ActionId): boolean;
+    getAxisValue(axisId: AxisId): number;
+    getAxisDelta(axisId: AxisId): number;
+    getActionState(actionId: ActionId): ActionState | undefined;
+    getAxisState(axisId: AxisId): AxisState | undefined;
+    getMousePosition(): {
+        x: number;
+        y: number;
+    };
+    getMouseDelta(): {
+        x: number;
+        y: number;
+    };
+    isMouseButtonPressed(button: MouseButton): boolean;
+    isKeyPressed(key: KeyCode): boolean;
+    rebindAction(actionId: ActionId, newBindings: InputBinding[]): void;
+    addBinding(actionId: ActionId, binding: InputBinding): void;
+    removeBinding(actionId: ActionId, index: number): void;
+    lockMouse(): void;
+    unlockMouse(): void;
+    isMouseLocked(): boolean;
+    vibrate(gamepadIndex: number, duration: number, weakMagnitude?: number, strongMagnitude?: number): void;
+    startRecording(name: string): string;
+    stopRecording(): InputRecording | null;
+    private recordFrame;
+    playRecording(recordingId: string): void;
+    stopPlayback(): void;
+    private playbackFrame;
+    private saveBindings;
+    private loadBindings;
+    resetBindings(): void;
+    destroy(): void;
+}
+export declare function createInputSystem(config?: Partial<InputConfig>): NiceInput;