@skewedaspect/sage 0.3.0

package/src/managers/entity.ts

@@ -0,0 +1,252 @@
+//----------------------------------------------------------------------------------------------------------------------
+// Entity Manager
+//----------------------------------------------------------------------------------------------------------------------
+
+import { GameEntity } from '../classes/entity.ts';
+import { GameEventBus } from '../classes/eventBus.ts';
+
+// Interfaces
+import type { Action } from '../interfaces/action.ts';
+import type { GameEntityDefinition } from '../interfaces/entity.ts';
+import type { LoggerInterface } from '../interfaces/logger.ts';
+import type { BindingManager } from '../managers/binding.ts';
+
+// Utils
+import { LoggingUtility, SAGELogger } from '../utils/logger.ts';
+
+//----------------------------------------------------------------------------------------------------------------------
+
+export class GameEntityManager
+{
+    /** The event bus for the entity manager. */
+    private eventBus : GameEventBus;
+
+    /** A map of entities managed by the entity manager. */
+    private entities : Map<string, GameEntity> = new Map<string, GameEntity>();
+
+    /** A map of entity definitions registered with the entity manager. */
+    private entityDefinitions : Map<string, GameEntityDefinition> = new Map<string, GameEntityDefinition>();
+
+    /** Reference to the binding manager for registering actions */
+    private bindingManager : BindingManager;
+
+    /** Logger instance */
+    private _log : LoggerInterface;
+
+    /**
+     * Creates an instance of EntityManager.
+     * @param eventBus - The event bus for the entity manager.
+     * @param logger - The logging utility to use
+     * @param bindingManager - The binding manager for registering actions
+     */
+    constructor(eventBus : GameEventBus, logger : LoggingUtility | undefined, bindingManager : BindingManager)
+    {
+        this.eventBus = eventBus;
+        this.bindingManager = bindingManager;
+        this._log = logger?.getLogger('EntityManager') || new SAGELogger('EntityManager');
+        this._log.info('EntityManager initialized');
+    }
+
+    //------------------------------------------------------------------------------------------------------------------
+    // Private Methods
+    //------------------------------------------------------------------------------------------------------------------
+
+    /**
+     * Checks if two actions are compatible
+     * @param existingAction - The action already registered
+     * @param newAction - The action being registered
+     * @returns true if the actions are compatible, false if they have conflicting options
+     */
+    private areActionsCompatible(existingAction : Action, newAction : Action) : boolean
+    {
+        // If types don't match, they're incompatible
+        if(existingAction.type !== newAction.type)
+        {
+            return false;
+        }
+
+        // For analog actions, check min and max values
+        if(existingAction.type === 'analog' && newAction.type === 'analog')
+        {
+            // If minValue or maxValue is specified and differs, they're incompatible
+            if((newAction.minValue !== undefined && existingAction.minValue !== newAction.minValue)
+                || (newAction.maxValue !== undefined && existingAction.maxValue !== newAction.maxValue))
+            {
+                return false;
+            }
+        }
+
+        // Digital actions are always compatible if they have the same name
+        return true;
+    }
+
+    /**
+     * Registers actions defined in the entity definition with the binding manager
+     * @param entityDef - The entity definition containing actions to register
+     */
+    private registerEntityActions(entityDef : GameEntityDefinition) : void
+    {
+        if(!entityDef.actions)
+        {
+            return;
+        }
+
+        for(const action of entityDef.actions)
+        {
+            try
+            {
+                // Check if the action is already registered
+                const existingAction = this.bindingManager.getAction(action.name);
+
+                if(!existingAction)
+                {
+                    // Action doesn't exist yet, register it
+                    this._log.debug(`Registering action "${ action.name }" from entity type "${ entityDef.type }"`);
+                    this.bindingManager.registerAction(action);
+                }
+                else if(!this.areActionsCompatible(existingAction, action))
+                {
+                    this._log.warn(
+                        `Action "${ action.name }" already registered with different options. `
+                        + `Entity "${ entityDef.type }" requires: ${ JSON.stringify(action) }, `
+                        + `but found: ${ JSON.stringify(existingAction) }`
+                    );
+                }
+                else
+                {
+                    this._log.trace(
+                        `Action "${ action.name }" already registered with compatible options, skipping registration`
+                    );
+                }
+            }
+            catch (err)
+            {
+                this._log.debug(`Failed to register action "${ action.name }": `
+                    + `${ err instanceof Error ? err.message : String(err) }`);
+            }
+        }
+    }
+
+    $frameUpdate(dt : number) : void
+    {
+        this._log.trace(`Updating ${ this.entities.size } entities with dt=${ dt }`);
+        for(const entity of this.entities.values())
+        {
+            entity.$update(dt);
+        }
+    }
+
+    //------------------------------------------------------------------------------------------------------------------
+    // Public API
+    //------------------------------------------------------------------------------------------------------------------
+
+    /**
+     * Registers a new entity definition.
+     * @param entityDef - The definition of the entity.
+     */
+    registerEntityDefinition(entityDef : GameEntityDefinition) : void
+    {
+        this._log.debug(`Registering entity definition: ${ entityDef.type }`);
+
+        // Register any actions this entity requires
+        this.registerEntityActions(entityDef);
+
+        // Store the entity definition
+        this.entityDefinitions.set(entityDef.type, entityDef);
+    }
+
+    /**
+     * Creates a new entity of the given type.
+     * @param type - The type of the entity to create.
+     * @param initialState - The initial state of the entity.
+     * @returns The created entity.
+     */
+    createEntity<State extends object = object>(type : string, initialState : Partial<State> = {}) : GameEntity<State>
+    {
+        this._log.debug(`Creating entity of type: ${ type }`);
+        const entityDef = this.entityDefinitions.get(type);
+        if(!entityDef)
+        {
+            const errorMsg = `Entity type ${ type } is not registered.`;
+            this._log.error(errorMsg);
+            throw new Error(errorMsg);
+        }
+
+        this._log.trace(`Using entity definition with ${ entityDef.behaviors?.length || 0 } behaviors`);
+        const mergedState = { ...entityDef.defaultState, ...initialState } as State;
+
+        const entity = new GameEntity<State>(
+            entityDef.type,
+            this.eventBus,
+            mergedState,
+            entityDef.behaviors
+        );
+
+        this.entities.set(entity.id, entity);
+        this._log.debug(`Entity created with ID: ${ entity.id }`);
+        return entity;
+    }
+
+    /**
+     * Destroys the entity with the given ID.
+     * @param entityID - The ID of the entity to destroy.
+     */
+    destroyEntity(entityID : string) : void
+    {
+        this._log.debug(`Destroying entity: ${ entityID }`);
+        const entity = this.entities.get(entityID);
+        if(entity)
+        {
+            entity.$destroy();
+            this.entities.delete(entityID);
+            this._log.debug(`Entity ${ entityID } destroyed`);
+        }
+        else
+        {
+            this._log.warn(`Attempted to destroy non-existent entity: ${ entityID }`);
+        }
+    }
+
+    /**
+     * Gets the entity with the given ID.
+     * @param entityID - The ID of the entity to get.
+     * @returns The entity with the given ID, or null if it does not exist.
+     */
+    getEntity(entityID : string) : GameEntity | null
+    {
+        this._log.trace(`Getting entity: ${ entityID }`);
+        return this.entities.get(entityID) ?? null;
+    }
+
+    /**
+     * Adds an existing entity to the entity manager.
+     * @param entity - The entity to add.
+     */
+    addEntity(entity : GameEntity) : void
+    {
+        this._log.debug(`Adding existing entity: ${ entity.id } (type: ${ entity.type })`);
+        this.entities.set(entity.id, entity);
+    }
+
+    /**
+     * Removes the entity with the given ID, without destroying it.
+     * @param entityID - The ID of the entity to remove.
+     */
+    removeEntity(entityID : string) : void
+    {
+        this._log.debug(`Removing entity: ${ entityID }`);
+        const entity = this.entities.get(entityID);
+        if(entity)
+        {
+            this.entities.delete(entityID);
+            this._log.debug(`Entity ${ entityID } removed`);
+        }
+        else
+        {
+            this._log.warn(`Attempted to remove non-existent entity: ${ entityID }`);
+        }
+    }
+}
+
+//----------------------------------------------------------------------------------------------------------------------
+

