@zylem/game-lib 0.6.3 → 0.6.4

package/dist/{entity-BpbZqg19.d.ts → entity-vj-HTjzU.d.ts}

@@ -2,7 +2,7 @@ import { Vector3, Vector2, Color, Material, BufferGeometry, Mesh, Group, ShaderM
 import { Vector3 as Vector3$1, RigidBodyDesc, ColliderDesc, RigidBody, Vector, Collider } from '@dimforge/rapier3d-compat';
 import { IComponent } from 'bitecs';
 import * as mitt from 'mitt';
-import { b as BehaviorDescriptor, c as BehaviorHandle, d as BehaviorRef } from './behavior-descriptor-BWNWmIjv.js';
+import { c as BehaviorDescriptor, d as BehaviorHandle, e as BehaviorRef } from './behavior-descriptor-BXnVR8Ki.js';
 
 /** Input
  *
@@ -46,6 +46,13 @@ interface InputGamepad {
     axes: {
         Horizontal: AnalogState;
         Vertical: AnalogState;
+        SecondaryHorizontal: AnalogState;
+        SecondaryVertical: AnalogState;
+    };
+    /** Screen-space cursor position (normalized 0..1). Only populated by MouseProvider. */
+    pointer?: {
+        x: number;
+        y: number;
     };
 }
 type Inputs = Record<InputPlayer, InputGamepad>;
@@ -174,6 +181,8 @@ declare abstract class BaseNode<Options = any, T = any> implements NodeInterface
      * onSetup/onUpdate/etc. methods which are typed with `this`.
      */
     protected lifecycleCallbacks: LifecycleCallbacks<any>;
+    private trackLifecycleRegistrations;
+    private userLifecycleRegistrations;
     constructor(args?: BaseNodeOptions[]);
     /**
      * Add setup callbacks to be executed in order during nodeSetup
@@ -209,6 +218,9 @@ declare abstract class BaseNode<Options = any, T = any> implements NodeInterface
     remove(baseNode: NodeInterface): void;
     getChildren(): NodeInterface[];
     isComposite(): boolean;
+    enableUserLifecycleTracking(): void;
+    protected replayUserLifecycleRegistrationsTo(target: BaseNode<any, any>, wrap?: <T extends Function>(callback: T) => T): void;
+    protected cloneChildrenInto(target: BaseNode<any, any>): void;
     abstract create(): T;
     protected abstract _setup(params: SetupContext<this>): void;
     protected abstract _loaded(params: LoadedContext<this>): Promise<void>;
@@ -222,6 +234,7 @@ declare abstract class BaseNode<Options = any, T = any> implements NodeInterface
     nodeCleanup(params: CleanupContext<this>): void;
     getOptions(): Options;
     setOptions(options: Partial<Options>): void;
+    private recordLifecycleRegistration;
 }
 
 type Vec3 = Vector3 | Vector3$1;
@@ -261,6 +274,8 @@ interface MaterialOptions {
     repeat?: Vector2;
     shader?: ZylemShader;
     color?: Color;
+    /** Opacity from 0 (fully transparent) to 1 (fully opaque). */
+    opacity?: number;
     /**
      * When true, prefer TSL/NodeMaterial (for WebGPU)
      * When false, prefer GLSL/ShaderMaterial (for WebGL)
@@ -276,33 +291,40 @@ type BatchKey = ReturnType<typeof shortHash>;
 type TexturePath = string | null;
 declare class MaterialBuilder {
     static batchMaterialMap: Map<BatchKey, BatchMaterialMapObject>;
+    /**
+     * Clear the static batch material cache.
+     * Should be called during game disposal to prevent stale material references
+     * from persisting across demo/stage switches.
+     */
+    static clearBatchCache(): void;
     materials: Material[];
     /** Whether to use TSL/NodeMaterial (for WebGPU compatibility) */
     private useTSL;
     constructor(useTSL?: boolean);
     batchMaterial(options: Partial<MaterialOptions>, entityType: symbol): void;
     build(options: Partial<MaterialOptions>, entityType: symbol): void;
