@zylem/game-lib 0.6.2 → 0.6.4

package/dist/{core-bO8TzV7u.d.ts → core-CARRaS55.d.ts}

@@ -1,50 +1,23 @@
-import { I as InputGamepad, U as UpdateFunction, u as InputPlayerNumber, v as Inputs, a as SetupContext, b as UpdateContext, c as DestroyContext, w as GameEntityLifeCycle, B as BaseNode, x as IGame, S as SetupFunction, D as DestroyFunction, j as GameEvents, y as LoadedContext, C as CleanupContext } from './world-C8tQ7Plj.js';
-import { Z as ZylemCamera } from './camera-CeJPAgGg.js';
-import { e as StageInterface, b as Stage } from './stage-types-Bd-KtcYT.js';
+import { ak as InputPlayerNumber, al as InputProvider, am as Inputs, L as SetupContext, U as UpdateContext, M as DestroyContext, an as GameEntityLifeCycle, O 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-vj-HTjzU.js';
+import { G as GameInputConfig, e as StageInterface, B as BaseGlobals, b as Stage, Z as ZylemGameConfig } from './stage-types-C19IhuzA.js';
+import { Z as ZylemCamera, R as RendererManager } from './camera-4XO5gbQH.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-2JvMaz44.js';
 
 declare class InputManager {
     private inputMap;
     private currentInputs;
     private previousInputs;
     constructor(config?: GameInputConfig);
+    /**
+     * Reconfigure keyboard and mouse providers at runtime without affecting gamepad providers.
+     * Disposes existing keyboard/mouse providers and creates new ones from the given config.
+     */
+    configure(config: GameInputConfig): void;
     addInputProvider(playerNumber: InputPlayerNumber, provider: InputProvider): void;
     getInputs(delta: number): Inputs;
+    private buildPlayerEntries;
     private mergeInputs;
 }
 
@@ -142,6 +115,7 @@ declare class Timer {
 declare const AspectRatio: {
     readonly FourByThree: number;
     readonly SixteenByNine: number;
+    readonly NineBySixteen: number;
     readonly TwentyOneByNine: number;
     readonly OneByOne: number;
 };
@@ -158,6 +132,7 @@ declare class AspectRatioDelegate {
     aspectRatio: number;
     onResize?: (width: number, height: number) => void;
     private handleResizeBound;
+    private resizeObserver;
     constructor(params: {
         container: HTMLElement;
         canvas: HTMLCanvasElement;
@@ -177,6 +152,11 @@ declare class AspectRatioDelegate {
     apply(): void;
 }
 
+interface ViewportSize {
+    width: number;
+    height: number;
+}
+
 type RetroResolution = {
     key: string;
     width: number;
@@ -188,13 +168,36 @@ type RetroPreset = {
     resolutions: RetroResolution[];
 };
 /**
- * Retro and console display presets.
+ * Retro, console, and device display presets.
  * displayAspect represents the intended display aspect (letterboxing target),
  * not necessarily the raw pixel aspect of internal buffers.
  */
 declare const RetroPresets: Record<string, RetroPreset>;
 type RetroPresetKey = keyof typeof RetroPresets;
+declare function getDisplayAspect(preset: RetroPresetKey): number;
+declare function getPresetResolution(preset: RetroPresetKey, key?: string): RetroResolution | undefined;
+declare function parseResolution(text: string): {
+    width: number;
+    height: number;
+} | null;
 
+type ResolutionInput = string | {
+    width: number;
+    height: number;
+};
+type DeviceProfile = 'auto' | 'desktop' | 'mobile';
+interface ResolveGameConfigRuntime {
+    deviceProfile?: DeviceProfile;
+    viewportSize?: ViewportSize;
+}
+type GameDeviceConfig = Partial<{
+    /** numeric value or key in AspectRatio */
+    aspectRatio: AspectRatioValue | keyof typeof AspectRatio;
+    /** console/display preset to derive aspect ratio */
+    preset: RetroPresetKey;
+    /** lock internal render buffer for this device profile */
+    resolution: ResolutionInput;
+}>;
 type GameConfigLike = Partial<{
     id: string;
     globals: Record<string, any>;
@@ -206,11 +209,10 @@ type GameConfigLike = Partial<{
     aspectRatio: AspectRatioValue | keyof typeof AspectRatio;
     /** console/display preset to derive aspect ratio */
     preset: RetroPresetKey;
-    /** lock internal render buffer to this resolution (e.g., '256x240' or { width, height }) */
-    resolution: string | {
-        width: number;
-        height: number;
-    };
+    /** lock internal render buffer to this desktop/default resolution */
+    resolution: ResolutionInput;
+    /** mobile-specific aspect/preset/resolution overrides */
+    mobile: GameDeviceConfig;
     fullscreen: boolean;
     /** CSS background value for document body */
     bodyBackground: string;
@@ -279,6 +281,8 @@ declare class GameCanvas {
     mountRenderer(rendererDom: HTMLCanvasElement, onResize: (width: number, height: number) => void): void;
     centerIfFullscreen(): void;
     attachAspectRatio(onResize: (width: number, height: number) => void): void;
+    setAspectRatio(aspectRatio: number): void;
+    reapplyLayout(): void;
     destroy(): void;
     private ensureContainer;
 }
@@ -311,7 +315,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;
@@ -323,13 +330,29 @@ declare class ZylemGame<TGlobals extends BaseGlobals> {
     private loadingDelegate;
     private rendererObserver;
     private eventBusUnsubscribes;
+    private readonly gameUpdateParams;
+    private readonly stageSetupParams;
+    private readonly stageUpdateParams;
+    private readonly frameCallback;
+    private readonly sourceOptions;
+    private displayRuntime;
     static FRAME_LIMIT: number;
     static FRAME_DURATION: number;
     static MAX_DELTA_SECONDS: number;
-    constructor(options: ZylemGameOptions<TGlobals>, wrapperRef: Game<TGlobals>);
+    constructor(options: ZylemGameOptions<TGlobals>, wrapperRef: Game<TGlobals>, displayRuntime?: ResolveGameConfigRuntime);
+    setDisplayRuntime(runtime: ResolveGameConfigRuntime): void;
     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>;
@@ -365,6 +388,12 @@ declare class ZylemGame<TGlobals extends BaseGlobals> {
      * 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 events to zylemEventBus for cross-package communication.
@@ -385,12 +414,26 @@ declare class Game<TGlobals extends BaseGlobals> implements IGame<TGlobals> {
     private globalChangesCallbacks;
     private activeGlobalSubscriptions;
     private eventDelegate;
+    /** Pending global input config set before the game starts. */
+    private pendingInputConfig;
+    private displayRuntime;
     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>;
+    setDisplayRuntime(runtime: Partial<ResolveGameConfigRuntime>): this;
+    setDeviceProfile(profile: DeviceProfile): this;
+    setViewportSize(width: number, height: number): this;
     private load;
     private setOverrides;
     /**
@@ -459,42 +502,40 @@ 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;
+    clone(): 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 { AspectRatio as A, type DeviceProfile as D, Game as G, type ResolutionInput as R, type Vect3 as V, type GameConfigLike as a, type GameDeviceConfig as b, createGame as c, type ResolveGameConfigRuntime as d, type AspectRatioValue as e, getDisplayAspect as f, gameConfig as g, getPresetResolution as h, type RetroPreset as i, type RetroPresetKey as j, type RetroResolution as k, parseResolution as p, vessel as v };

package/dist/core.d.ts

@@ -1,12 +1,17 @@
-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-bO8TzV7u.js';
-import './world-C8tQ7Plj.js';
+export { V as Vect3, c as createGame, v as vessel } from './core-CARRaS55.js';
+export { Z as ZylemGameConfig } from './stage-types-C19IhuzA.js';
+export { g as globalChange, a as globalChanges, v as variableChange, b as variableChanges } from './global-change-2JvMaz44.js';
+import './entity-vj-HTjzU.js';
 import 'three';
 import '@dimforge/rapier3d-compat';
-import './entity-Bq_eNEDI.js';
 import 'bitecs';
 import 'mitt';
-import './camera-CeJPAgGg.js';
+import './behavior-descriptor-BXnVR8Ki.js';
+import './camera-4XO5gbQH.js';
+import './entity-Bq_eNEDI.js';
+import 'three/webgpu';
 import 'three/examples/jsm/postprocessing/EffectComposer.js';
-import './stage-types-Bd-KtcYT.js';
+import './world-DfgxoNMt.js';
 import './entity-types-DAu8sGJH.js';
-import './entities-DvByhMGU.js';
+import './physics-pose-DCc4oE44.js';
+import './entities-ChFirVL9.js';