package/src/managers/game.ts

@@ -0,0 +1,111 @@
+//----------------------------------------------------------------------------------------------------------------------
+// Game Manager
+//----------------------------------------------------------------------------------------------------------------------
+
+import { AbstractEngine, Scene } from '@babylonjs/core';
+
+// Interfaces
+import { GameCanvas } from '../interfaces/game.ts';
+import { LoggerInterface } from '../interfaces/logger.ts';
+
+// Managers
+import { GameEntityManager } from './entity.ts';
+import { UserInputManager } from './input.ts';
+
+// Engines
+import { SceneEngine } from '../engines/scene.ts';
+
+// Utils
+import { isBrowser } from '../utils/capabilities.ts';
+import { LoggingUtility, SAGELogger } from '../utils/logger.ts';
+
+//----------------------------------------------------------------------------------------------------------------------
+
+export class GameManager
+{
+    private _engine : AbstractEngine;
+    private _entityManager : GameEntityManager;
+    private _inputManager : UserInputManager;
+    private _sceneEngine : SceneEngine;
+    private _currentScene : Scene | null = null;
+    private _log : LoggerInterface;
+
+    public started = false;
+
+    //------------------------------------------------------------------------------------------------------------------
+
+    constructor(
+        engine : AbstractEngine,
+        sceneEngine : SceneEngine,
+        entityManager : GameEntityManager,
+        inputManager : UserInputManager,
+        logger ?: LoggingUtility
+    )
+    {
+        this._engine = engine;
+        this._sceneEngine = sceneEngine;
+        this._entityManager = entityManager;
+        this._inputManager = inputManager;
+        this._log = logger?.getLogger('GameManager') || new SAGELogger('GameManager');
+
+        if(isBrowser())
+        {
+            // Resize the engine on window resize
+            window.addEventListener('resize', this._resizeHandler.bind(this));
+        }
+    }
+
+    private _renderLoop() : void
+    {
+        // Update entities and entity manager
+        const deltaTime = this._engine.getDeltaTime();
+        this._entityManager.$frameUpdate(deltaTime);
+
+        // Update input devices
+        if(this._inputManager)
+        {
+            this._inputManager.pollGamepads();
+        }
+
+        // Render the current scene
+        if(this._currentScene)
+        {
+            this._currentScene.render();
+        }
+    }
+
+    private _resizeHandler() : void
+    {
+        if(this.started)
+        {
+            this._engine.resize();
+        }
+    }
+
+    //------------------------------------------------------------------------------------------------------------------
+    // Public API
+    //------------------------------------------------------------------------------------------------------------------
+
+    async start(canvas : GameCanvas) : Promise<void>
+    {
+        // TODO: There needs to be some sort of initial scene we load
+        this._currentScene = await this._sceneEngine.loadScene(canvas);
+
+        // Start the render loop
+        this._engine.runRenderLoop(this._renderLoop.bind(this));
+
+        this.started = true;
+
+        this._log.info('SkewedAspect Game Engine started successfully');
+    }
+
+    async stop() : Promise<void>
+    {
+        this.started = false;
+        this._engine.stopRenderLoop();
+
+        this._log.info('SkewedAspect Game Engine stopped successfully');
+    }
+}
+
+//----------------------------------------------------------------------------------------------------------------------

