@zylem/game-lib 0.6.0 → 0.6.3

package/dist/{core-CZhozNRH.d.ts → core-DAkskq6Y.d.ts}

@@ -1,52 +1,23 @@
-import { I as InputGamepad, c as UpdateFunction, f as InputPlayerNumber, g as Inputs, h as ButtonState, A as AnalogState, S as SetupContext, U as UpdateContext, d as DestroyContext, i as GameEntityLifeCycle, e as BaseNode, j as IGame, b as SetupFunction, D as DestroyFunction, k as LoadedContext, C as CleanupContext } from './entity-COvRtFNG.js';
-import { Z as ZylemCamera } from './camera-CpbDr4-V.js';
-import { d as StageInterface, b as Stage } from './stage-types-CD21XoIU.js';
+import { ak as InputPlayerNumber, al as InputProvider, am as Inputs, L as SetupContext, U as UpdateContext, M as DestroyContext, an as GameEntityLifeCycle, N as BaseNode, ao as IGame, S as SetupFunction, J as UpdateFunction, K as DestroyFunction, aa as GameEvents, ap as LoadedContext, aq as CleanupContext, ar as NodeInterface } from './entity-BpbZqg19.js';
+import { G as GameInputConfig, e as StageInterface, B as BaseGlobals, b as Stage, Z as ZylemGameConfig } from './stage-types-BFsm3qsZ.js';
+import { Z as ZylemCamera, R as RendererManager } from './camera-B5e4c78l.js';
 import { Vector3 } from 'three';
 import { Vector3 as Vector3$1 } from '@dimforge/rapier3d-compat';
-
-interface InputProvider {
-    getInput(delta: number): Partial<InputGamepad>;
-    isConnected(): boolean;
-    getName(): string;
-}
-
-type BasicTypes = number | string | boolean;
-type BaseGlobals = Record<string, BasicTypes>;
-type KeyboardMapping = Record<string, string[]>;
-type MouseMapping = Record<string, string[]>;
-interface GameInputPlayerConfig {
-    key?: KeyboardMapping;
-    mouse?: MouseMapping;
-}
-interface GameInputConfig {
-    p1?: GameInputPlayerConfig;
-    p2?: GameInputPlayerConfig;
-    p3?: GameInputPlayerConfig;
-    p4?: GameInputPlayerConfig;
-    p5?: GameInputPlayerConfig;
-    p6?: GameInputPlayerConfig;
-    p7?: GameInputPlayerConfig;
-    p8?: GameInputPlayerConfig;
-}
-interface ZylemGameConfig<StageInterface, GameInterface, TGlobals extends BaseGlobals> {
-    id: string;
-    globals?: TGlobals;
-    stages?: StageInterface[];
-    update?: UpdateFunction<GameInterface>;
-    debug?: boolean;
-    time?: number;
-    input?: GameInputConfig;
-}
+import './global-change-Dc8uCKi2.js';
 
 declare class InputManager {
     private inputMap;
     private currentInputs;
     private previousInputs;
     constructor(config?: GameInputConfig);
+    /**
+     * Reconfigure keyboard providers at runtime without affecting gamepad providers.
+     * Disposes existing keyboard providers and creates new ones from the given config.
+     */
+    configure(config: GameInputConfig): void;
     addInputProvider(playerNumber: InputPlayerNumber, provider: InputProvider): void;
     getInputs(delta: number): Inputs;
-    mergeButtonState(a: ButtonState | undefined, b: ButtonState | undefined): ButtonState;
-    mergeAnalogState(a: AnalogState | undefined, b: AnalogState | undefined): AnalogState;
+    private buildPlayerEntries;
     private mergeInputs;
 }
 