-    withColor(color: Color, useTSL?: boolean): this;
-    withShader(shader: ZylemShaderObject): this;
-    withTSLShader(shader: ZylemTSLShader): this;
+    withColor(color: Color, useTSL?: boolean, opacity?: number): this;
+    withShader(shader: ZylemShaderObject, opacity?: number): this;
+    withTSLShader(shader: ZylemTSLShader, opacity?: number): this;
+    private applyOpacity;
     /**
      * Set texture - loads in background (deferred).
      * Material is created immediately with null map, texture applies when loaded.
      */
-    setTexture(texturePath?: TexturePath, repeat?: Vector2, useTSL?: boolean): void;
+    setTexture(texturePath?: TexturePath, repeat?: Vector2, useTSL?: boolean, opacity?: number): void;
     /**
      * Set normal map for the current material
      */
     setNormalMap(normalMapPath: string, repeat?: Vector2): void;
-    setColor(color: Color, useTSL?: boolean): void;
+    setColor(color: Color, useTSL?: boolean, opacity?: number): void;
     /**
      * Set GLSL shader (WebGL only)
      */
-    setShader(customShader: ZylemShaderObject): void;
+    setShader(customShader: ZylemShaderObject, opacity?: number): void;
     /**
      * Set TSL shader (WebGPU compatible)
      */
-    setTSLShader(tslShader: ZylemTSLShader): void;
+    setTSLShader(tslShader: ZylemTSLShader, opacity?: number): void;
 }
 
 /**
@@ -524,6 +546,14 @@ type ZylemEvents = GameEvents & StageEvents & EntityEvents;
  */
 declare const zylemEventBus: mitt.Emitter<ZylemEvents>;
 
+type VelocityIntentMode = 'replace' | 'add';
+interface VelocityIntent {
+    x?: number;
+    y?: number;
+    z?: number;
+    mode: VelocityIntentMode;
+    priority?: number;
+}
 /**
  * Transform state managed by Valtio for batched physics updates.
  *
@@ -562,11 +592,18 @@ interface TransformState {
         y: number;
         z: number;
     };
+    /** Per-source velocity intents composed once per frame */
+    velocityChannels: Record<string, VelocityIntent>;
     /** Dirty flags to track what needs to be applied */
     dirty: {
         position: boolean;
         rotation: boolean;
+        /** @deprecated Use per-axis velocityX/Y/Z flags for new code */
         velocity: boolean;
+        velocityX: boolean;
+        velocityY: boolean;
+        velocityZ: boolean;
+        velocityChannels: boolean;
         angularVelocity: boolean;
     };
 }
@@ -771,6 +808,7 @@ interface CollisionComponent {
     __kind: 'collision';
     bodyDesc: RigidBodyDesc;
     colliderDesc: ColliderDesc;
+    cloneComponent: () => CollisionComponent;
 }
 interface BaseCollisionOptions {
     /** Whether the body is static (fixed) or dynamic */
@@ -892,8 +930,28 @@ interface CollisionContext<T, O extends GameEntityOptions, TGlobals extends Reco
     other: GameEntity<O | any>;
     globals: TGlobals;
 }