package/src/managers/input.ts

@@ -0,0 +1,233 @@
+//----------------------------------------------------------------------------------------------------------------------
+// User Input Manager
+//----------------------------------------------------------------------------------------------------------------------
+
+// Interfaces
+import type { GamepadInputState, InputDevice, KeyboardInputState, MouseInputState } from '../interfaces/input.ts';
+import type { LoggerInterface } from '../interfaces/logger.ts';
+
+// Classes
+import { type GameEvent, GameEventBus } from '../classes/eventBus.ts';
+
+// Utils
+import { LoggingUtility, SAGELogger } from '../utils/logger.ts';
+
+// Resource Access
+import { KeyboardInputPlugin } from '../classes/input/keyboard.ts';
+import { MouseInputPlugin } from '../classes/input/mouse.ts';
+import { GamepadInputPlugin } from '../classes/input/gamepad.ts';
+
+//----------------------------------------------------------------------------------------------------------------------
+
+/**
+ * Manager for handling user input from various devices (keyboard, mouse, gamepad)
+ */
+export class UserInputManager
+{
+    private _eventBus : GameEventBus;
+
+    private _keyboardRA : KeyboardInputPlugin;
+    private _mouseRA : MouseInputPlugin;
+    private _gamepadRA : GamepadInputPlugin;
+
+    /** Logger instance */
+    private _log : LoggerInterface;
+
+    //------------------------------------------------------------------------------------------------------------------
+
+    /**
+     * Create a new UserInputManager
+     *
+     * @param eventBus - The game event bus to publish events to
+     * @param canvas - The DOM element to attach input listeners to
+     * @param logger - The logging utility to use
+     */
+    constructor(
+        eventBus : GameEventBus,
+        canvas : HTMLElement,
+        logger ?: LoggingUtility
+    )
+    {
+        this._eventBus = eventBus;
+
+        // Initialize logger
+        this._log = logger?.getLogger('UserInputManager') || new SAGELogger('UserInputManager');
+
+        this._log.info('Initializing UserInputManager');
+
+        // Initialize resource access classes
+        this._log.debug('Initializing input resource access classes');
+        this._keyboardRA = new KeyboardInputPlugin();
+        this._mouseRA = new MouseInputPlugin(canvas);
+        this._gamepadRA = new GamepadInputPlugin();
+
+        // Register callbacks
+        this._log.debug('Registering input event callbacks');
+        this._keyboardRA.onDeviceConnected(this._publishDeviceConnected.bind(this));
+        this._keyboardRA.onInputChanged(this._publishInputChanged.bind(this));
+        this._mouseRA.onDeviceConnected(this._publishDeviceConnected.bind(this));
+        this._mouseRA.onInputChanged(this._publishInputChanged.bind(this));
+        this._gamepadRA.onDeviceConnected(this._publishDeviceConnected.bind(this));
+        this._gamepadRA.onDeviceDisconnected(this._publishDeviceDisconnected.bind(this));
+        this._gamepadRA.onInputChanged(this._publishInputChanged.bind(this));
+
+        this._log.info('UserInputManager initialized successfully');
+    }
+
+    //------------------------------------------------------------------------------------------------------------------
+    // Private methods
+    //------------------------------------------------------------------------------------------------------------------
+
+    /**
+     * Publish device connected event to the event bus
+     */
+    private _publishDeviceConnected(device : InputDevice) : void
+    {
+        this._log.debug(`Device connected: ${ device.id } (${ device.name })`);
+
+        const gameEvent : GameEvent = {
+            type: 'input:device:connected',
+            payload: { device },
+        };
+
+        this._eventBus.publish(gameEvent);
+    }
+
+    /**
+     * Publish device disconnected event to the event bus
+     */
+    private _publishDeviceDisconnected(device : InputDevice) : void
+    {
+        this._log.debug(`Device disconnected: ${ device.id } (${ device.name })`);
+
+        const gameEvent : GameEvent = {
+            type: 'input:device:disconnected',
+            payload: { device },
+        };
+
+        this._eventBus.publish(gameEvent);
+    }
+
+    /**
+     * Publish input changed event to the event bus, used by all device types
+     */
+    private _publishInputChanged(
+        device : InputDevice,
+        state : KeyboardInputState | MouseInputState | GamepadInputState
+    ) : void
+    {
+        this._log.trace(`Input changed: ${ device.id }`, state);
+
+        const gameEvent : GameEvent = {
+            type: 'input:changed',
+            payload: {
+                deviceId: device.id,
+                device,
+                state,
+            },
+        };
+
+        // Publish the event to the event bus
+        this._eventBus.publish(gameEvent);
+    }
+
+    //------------------------------------------------------------------------------------------------------------------
+    // Internal methods
+    //------------------------------------------------------------------------------------------------------------------
+
+    /**
+     * Destroy the input manager and clean up event listeners
+     */
+    public $destroy() : void
+    {
+        this._log.info('Destroying UserInputManager');
+
+        // Cleanup all resource access instances
+        this._log.debug('Cleaning up input resource access instances');
+        this._keyboardRA.destroy();
+        this._mouseRA.destroy();
+        this._gamepadRA.destroy();
+
+        this._log.info('UserInputManager destroyed');
+    }
+
+    //------------------------------------------------------------------------------------------------------------------
+    // Public methods
+    //------------------------------------------------------------------------------------------------------------------
+
+    /**
+     * Get all input devices
+     *
+     * @return An array of input devices
+     */
+    public listDevices() : InputDevice[]
+    {
+        this._log.debug('Getting all connected input devices');
+
+        const devices : InputDevice[] = [];
+
+        // Add keyboard and mouse
+        devices.push(this._keyboardRA.getDevice());
+        devices.push(this._mouseRA.getDevice());
+
+        // Add all gamepads
+        devices.push(...this._gamepadRA.getDevices());
+
+        this._log.debug(`Found ${ devices.length } connected devices`);
+        return devices;
+    }
+
+    /**
+     * Get a specific input device by ID
+     *
+     * @param deviceId - The ID of the device to get
+     *
+     * @return The input device, or null if not found
+     */
+    public getDevice(deviceId : string) : InputDevice | null
+    {
+        this._log.debug(`Getting device: ${ deviceId }`);
+
+        // Shortcut for keyboard and mouse
+        if(deviceId.startsWith('keyboard-'))
+        {
+            return this._keyboardRA.getDevice();
+        }
+        else if(deviceId.startsWith('mouse-'))
+        {
+            return this._mouseRA.getDevice();
+        }
+        else if(deviceId.startsWith('gamepad-'))
+        {
+            const index = parseInt(deviceId.split('-')[1], 10);
+            return this._gamepadRA.getDevice(index);
+        }
+        else
+        {
+            // This is the slow path, and should never be hit, but it is here for completeness
+            const devices = this.listDevices();
+
+            for(const device of devices)
+            {
+                if(device.id === deviceId)
+                {
+                    return device;
+                }
+            }
+        }
+
+        this._log.warn(`Device not found: ${ deviceId }`);
+        return null;
+    }
+
+    /**
+     * Poll for gamepad state updates - call this in your game loop
+     */
+    public pollGamepads() : void
+    {
+        this._gamepadRA.pollGamepads();
+    }
+}
+
+//----------------------------------------------------------------------------------------------------------------------
+