@@ -313,7 +284,10 @@ declare class ZylemGame<TGlobals extends BaseGlobals> {
     timer: Timer;
     inputManager: InputManager;
     wrapperRef: Game<TGlobals>;
+    globalInputConfig: GameInputConfig | undefined;
     defaultCamera: ZylemCamera | null;
+    /** Shared renderer manager for all stages */
+    rendererManager: RendererManager | null;
     container: HTMLElement | null;
     canvas: HTMLCanvasElement | null;
     aspectRatioDelegate: AspectRatioDelegate | null;
@@ -332,10 +306,25 @@ declare class ZylemGame<TGlobals extends BaseGlobals> {
     loadGameCanvas(config: GameConfig): void;
     loadDebugOptions(options: ZylemGameOptions<TGlobals>): void;
     loadStage(stage: Stage, stageIndex?: number): Promise<void>;
+    /**
+     * Merges game-level global input config with the stage's per-stage overrides
+     * and reconfigures the InputManager.
+     */
+    applyInputConfig(stage: Stage): void;
+    /**
+     * Update the game-level global input config and re-apply to the current stage.
+     */
+    setGlobalInputConfig(config: GameInputConfig): void;
     unloadCurrentStage(): void;
     setGlobals(options: ZylemGameConfig<Stage, ZylemGame<TGlobals>, TGlobals>): void;
     params(): UpdateContext<ZylemGame<TGlobals>, TGlobals>;
     start(): void;
+    /**
+     * Execute a single frame update.
+     * This method can be called directly for testing or from the game loop.
+     * @param deltaTime Optional delta time in seconds. If not provided, uses timer delta.
+     */
+    step(deltaTime?: number): void;
     loop(timestamp: number): void;
     dispose(): void;
     outOfLoop(): void;
@@ -348,9 +337,28 @@ declare class ZylemGame<TGlobals extends BaseGlobals> {
      * @returns Unsubscribe function
      */
     onLoading(callback: (event: GameLoadingEvent) => void): () => void;
+    /**
+     * Build the stage config payload for the current stage.
+     */
+    private buildStageConfigPayload;
+    /**
+     * Build the entities payload for the current stage.
+     */
+    private buildEntitiesPayload;
+    /**
+     * Emit a state:dispatch event to the zylemEventBus.
+     * Called after stage load and on global state changes.
+     */
+    private emitStateDispatch;
+    /**
+     * Inspect a stage's options to determine the renderer type.
+     * Looks for CameraWrapper instances in the stage options and uses
+     * the first camera's rendererType. Falls back to 'webgl'.
+     */
+    private resolveRendererType;
     /**
      * Subscribe to the game event bus for stage loading and state events.
-     * Emits window events for cross-application communication.
+     * Emits events to zylemEventBus for cross-package communication.
      */
     private subscribeToEventBus;
 }
@@ -367,11 +375,22 @@ declare class Game<TGlobals extends BaseGlobals> implements IGame<TGlobals> {
     private globalChangeCallbacks;
     private globalChangesCallbacks;
     private activeGlobalSubscriptions;
+    private eventDelegate;
+    /** Pending global input config set before the game starts. */
+    private pendingInputConfig;
     refErrorMessage: string;
     constructor(options: GameOptions<TGlobals>);
     onSetup(...callbacks: Array<SetupFunction<ZylemGame<TGlobals>, TGlobals>>): this;
     onUpdate(...callbacks: Array<UpdateFunction<ZylemGame<TGlobals>, TGlobals>>): this;
     onDestroy(...callbacks: Array<DestroyFunction<ZylemGame<TGlobals>, TGlobals>>): this;
+    /**
+     * Set composable input configuration as global defaults for the entire game.
+     * Multiple configs are deep-merged (later configs win on key conflicts).
+     * Per-stage overrides (via stage.setInputConfiguration) are merged on top.
+     * Can be called before or after start().
+     * @example game.setInputConfiguration(useArrowsForAxes('p1'), useWASDForDirections('p2'));
+     */
+    setInputConfiguration(...configs: GameInputConfig[]): this;
     start(): Promise<this>;
     private load;
     private setOverrides;
@@ -400,6 +419,12 @@ declare class Game<TGlobals extends BaseGlobals> implements IGame<TGlobals> {
     getCurrentStage(): Stage | null;
     pause(): Promise<void>;
     resume(): Promise<void>;
+    /**
+     * Execute a single frame update.
+     * Useful for testing or manual frame stepping.
+     * @param deltaTime Optional delta time in seconds (defaults to 1/60)
+     */
+    step(deltaTime?: number): void;
     reset(): Promise<void>;
     previousStage(): void;
     loadStageFromId(stageId: string): Promise<void>;
@@ -407,6 +432,16 @@ declare class Game<TGlobals extends BaseGlobals> implements IGame<TGlobals> {
     goToStage(): Promise<void>;
     end(): Promise<void>;
     dispose(): void;
+    /**
+     * Dispatch an event from the game.
+     * Events are emitted both locally and to the global event bus.
+     */
+    dispatch<K extends keyof GameEvents>(event: K, payload: GameEvents[K]): void;
+    /**
+     * Listen for events on this game instance.
+     * @returns Unsubscribe function
+     */
+    listen<K extends keyof GameEvents>(event: K, handler: (payload: GameEvents[K]) => void): () => void;
     /**
      * Subscribe to loading events from the game.
      * Events include stage context (stageName, stageIndex).
@@ -425,42 +460,39 @@ declare class Game<TGlobals extends BaseGlobals> implements IGame<TGlobals> {
  */
 declare function createGame<TGlobals extends BaseGlobals>(...options: GameOptions<TGlobals>): Game<TGlobals>;
 
+/**
+ * A Vessel is an empty container entity that holds child entities.
+ * It has no geometry, physics, or rendering of its own, but propagates
+ * lifecycle events to its children and provides a logical grouping mechanism.
+ *
+ * Child entities added to a Vessel will be individually spawned into the
+ * stage's physics world and render scene when the Vessel is spawned.
+ */
 declare class Vessel extends BaseNode<{}, Vessel> {
     static type: symbol;
     protected _setup(_params: SetupContext<this>): void;
     protected _loaded(_params: LoadedContext<this>): Promise<void>;
     protected _update(_params: UpdateContext<this>): void;
     protected _destroy(_params: DestroyContext<this>): void;
-    protected _cleanup(_params: CleanupContext<this>): Promise<void>;
+    protected _cleanup(_params: CleanupContext<this>): void;
     create(): this;
+    /**
+     * Add one or more child entities to this vessel.
+     * Overrides parent to support multiple arguments.
+     * @returns this for chaining
+     */
+    add(...nodes: NodeInterface[]): this;
 }
-declare function vessel(...args: Array<BaseNode>): BaseNode<{}, Vessel>;
-
 /**
- * @deprecated This type is deprecated.
+ * Create a vessel containing the given child entities.
+ * @param args Child BaseNode entities to add
+ * @returns A new Vessel with the children added
  */
-type Vect3 = Vector3 | Vector3$1;
+declare function vessel(...args: Array<BaseNode>): Vessel;
 
 /**
- * Listen for a single global key change inside an onUpdate pipeline.
- * Usage: onUpdate(globalChange('p1Score', (value) => { ... }))
- */
-declare function globalChange<T = any>(key: string, callback: (value: T, ctx: UpdateContext<any>) => void): (ctx: UpdateContext<any>) => void;
-/**
- * Listen for multiple global key changes inside an onUpdate pipeline.
- * Calls back when any of the provided keys changes.
- * Usage: onUpdate(globalChanges(['p1Score','p2Score'], ([p1,p2]) => { ... }))
- */
-declare function globalChanges<T = any>(keys: string[], callback: (values: T[], ctx: UpdateContext<any>) => void): (ctx: UpdateContext<any>) => void;
-/**
- * Listen for a single stage variable change inside an onUpdate pipeline.
- * Usage: onUpdate(variableChange('score', (value, ctx) => { ... }))
- */
-declare function variableChange<T = any>(key: string, callback: (value: T, ctx: UpdateContext<any>) => void): (ctx: UpdateContext<any>) => void;
-/**
- * Listen for multiple stage variable changes; fires when any changes.
- * Usage: onUpdate(variableChanges(['a','b'], ([a,b], ctx) => { ... }))
+ * @deprecated This type is deprecated.
  */
-declare function variableChanges<T = any>(keys: string[], callback: (values: T[], ctx: UpdateContext<any>) => void): (ctx: UpdateContext<any>) => void;
+type Vect3 = Vector3 | Vector3$1;
 
-export { Game as G, type Vect3 as V, type ZylemGameConfig as Z, globalChange as a, globalChanges as b, createGame as c, variableChange as d, variableChanges as e, gameConfig as g, vessel as v };
+export { Game as G, type Vect3 as V, createGame as c, gameConfig as g, vessel as v };

package/dist/core.d.ts

@@ -1,10 +1,16 @@
-export { V as Vect3, Z as ZylemGameConfig, c as createGame, a as globalChange, b as globalChanges, d as variableChange, e as variableChanges, v as vessel } from './core-CZhozNRH.js';
-import './entity-COvRtFNG.js';
+export { V as Vect3, c as createGame, v as vessel } from './core-DAkskq6Y.js';
+export { Z as ZylemGameConfig } from './stage-types-BFsm3qsZ.js';
+export { g as globalChange, a as globalChanges, v as variableChange, b as variableChanges } from './global-change-Dc8uCKi2.js';
+import './entity-BpbZqg19.js';
 import 'three';
 import '@dimforge/rapier3d-compat';
 import 'bitecs';
-import './camera-CpbDr4-V.js';
-import 'three/examples/jsm/postprocessing/EffectComposer.js';
+import 'mitt';
+import './behavior-descriptor-BWNWmIjv.js';
+import './camera-B5e4c78l.js';
 import './entity-Bq_eNEDI.js';
-import './stage-types-CD21XoIU.js';
-import './entities-BAxfJOkk.js';
+import 'three/webgpu';
+import 'three/examples/jsm/postprocessing/EffectComposer.js';
+import './world-Be5m1XC1.js';
+import './entity-types-DAu8sGJH.js';
+import './entities-DC9ce_vx.js';