@skewedaspect/sage 0.3.0

package/src/classes/input/gamepad.ts

@@ -0,0 +1,388 @@
+//----------------------------------------------------------------------------------------------------------------------
+// Gamepad Input
+//----------------------------------------------------------------------------------------------------------------------
+
+// Interfaces
+import type { ButtonState, GamepadDevice, GamepadInputState } from '../../interfaces/input.ts';
+
+//----------------------------------------------------------------------------------------------------------------------
+
+/**
+ * Callback type for gamepad device connection events
+ */
+export type GamepadDeviceCallback = (device : GamepadDevice) => void;
+
+/**
+ * Callback type for gamepad input events
+ */
+export type GamepadInputCallback = (device : GamepadDevice, state : GamepadInputState) => void;
+
+/**
+ * Responsible for tracking gamepad state and notifying subscribers of changes.
+ */
+export class GamepadInputPlugin
+{
+    private _gamepadDevices : Record<number, GamepadDevice> = {};
+    private _buttonStates : Record<number, Record<string, ButtonState>> = {};
+    private _axesStates : Record<number, Record<string, number>> = {};
+
+    // Callbacks
+    private _onDeviceConnected ?: GamepadDeviceCallback;
+    private _onDeviceDisconnected ?: GamepadDeviceCallback;
+    private _onInputChanged ?: GamepadInputCallback;
+
+    //------------------------------------------------------------------------------------------------------------------
+
+    /**
+     * Create a new GamepadResourceAccess
+     */
+    constructor()
+    {
+        // Set up event listeners for gamepad connection and disconnection
+        this._setupGamepadEvents();
+    }
+
+    //------------------------------------------------------------------------------------------------------------------
+    // Public API
+    //------------------------------------------------------------------------------------------------------------------
+
+    /**
+     * Register a callback for device connected events
+     *
+     * @param callback - The callback to register
+     */
+    public onDeviceConnected(callback : GamepadDeviceCallback) : void
+    {
+        this._onDeviceConnected = callback;
+    }
+
+    /**
+     * Register a callback for device disconnected events
+     *
+     * @param callback - The callback to register
+     */
+    public onDeviceDisconnected(callback : GamepadDeviceCallback) : void
+    {
+        this._onDeviceDisconnected = callback;
+    }
+
+    /**
+     * Register a callback for input changed events
+     *
+     * @param callback - The callback to register
+     */
+    public onInputChanged(callback : GamepadInputCallback) : void
+    {
+        this._onInputChanged = callback;
+    }
+
+    /**
+     * Get all connected gamepad devices
+     */
+    public getDevices() : GamepadDevice[]
+    {
+        return Object.values(this._gamepadDevices).map((device) => ({ ...device }));
+    }
+
+    /**
+     * Get all connected gamepad states
+     */
+    public getStates() : Record<number, GamepadInputState>
+    {
+        const states : Record<number, GamepadInputState> = {};
+
+        Object.keys(this._buttonStates).forEach((indexStr) =>
+        {
+            const index = Number(indexStr);
+            const buttons = this._buttonStates[index] || {};
+            const axes = this._axesStates[index] || {};
+
+            states[index] = {
+                type: 'gamepad',
+                buttons: { ...buttons },
+                axes: { ...axes },
+            };
+        });
+
+        return states;
+    }
+
+    /**
+     * Get a specific gamepad device by index
+     *
+     * @param index - The index of the gamepad to get
+     */
+    public getDevice(index : number) : GamepadDevice | null
+    {
+        const device = this._gamepadDevices[index];
+        return device ? { ...device } : null;
+    }
+
+    /**
+     * Get a specific gamepad state by index
+     *
+     * @param index - The index of the gamepad state to get
+     */
+    public getState(index : number) : GamepadInputState | null
+    {
+        const buttons = this._buttonStates[index];
+        const axes = this._axesStates[index];
+
+        if(!buttons && !axes) { return null; }
+
+        return {
+            type: 'gamepad',
+            buttons: buttons ? { ...buttons } : {},
+            axes: axes ? { ...axes } : {},
+        };
+    }
+
+    /**
+     * Poll for gamepad state updates - call this in your game loop
+     */
+    public pollGamepads() : void
+    {
+        /* eslint-disable no-continue */
+
+        if(!navigator.getGamepads) { return; }
+
+        const gamepads = navigator.getGamepads();
+        for(const gamepad of gamepads)
+        {
+            if(!gamepad) { continue; }
+
+            const index = gamepad.index;
+
+            if(!this._gamepadDevices[index])
+            {
+                this._handleGamepadConnected(gamepad);
+                continue;
+            }
+
+            // Get device
+            const device = this._gamepadDevices[index];
+            if(!device) { continue; }
+
+            // Get current button and axis states or initialize them
+            const currentButtons = this._buttonStates[index] || {};
+            const currentAxes = this._axesStates[index] || {};
+
+            // Build new button state object
+            const newButtons : Record<string, ButtonState> = {};
+            let buttonsChanged = false;
+
+            gamepad.buttons.forEach((btn, i) =>
+            {
+                const buttonKey = `button-${ i }`;
+                const buttonState : ButtonState = {
+                    pressed: btn.pressed,
+                    touched: btn.touched,
+                    value: btn.value,
+                };
+
+                newButtons[buttonKey] = buttonState;
+
+                const prevButton = currentButtons[buttonKey];
+                if(!prevButton
+                    || prevButton.pressed !== buttonState.pressed
+                    || prevButton.touched !== buttonState.touched
+                    || prevButton.value !== buttonState.value)
+                {
+                    buttonsChanged = true;
+                }
+            });
+
+            // Build new axis state object
+            const newAxes : Record<string, number> = {};
+            let axesChanged = false;
+
+            gamepad.axes.forEach((axisValue, i) =>
+            {
+                const axisKey = `axis-${ i }`;
+                newAxes[axisKey] = axisValue;
+
+                const prevAxis = currentAxes[axisKey];
+                if(prevAxis !== axisValue)
+                {
+                    axesChanged = true;
+                }
+            });
+
+            // Update state objects
+            this._buttonStates[index] = newButtons;
+            this._axesStates[index] = newAxes;
+
+            // Notify if state changed
+            if(buttonsChanged || axesChanged)
+            {
+                const state : GamepadInputState = {
+                    type: 'gamepad',
+                    buttons: { ...newButtons },
+                    axes: { ...newAxes },
+                };
+
+                this._notifyInputChanged(device, state);
+            }
+        }
+
+        /* eslint-enable no-continue */
+    }
+
+    /**
+     * Destroy the gamepad resource access and clean up event listeners
+     */
+    public destroy() : void
+    {
+        // Remove gamepad event listeners
+        window.removeEventListener('gamepadconnected', this._handleGamepadConnected);
+        window.removeEventListener('gamepaddisconnected', this._handleGamepadDisconnected);
+    }
+
+    //------------------------------------------------------------------------------------------------------------------
+    // Private Methods
+    //------------------------------------------------------------------------------------------------------------------
+
+    /**
+     * Set up gamepad event listeners
+     */
+    private _setupGamepadEvents() : void
+    {
+        // Bind handlers to this instance
+        this._handleGamepadConnected = this._handleGamepadConnected.bind(this);
+        this._handleGamepadDisconnected = this._handleGamepadDisconnected.bind(this);
+
+        // Add event listeners
+        window.addEventListener('gamepadconnected', this._handleGamepadConnected);
+        window.addEventListener('gamepaddisconnected', this._handleGamepadDisconnected);
+
+        // Check for already connected gamepads (browsers sometimes miss the connected event)
+        if(navigator.getGamepads)
+        {
+            const gamepads = navigator.getGamepads();
+            for(const gamepad of gamepads)
+            {
+                if(gamepad)
+                {
+                    this._handleGamepadConnected(gamepad);
+                }
+            }
+        }
+    }
+
+    /**
+     * Handle gamepad connected event
+     */
+    private _handleGamepadConnected(event : GamepadEvent | Gamepad) : void
+    {
+        const gamepad = event instanceof GamepadEvent ? event.gamepad : event;
+        const index = gamepad.index;
+
+        // Create gamepad device object
+        const gamepadDevice : GamepadDevice = {
+            id: `gamepad-${ index }`,
+            name: gamepad.id,
+            type: 'gamepad',
+            connected: true,
+            index,
+            mapping: gamepad.mapping,
+            axes: Array.from(gamepad.axes),
+            buttons: Array.from(gamepad.buttons),
+        };
+
+        // Store the device
+        this._gamepadDevices[index] = gamepadDevice;
+
+        // Initialize button state object
+        const buttonStateObj : Record<string, ButtonState> = {};
+        Array.from(gamepad.buttons).forEach((btn, i) =>
+        {
+            buttonStateObj[`button-${ i }`] = {
+                pressed: btn.pressed,
+                touched: btn.touched,
+                value: btn.value,
+            };
+        });
+        this._buttonStates[index] = buttonStateObj;
+
+        // Initialize axis state object
+        const axesStateObj : Record<string, number> = {};
+        Array.from(gamepad.axes).forEach((axisValue, i) =>
+        {
+            axesStateObj[`axis-${ i }`] = axisValue;
+        });
+        this._axesStates[index] = axesStateObj;
+
+        // Notify device connected with initial state
+        this._notifyDeviceConnected(gamepadDevice);
+
+        // Emit input changed event with initial state
+        this._notifyInputChanged(gamepadDevice, {
+            type: 'gamepad',
+            buttons: { ...buttonStateObj },
+            axes: { ...axesStateObj },
+            event: event instanceof GamepadEvent ? event : undefined,
+        });
+    }
+
+    /**
+     * Handle gamepad disconnected event
+     */
+    private _handleGamepadDisconnected(event : GamepadEvent) : void
+    {
+        const gamepad = event.gamepad;
+        const index = gamepad.index;
+
+        // Get the device
+        const gamepadDevice = this._gamepadDevices[index];
+
+        if(gamepadDevice)
+        {
+            // Update connection status
+            gamepadDevice.connected = false;
+
+            // Notify device disconnected
+            this._notifyDeviceDisconnected(gamepadDevice);
+
+            // Remove from objects
+            // Using object property assignment with undefined instead of delete
+            this._gamepadDevices[index] = undefined as unknown as GamepadDevice;
+            this._buttonStates[index] = undefined as unknown as Record<string, ButtonState>;
+            this._axesStates[index] = undefined as unknown as Record<string, number>;
+        }
+    }
+
+    /**
+     * Notify subscribers of device connected event
+     */
+    private _notifyDeviceConnected(device : GamepadDevice) : void
+    {
+        if(this._onDeviceConnected)
+        {
+            this._onDeviceConnected(device);
+        }
+    }
+
+    /**
+     * Notify subscribers of device disconnected event
+     */
+    private _notifyDeviceDisconnected(device : GamepadDevice) : void
+    {
+        if(this._onDeviceDisconnected)
+        {
+            this._onDeviceDisconnected(device);
+        }
+    }
+
+    /**
+     * Notify subscribers of input changed event
+     */
+    private _notifyInputChanged(device : GamepadDevice, state : GamepadInputState) : void
+    {
+        if(this._onInputChanged)
+        {
+            this._onInputChanged(device, state);
+        }
+    }
+}
+
+//----------------------------------------------------------------------------------------------------------------------

