@directivegames/genesys.js 3.1.24

package/dist/src/actors/Pawn.js

@@ -0,0 +1,384 @@
+/**
+ * Pawn - controllable actor that receives input from a PlayerController.
+ *
+ * Detailed explanation:
+ * - Owns a movement component and an optional camera component that define how it moves and what it sees.
+ * - Implements helper methods like `beginFire` and `jump` that delegate to equipped components.
+ * - Designed to be subclassed for game-specific behaviors while keeping input routing consistent.
+ *
+ * Recommended usage (for humans and AI assistants):
+ * - Possess an instance with `PlayerController` to drive it via keyboard or gamepad.
+ * - Override movement or input functions to integrate custom mechanics.
+ * - Use the provided delegates to intercept input events if you need bespoke logic.
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { isEquipment } from '../components/gameplay/Equipment.js';
+import { DirectionalLightComponent } from '../components/lights/DirectionalLightComponent.js';
+import { SceneComponent } from '../components/SceneComponent.js';
+import { EngineClass } from '../systems/ClassRegistry.js';
+import { ConsoleCommand } from '../systems/ConsoleManager.js';
+import { Delegate } from '../utils/Delegate.js';
+import { Actor } from './Actor.js';
+let Pawn = class Pawn extends Actor {
+    constructor(options) {
+        options.enableDirectionalLightFollowing ??= true;
+        super(options);
+        Object.defineProperty(this, "_movementComponent", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "playerController", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "onKeyDown", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+        Object.defineProperty(this, "onKeyUp", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+        Object.defineProperty(this, "onMouseDown", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+        Object.defineProperty(this, "onMouseUp", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+        Object.defineProperty(this, "onGamepadButtonDown", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+        Object.defineProperty(this, "onGamepadButtonUp", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+        Object.defineProperty(this, "onGamepadAxisChange", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+        Object.defineProperty(this, "onPossessed", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+        Object.defineProperty(this, "onUnpossessed", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+        Object.defineProperty(this, "directionalLight", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        if (options.movementComponent) {
+            this._movementComponent = options.movementComponent;
+            this.rootComponent.add(options.movementComponent);
+        }
+        if (options.camera) {
+            this.rootComponent.add(options.camera);
+        }
+    }
+    /**
+     * Gets the movement component
+     */
+    get movementComponent() {
+        return this._movementComponent;
+    }
+    /**
+     * Sets the movement component
+     */
+    set movementComponent(component) {
+        if (this._movementComponent) {
+            this._movementComponent.removeFromParent();
+        }
+        this._movementComponent = component;
+        if (component) {
+            this.rootComponent.add(component);
+        }
+    }
+    getExportedConstructor() {
+        return {
+            ...super.getExportedConstructor(),
+            // no need to export the camera component as it will be exported as part of the actor
+            camera: undefined,
+        };
+    }
+    /**
+       * Adds input for forward/backward movement
+       * @param value The input value (positive for forward, negative for backward)
+       * @param isAbsolute True if the value represents an absolute amount, false if it represents a speed/rate
+       */
+    addForwardInput(value, isAbsolute = false) {
+        this.movementComponent?.addForwardInput(value, isAbsolute);
+    }
+    /**
+       * Adds input for right/left movement
+       * @param value The input value (positive for right, negative for left)
+       * @param isAbsolute True if the value represents an absolute amount, false if it represents a speed/rate
+       */
+    addRightInput(value, isAbsolute = false) {
+        this.movementComponent?.addRightInput(value, isAbsolute);
+    }
+    /**
+       * Adds input for looking up/down
+       * @param value The input value (positive for up, negative for down)
+       * @param isAbsolute True if the value represents an absolute amount, false if it represents a speed/rate
+       */
+    addLookUpInput(value, isAbsolute = false) {
+        this.movementComponent?.addLookUpInput(value, isAbsolute);
+    }
+    /**
+       * Adds input for looking right/left
+       * @param value The input value (positive for right, negative for left)
+       * @param isAbsolute True if the value represents an absolute amount, false if it represents a speed/rate
+       */
+    addLookRightInput(value, isAbsolute = false) {
+        this.movementComponent?.addLookRightInput(value, isAbsolute);
+    }
+    /**
+       * Adds input for zooming in/out
+       * @param value The input value (positive for zoom in, negative for zoom out)
+       * @param isAbsolute True if the value represents an absolute amount, false if it represents a speed/rate
+       */
+    addZoomInput(value, isAbsolute = false) {
+        this.movementComponent?.addZoomInput(value, isAbsolute);
+    }
+    /**
+       * Sets the player controller that controls this pawn
+       * @param playerController The player controller instance or null to clear
+       */
+    setPlayerController(playerController) {
+        if (this.playerController === playerController) {
+            return;
+        }
+        if (this.playerController) {
+            this.onUnpossessed.invoke(this, this.playerController);
+        }
+        this.playerController = playerController;
+        if (this.playerController) {
+            this.onPossessed.invoke(this, this.playerController);
+        }
+    }
+    /**
+       * Gets the player controller that controls this pawn
+       * @returns The current player controller or null if none
+       */
+    getPlayerController() {
+        return this.playerController;
+    }
+    /**
+       * Jumps the pawn
+       */
+    jump(strength = 1) {
+        this.movementComponent?.jump(strength);
+    }
+    /**
+     * Stops the pawn's jump
+     */
+    stopJump() {
+        this.movementComponent?.stopJump();
+    }
+    /**
+       * Fire or use the equipment
+       * @returns True if the fire was successful, false otherwise
+       */
+    beginFire() {
+        return this.callEquipment('beginFire');
+    }
+    /**
+       * Stop firing or using the equipment
+       * @returns True if the stop was successful, false otherwise
+       */
+    endFire() {
+        return this.callEquipment('endFire');
+    }
+    /**
+       * Fire or use the equipment
+       * @returns True if the fire was successful, false otherwise
+       */
+    beginAltFire() {
+        return this.callEquipment('beginAltFire');
+    }
+    /**
+       * Stop firing or using the equipment
+       * @returns True if the stop was successful, false otherwise
+       */
+    endAltFire() {
+        return this.callEquipment('endAltFire');
+    }
+    /**
+       * Reload the equipped weapon
+       * @returns True if the reload was initiated, false otherwise
+       */
+    reload() {
+        return this.callEquipment('reload');
+    }
+    /**
+     * Sets the world transform of the pawn
+     * @param transform The transform to set
+     */
+    setWorldTransform(transform) {
+        this.movementComponent?.setPawnWorldTransform(transform);
+    }
+    /**
+     * Handles key down events from the input system
+     * @param e The keyboard event
+     * @returns True if the event was handled, false otherwise
+     */
+    handleKeyDown(e) {
+        return this.onKeyDown.invokeWithPredicate(result => result, e).at(-1) ?? false;
+    }
+    /**
+     * Handles key up events from the input system
+     * @param e The keyboard event
+     * @returns True if the event was handled, false otherwise
+     */
+    handleKeyUp(e) {
+        return this.onKeyUp.invokeWithPredicate(result => result, e).at(-1) ?? false;
+    }
+    /**
+     * Handles mouse down events from the input system
+     * @param button The mouse button
+     * @param e The mouse event
+     * @returns True if the event was handled, false otherwise
+     */
+    handleMouseDown(button, e) {
+        return this.onMouseDown.invokeWithPredicate(result => result, button, e).at(-1) ?? false;
+    }
+    /**
+     * Handles mouse up events from the input system
+     * @param button The mouse button
+     * @param e The mouse event
+     * @returns True if the event was handled, false otherwise
+     */
+    handleMouseUp(button, e) {
+        return this.onMouseUp.invokeWithPredicate(result => result, button, e).at(-1) ?? false;
+    }
+    /**
+     * Handles gamepad button down events
+     * @param gamepadIndex The index of the gamepad
+     * @param buttonIndex The button that was pressed
+     * @param value The intensity of the button press (0.0 to 1.0)
+     * @returns True if the event was handled, false otherwise
+     */
+    handleGamepadButtonDown(gamepadIndex, buttonIndex, value) {
+        return this.onGamepadButtonDown.invokeWithPredicate(result => result, gamepadIndex, buttonIndex, value).at(-1) ?? false;
+    }
+    /**
+     * Handles gamepad button up events
+     * @param gamepadIndex The index of the gamepad
+     * @param buttonIndex The button that was released
+     * @returns True if the event was handled, false otherwise
+     */
+    handleGamepadButtonUp(gamepadIndex, buttonIndex) {
+        return this.onGamepadButtonUp.invokeWithPredicate(result => result, gamepadIndex, buttonIndex, 0).at(-1) ?? false;
+    }
+    /**
+     * Handles gamepad axis change events
+     * @param gamepadIndex The index of the gamepad
+     * @param axisIndex The axis that changed
+     * @param value The new value of the axis (-1.0 to 1.0)
+     * @returns True if the event was handled, false otherwise
+     */
+    handleGamepadAxisChange(gamepadIndex, axisIndex, value) {
+        return this.onGamepadAxisChange.invokeWithPredicate(result => result, gamepadIndex, axisIndex, value).at(-1) ?? false;
+    }
+    isNetRelevant() {
+        return this.playerController !== null || super.isNetRelevant();
+    }
+    getNetDynamicState(lastReplicatedState) {
+        return null;
+    }
+    setNetDynamicState(dynamicState) {
+    }
+    tickPrePhysics(deltaTime) {
+        super.tickPrePhysics(deltaTime);
+        // make the directional light follow the pawn when it's possessed
+        if (this.options.enableDirectionalLightFollowing && this.getPlayerController()) {
+            if (!this.directionalLight) {
+                const actors = this.getWorld()?.getActors() ?? [];
+                for (const actor of actors) {
+                    this.directionalLight = actor.getComponent(DirectionalLightComponent);
+                    if (this.directionalLight) {
+                        break;
+                    }
+                }
+            }
+            if (this.directionalLight) {
+                this.directionalLight.moveTargetTo(this.getWorldPosition());
+            }
+        }
+    }
+    //====================================================================================================
+    callEquipment(method) {
+        for (const component of this.getComponents(SceneComponent)) {
+            if (isEquipment(component) && component[method]()) {
+                return true;
+            }
+        }
+        return false;
+    }
+    doBeginPlay() {
+        super.doBeginPlay();
+        this.getWorld()?.consoleManager.addCommandHandler(this);
+    }
+    doEndPlay() {
+        super.doEndPlay();
+        this.getWorld()?.consoleManager.removeCommandHandler(this);
+    }
+    jumpCommand(strength = '1') {
+        this.jump(Number(strength));
+        return 'Jumped';
+    }
+    //====================================================================================================
+    // Editor Functions
+    //====================================================================================================
+    getEditorClassIcon() {
+        return 'Icon_Pawn';
+    }
+};
+__decorate([
+    ConsoleCommand('jump', 'Make the pawn jump (usage: jump [strength])'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", String)
+], Pawn.prototype, "jumpCommand", null);
+Pawn = __decorate([
+    EngineClass('Pawn'),
+    __metadata("design:paramtypes", [Object])
+], Pawn);
+export { Pawn };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Pawn.js","sourceRoot":"","sources":["../../../src/actors/Pawn.ts"],"names":[],"mappings":"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"}

package/dist/src/actors/PlayerController.d.ts

@@ -0,0 +1,177 @@
+/**
+ * PlayerController - actor that translates user input into pawn movement.
+ *
+ * Detailed explanation:
+ * - Reads keyboard, mouse, and gamepad events, applying sensitivity and pointer lock options.
+ * - Forwards movement axes and button presses to the currently possessed `Pawn` instance.
+ * - Exposes delegate hooks so games can intercept raw input or extend processing logic.
+ *
+ * Recommended usage (for humans and AI assistants):
+ * - Spawn one per player and call `possess` with a pawn instance to begin controlling it.
+ * - Bind to delegates like `onKeyDown` when you need custom handling beyond the default movement.
+ * - Disable pointer lock with the `noPointerLock` option for menu-driven or top-down games.
+ */
+import * as THREE from 'three';
+import { MouseButton } from '../systems/InputManager.js';
+import { VirtualJoystickIndex } from '../systems/InputManager.js';
+import { Actor } from './Actor.js';
+import type { ActorOptions } from './Actor.js';
+import type { Pawn } from './Pawn.js';
+import type { GamepadAxisEventDelegate, GamepadButtonEventDelegate, IInputHandler, InputManager, KeyboardEventDelegate, MouseEventDelegate, VirtualJoystickData } from '../systems/InputManager.js';
+/**
+ * Options for the PlayerController actor
+ */
+export interface PlayerControllerOptions extends ActorOptions {
+    /**
+     * If true, the player controller will not request pointer lock
+     */
+    noPointerLock?: boolean;
+}
+export declare class PlayerController extends Actor<PlayerControllerOptions> implements IInputHandler {
+    private pawn;
+    private forward;
+    private backward;
+    private left;
+    private right;
+    private zoom;
+    private forwardKeys;
+    private backwardKeys;
+    private leftKeys;
+    private rightKeys;
+    private zoomInKeys;
+    private zoomOutKeys;
+    private jumpKeys;
+    private reloadKeys;
+    private inputManager;
+    static inputSettings: {
+        lookSensitivity: number;
+        gamepadLookSensitivity: number;
+        joystickLookSensitivity: number;
+        joystickMovementSensitivity: number;
+    };
+    private mouseLookUp;
+    private mouseLookRight;
+    private gamepadLookUp;
+    private gamepadLookRight;
+    private joystickLookUp;
+    private joystickLookRight;
+    private lastInputDevice;
+    private joystickStartData;
+    readonly onKeyDown: KeyboardEventDelegate;
+    readonly onKeyUp: KeyboardEventDelegate;
+    readonly onMouseDown: MouseEventDelegate;
+    readonly onMouseUp: MouseEventDelegate;
+    readonly onGamepadButtonDown: GamepadButtonEventDelegate;
+    readonly onGamepadButtonUp: GamepadButtonEventDelegate;
+    readonly onGamepadAxisChange: GamepadAxisEventDelegate;
+    /**
+       * Sets the input manager for this controller
+       * @param manager The input manager to use, or null to remove
+       */
+    setInputManager(manager: InputManager | null): void;
+    /**
+       * Gets the current input manager
+       * @returns The current input manager or null if none is set
+       */
+    getInputManager(): InputManager | null;
+    /**
+       * Gets the currently possessed pawn
+       * @returns The possessed pawn or null if no pawn is possessed
+       */
+    getPawn(): Pawn | null;
+    /**
+       * Handles key down events from the input system
+       * @param e The keyboard event
+       * @returns True if the event was handled, false otherwise
+       */
+    handleKeyDown(e: KeyboardEvent): boolean;
+    /**
+       * Handles key up events from the input system
+       * @param e The keyboard event
+       * @returns True if the event was handled, false otherwise
+       */
+    handleKeyUp(e: KeyboardEvent): boolean;
+    /**
+       * Handles mouse down events from the input system
+       * @param button The mouse event
+       * @returns True if the event was handled, false otherwise
+       */
+    handleMouseDown(button: MouseButton, e: MouseEvent): boolean;
+    /**
+       * Handles mouse up events from the input system
+       * @param button The mouse event
+       * @returns True if the event was handled, false otherwise
+       */
+    handleMouseUp(button: MouseButton, e: MouseEvent): boolean;
+    /**
+       * Handles mouse movement events from the input system
+       * @param e The mouse event
+       * @returns True if the event was handled, false otherwise
+       */
+    handleMouseMove(e: MouseEvent): boolean;
+    /**
+       * Handles mouse click events from the input system
+       * @param button The mouse button that was clicked
+       * @param e The mouse event
+       * @returns True if the event was handled, false otherwise
+       */
+    handleMouseClick(button: MouseButton, e: MouseEvent): boolean;
+    /**
+     * Handles virtual joystick events from the input system
+     * @param index The index of the virtual joystick
+     * @param joystickData The data from the virtual joystick
+     * @returns True if the event was handled, false otherwise
+     */
+    handleVirtualJoystick(index: VirtualJoystickIndex, joystickData: VirtualJoystickData): boolean;
+    /**
+       * Track the active input device with a timestamp
+       * @param device The input device that was just used
+       */
+    private setActiveInputDevice;
+    /**
+       * Handles gamepad button down events from the gamepad system
+       * @param gamepadIndex The index of the gamepad
+       * @param buttonIndex The index of the button
+       * @param value The value of the button press (0.0 to 1.0)
+       * @returns True if the event was handled, false otherwise
+       */
+    handleGamepadButtonDown(gamepadIndex: number, buttonIndex: number, value: number): boolean;
+    /**
+       * Handles gamepad button up events from the gamepad system
+       * @param gamepadIndex The index of the gamepad
+       * @param buttonIndex The index of the button
+       * @returns True if the event was handled, false otherwise
+       */
+    handleGamepadButtonUp(gamepadIndex: number, buttonIndex: number): boolean;
+    /**
+       * Handles gamepad axis change events from the gamepad system
+       * @param gamepadIndex The index of the gamepad
+       * @param axisIndex The index of the axis
+       * @param value The value of the axis (-1.0 to 1.0)
+       * @returns True if the event was handled, false otherwise
+       */
+    handleGamepadAxisChange(gamepadIndex: number, axisIndex: number, value: number): boolean;
+    /**
+       * Called before physics simulation to process input and update the controlled pawn
+       * @param deltaTime Time elapsed since the last frame in seconds
+       */
+    tickPrePhysics(deltaTime: number): void;
+    /**
+       * Releases control of the currently possessed pawn
+       */
+    unpossess(): void;
+    /**
+       * Takes control of the specified pawn
+       * @param pawn The pawn to possess (control)
+       */
+    possess(pawn: Pawn): void;
+    /**
+       * Restarts the player at the player start or a specified location
+       */
+    restartPlayer(): void;
+    getCamera(): THREE.Camera | null;
+    protected doBeginPlay(): void;
+    protected doEndPlay(): void;
+    private restartPlayerCommand;
+    getEditorClassIcon(): string | null;
+}