+type CollisionPhase = 'enter' | 'stay';
+interface CollisionRegistrationOptions {
+    phase?: CollisionPhase;
+    cooldownMs?: number;
+}
+interface NormalizedCollisionRegistrationOptions {
+    phase: CollisionPhase;
+    cooldownMs?: number;
+}
+interface CollisionRegistration<T, O extends GameEntityOptions> {
+    id: number;
+    callback: (params: CollisionContext<T, O>) => void;
+    options: NormalizedCollisionRegistrationOptions;
+}
+interface CollisionDispatchMetadata {
+    phase: CollisionPhase;
+    nowMs: number;
+}
 interface CollisionDelegate<T, O extends GameEntityOptions> {
-    collision?: ((params: CollisionContext<any, any>) => void)[];
+    collision?: CollisionRegistration<any, any>[];
+    cooldowns?: Map<string, number>;
+    nextId?: number;
 }
 type IBuilder<BuilderOptions = any> = {
     preBuild: (options: BuilderOptions) => BuilderOptions;
@@ -935,6 +993,7 @@ declare class GameEntity<O extends GameEntityOptions> extends BaseNode<O> implem
     materials: Material[] | undefined;
     bodyDesc: RigidBodyDesc | null;
     body: RigidBody | null;
+    physicsAttached: boolean;
     colliderDesc: ColliderDesc | undefined;
     collider: Collider | undefined;
     custom: Record<string, any>;
@@ -956,6 +1015,9 @@ declare class GameEntity<O extends GameEntityOptions> extends BaseNode<O> implem
     isInstanced: boolean;
     protected eventDelegate: EventEmitterDelegate<EntityEvents>;
     private behaviorRefs;
+    private cloneFactory;
+    private trackAddedComponents;
+    private trackedComponents;
     transformStore: TransformState;
     moveX: (delta: number) => void;
     moveY: (delta: number) => void;
@@ -1002,6 +1064,7 @@ declare class GameEntity<O extends GameEntityOptions> extends BaseNode<O> implem
     add(...components: Array<NodeInterface | Mesh | CollisionComponent>): this;
     private addMeshComponent;
     private addCollisionComponent;
+    private trackComponent;
     private _actions;
     /**
      * Run a fire-and-forget action. Auto-removed when done.
@@ -1023,9 +1086,12 @@ declare class GameEntity<O extends GameEntityOptions> extends BaseNode<O> implem
      */
     _tickActions(delta: number): void;
     create(): this;
+    clone(overrides?: Partial<O>): this;
+    finalizeCloneSupport(factory: (options?: Partial<O>) => GameEntity<O>): this;
     /**
      * Add collision callbacks
      */
+    onCollision(callback: (params: CollisionContext<this, O>) => void, options?: CollisionRegistrationOptions): this;
     onCollision(...callbacks: ((params: CollisionContext<this, O>) => void)[]): this;
     /**
      * Use a behavior on this entity via typed descriptor.
@@ -1040,6 +1106,9 @@ declare class GameEntity<O extends GameEntityOptions> extends BaseNode<O> implem
      * Used by the stage to auto-register required systems.
      */
     getBehaviorRefs(): BehaviorRef[];
+    getCollisionCallbacks(): Array<(params: CollisionContext<this, O>) => void>;
+    getCollisionRegistrations(): Array<CollisionRegistration<this, O>>;
+    private copyBehaviorRefsTo;
     /**
      * Entity-specific setup - resets actions for a fresh stage session.
      * (User callbacks are handled by BaseNode's lifecycleCallbacks.setup)
@@ -1066,7 +1135,7 @@ declare class GameEntity<O extends GameEntityOptions> extends BaseNode<O> implem
      * and must persist across stage reloads. Actions are reset in _setup().
      */
     protected _cleanup(_params: CleanupContext<this>): void;
-    _collision(other: GameEntity<O>, globals?: any): void;
+    _collision(other: GameEntity<O>, globals?: any, dispatch?: CollisionDispatchMetadata): void;
     protected updateMaterials(params: any): void;
     buildInfo(): Record<string, string>;
     /**
@@ -1097,4 +1166,4 @@ declare class GameEntity<O extends GameEntityOptions> extends BaseNode<O> implem
  */
 declare function create(options?: Partial<GameEntityOptions>): GameEntity<GameEntityOptions>;
 
-export { sphereCollision as $, type Action as A, setRotationZ as B, setRotationDegrees as C, setRotationDegreesY as D, setRotationDegreesX as E, setRotationDegreesZ as F, setRotation as G, getRotation as H, GameEntity as I, type UpdateFunction as J, type DestroyFunction as K, type SetupContext as L, type DestroyContext as M, BaseNode as N, type LoadingEvent as O, type GameEntityOptions as P, type StageEvents as Q, type MaterialOptions as R, type SetupFunction as S, type TransformState as T, type UpdateContext as U, type Vec3 as V, type MoveableEntity as W, type InputPlayer as X, create as Y, type ZylemShader as Z, boxCollision as _, moveX as a, coneCollision as a0, pyramidCollision as a1, cylinderCollision as a2, pillCollision as a3, planeCollision as a4, zoneCollision as a5, type CollisionComponent as a6, EventEmitterDelegate as a7, zylemEventBus as a8, type ZylemEvents as a9, type GameEvents as aa, type EntityEvents as ab, type GameLoadingPayload as ac, type StateDispatchPayload as ad, type StageConfigPayload as ae, type EntityConfigPayload as af, type ZylemShaderObject as ag, type ZylemTSLShader as ah, isTSLShader as ai, isGLSLShader as aj, type InputPlayerNumber as ak, type InputProvider as al, type Inputs as am, GameEntityLifeCycle as an, type IGame as ao, type LoadedContext as ap, type CleanupContext as aq, type NodeInterface as ar, type TexturePath as as, moveY as b, createTransformStore as c, moveZ as d, moveXY as e, moveXZ as f, resetVelocity as g, moveForwardXY as h, getPosition as i, getVelocity as j, setPositionX as k, setPositionY as l, move as m, setPositionZ as n, wrapAround3D as o, rotateInDirection as p, rotateYEuler as q, resetTransformStore as r, setPosition as s, rotateEuler as t, rotateX as u, rotateY as v, wrapAroundXY as w, rotateZ as x, setRotationY as y, setRotationX as z };
+export { sphereCollision as $, type Action as A, setRotationZ as B, setRotationDegrees as C, setRotationDegreesY as D, setRotationDegreesX as E, setRotationDegreesZ as F, setRotation as G, getRotation as H, GameEntity as I, type UpdateFunction as J, type DestroyFunction as K, type SetupContext as L, type DestroyContext as M, type LoadingEvent as N, BaseNode as O, type GameEntityOptions as P, type StageEvents as Q, type MaterialOptions as R, type SetupFunction as S, type TransformState as T, type UpdateContext as U, type Vec3 as V, type MoveableEntity as W, type InputPlayer as X, create as Y, type ZylemShader as Z, boxCollision as _, moveX as a, coneCollision as a0, pyramidCollision as a1, cylinderCollision as a2, pillCollision as a3, planeCollision as a4, zoneCollision as a5, type CollisionComponent as a6, EventEmitterDelegate as a7, zylemEventBus as a8, type ZylemEvents as a9, type GameEvents as aa, type EntityEvents as ab, type GameLoadingPayload as ac, type StateDispatchPayload as ad, type StageConfigPayload as ae, type EntityConfigPayload as af, type ZylemShaderObject as ag, type ZylemTSLShader as ah, isTSLShader as ai, isGLSLShader as aj, type InputPlayerNumber as ak, type InputProvider as al, type Inputs as am, GameEntityLifeCycle as an, type IGame as ao, type LoadedContext as ap, type CleanupContext as aq, type NodeInterface as ar, type TexturePath as as, moveY as b, createTransformStore as c, moveZ as d, moveXY as e, moveXZ as f, resetVelocity as g, moveForwardXY as h, getPosition as i, getVelocity as j, setPositionX as k, setPositionY as l, move as m, setPositionZ as n, wrapAround3D as o, rotateInDirection as p, rotateYEuler as q, resetTransformStore as r, setPosition as s, rotateEuler as t, rotateX as u, rotateY as v, wrapAroundXY as w, rotateZ as x, setRotationY as y, setRotationX as z };

package/dist/{global-change-Dc8uCKi2.d.ts → global-change-2JvMaz44.d.ts}

@@ -1,4 +1,4 @@
-import { U as UpdateContext } from './entity-BpbZqg19.js';
+import { U as UpdateContext } from './entity-vj-HTjzU.js';
 
 /**
  * Listen for a single global key change inside an onUpdate pipeline.