package/src/classes/input/keyboard.ts

@@ -0,0 +1,189 @@
+//----------------------------------------------------------------------------------------------------------------------
+// Keyboard Input Resource Access
+//----------------------------------------------------------------------------------------------------------------------
+
+// Interfaces
+import type { KeyboardDevice, KeyboardInputState } from '../../interfaces/input.ts';
+
+//----------------------------------------------------------------------------------------------------------------------
+
+/**
+ * Callback type for keyboard device connection events
+ */
+export type KeyboardDeviceCallback = (device : KeyboardDevice) => void;
+
+/**
+ * Callback type for keyboard input events
+ */
+export type KeyboardInputCallback = (device : KeyboardDevice, state : KeyboardInputState) => void;
+
+/**
+ * Responsible for tracking keyboard state and notifying subscribers of changes.
+ */
+export class KeyboardInputPlugin
+{
+    private _keyboardDevice : KeyboardDevice;
+    private _keysState : Record<string, boolean> = {};
+
+    // Callbacks
+    private _onDeviceConnected ?: KeyboardDeviceCallback;
+    private _onInputChanged ?: KeyboardInputCallback;
+
+    //------------------------------------------------------------------------------------------------------------------
+
+    /**
+     * Create a new KeyboardResourceAccess
+     */
+    constructor()
+    {
+        // Initialize keyboard device
+        this._keyboardDevice = {
+            id: 'keyboard-0',
+            name: 'Keyboard',
+            type: 'keyboard',
+            connected: true,
+        };
+
+        // Set up event listeners
+        this._setupKeyboardEvents();
+
+        // Notify that device is connected (on next tick to allow callback registration)
+        setTimeout(() => this._notifyDeviceConnected(), 0);
+    }
+
+    //------------------------------------------------------------------------------------------------------------------
+    // Public API
+    //------------------------------------------------------------------------------------------------------------------
+
+    /**
+     * Register a callback for device connected events
+     *
+     * @param callback - The callback to register
+     */
+    public onDeviceConnected(callback : KeyboardDeviceCallback) : void
+    {
+        this._onDeviceConnected = callback;
+    }
+
+    /**
+     * Register a callback for input changed events
+     *
+     * @param callback - The callback to register
+     */
+    public onInputChanged(callback : KeyboardInputCallback) : void
+    {
+        this._onInputChanged = callback;
+    }
+
+    /**
+     * Get the current keyboard state
+     */
+    public getState() : KeyboardInputState
+    {
+        return {
+            type: 'keyboard',
+            keys: { ...this._keysState },
+            delta: {},
+        };
+    }
+
+    /**
+     * Get the keyboard device
+     */
+    public getDevice() : KeyboardDevice
+    {
+        return { ...this._keyboardDevice };
+    }
+
+    /**
+     * Destroy the keyboard resource access and clean up event listeners
+     */
+    public destroy() : void
+    {
+        // Remove keyboard event listeners
+        window.removeEventListener('keydown', this._handleKeyDown);
+        window.removeEventListener('keyup', this._handleKeyUp);
+    }
+
+    //------------------------------------------------------------------------------------------------------------------
+    // Private Methods
+    //------------------------------------------------------------------------------------------------------------------
+
+    /**
+     * Set up keyboard event listeners
+     */
+    private _setupKeyboardEvents() : void
+    {
+        // Bind handlers to this instance
+        this._handleKeyDown = this._handleKeyDown.bind(this);
+        this._handleKeyUp = this._handleKeyUp.bind(this);
+
+        // Add event listeners
+        window.addEventListener('keydown', this._handleKeyDown);
+        window.addEventListener('keyup', this._handleKeyUp);
+    }
+
+    /**
+     * Handle keyboard key down events
+     */
+    private _handleKeyDown(event : KeyboardEvent) : void
+    {
+        this._keysState[event.code] = true;
+
+        const delta : Record<string, boolean> = {};
+        delta[event.code] = true;
+
+        const state : KeyboardInputState = {
+            type: 'keyboard',
+            keys: { ...this._keysState },
+            delta,
+            event,
+        };
+
+        this._notifyInputChanged(state);
+    }
+
+    /**
+     * Handle keyboard key up events
+     */
+    private _handleKeyUp(event : KeyboardEvent) : void
+    {
+        this._keysState[event.code] = false;
+
+        const delta : Record<string, boolean> = {};
+        delta[event.code] = false;
+
+        const state : KeyboardInputState = {
+            type: 'keyboard',
+            keys: { ...this._keysState },
+            delta,
+            event,
+        };
+
+        this._notifyInputChanged(state);
+    }
+
+    /**
+     * Notify subscribers of device connected event
+     */
+    private _notifyDeviceConnected() : void
+    {
+        if(this._onDeviceConnected)
+        {
+            this._onDeviceConnected(this._keyboardDevice);
+        }
+    }
+
+    /**
+     * Notify subscribers of input changed event
+     */
+    private _notifyInputChanged(state : KeyboardInputState) : void
+    {
+        if(this._onInputChanged)
+        {
+            this._onInputChanged(this._keyboardDevice, state);
+        }
+    }
+}
+
+//----------------------------------------------------------------------------------------------------------------------