@zylem/game-lib 0.5.1 → 0.6.2

package/dist/entity-Bq_eNEDI.d.ts

@@ -0,0 +1,28 @@
+import { RigidBody, Collider, KinematicCharacterController } from '@dimforge/rapier3d-compat';
+import { Group, Mesh } from 'three';
+
+type LifecycleFunction<T> = (params?: any) => void;
+interface Entity<T = any> {
+    setup: (entity: T) => void;
+    destroy: () => void;
+    update: LifecycleFunction<T>;
+    type: string;
+    _collision?: (entity: any, other: any, globals?: any) => void;
+    _destroy?: (globals?: any) => void;
+    name?: string;
+    tag?: Set<string>;
+}
+interface StageEntity extends Entity {
+    uuid: string;
+    body: RigidBody;
+    group: Group;
+    mesh: Mesh;
+    instanceId: number;
+    collider: Collider;
+    controlledRotation: boolean;
+    characterController: KinematicCharacterController;
+    name: string;
+    markedForRemoval: boolean;
+}
+
+export type { Entity as E, LifecycleFunction as L, StageEntity as S };

package/dist/entity-types-DAu8sGJH.d.ts

@@ -0,0 +1,26 @@
+import { Group } from 'three';
+import { RigidBody, Collider } from '@dimforge/rapier3d-compat';
+
+/**
+ * Base entity interface - shared across modules to prevent circular dependencies
+ */
+interface BaseEntityInterface {
+    uuid: string;
+    name: string;
+    eid: number;
+    group: Group | null | undefined;
+    body: RigidBody | null | undefined;
+    collider: Collider | null | undefined;
+}
+/**
+ * Game entity interface - minimal interface to break circular dependencies
+ */
+interface GameEntityInterface extends BaseEntityInterface {
+    type: string;
+    isStatic: boolean;
+    setPosition(x: number, y: number, z: number): void;
+    setRotation(x: number, y: number, z: number): void;
+    setScale(x: number, y: number, z: number): void;
+}
+
+export type { BaseEntityInterface as B, GameEntityInterface as G };

package/dist/main.d.ts

@@ -1,13 +1,13 @@
-import { G as Game } from './core-C2mjetAd.js';
-export { V as Vect3, Z as ZylemGameConfig, c as createGame, g as gameConfig, a as globalChange, b as globalChanges, d as variableChange, e as variableChanges, v as vessel } from './core-C2mjetAd.js';
-export { S as StageOptions, c as createStage } from './stage-CrmY7V0i.js';
-export { e as entitySpawner } from './entity-spawner-DNnLYnZq.js';
-export { P as PerspectiveType, a as Perspectives, c as camera } from './camera-Dk-fOVZE.js';
-export { ZylemBox, actor, box, plane, rect, sphere, sprite, text, zone } from './entities.js';
-import { U as UpdateContext, B as BehaviorCallbackType } from './entity-bQElAdpo.js';
-export { a as Behavior, L as LoadingEvent } from './entity-bQElAdpo.js';
-export { boundary2d, ricochet2DCollision, ricochet2DInBounds } from './behaviors.js';
-import { M as MoveableEntity } from './moveable-B_vyA6cw.js';
+import { G as Game } from './core-bO8TzV7u.js';
+export { V as Vect3, Z as ZylemGameConfig, c as createGame, g as gameConfig, a as globalChange, b as globalChanges, d as variableChange, e as variableChanges, v as vessel } from './core-bO8TzV7u.js';
+export { a as StageOptions, d as createDisk, c as createStage } from './stage-types-Bd-KtcYT.js';
+import { S as StageBlueprint } from './blueprints-Cq3Ko6_G.js';
+export { e as entitySpawner } from './blueprints-Cq3Ko6_G.js';
+export { P as PerspectiveType, d as Perspectives, c as createCamera } from './camera-CeJPAgGg.js';
+export { A as ACTOR_TYPE, B as BOX_TYPE, P as PLANE_TYPE, R as RECT_TYPE, a as SPHERE_TYPE, S as SPRITE_TYPE, T as TEXT_TYPE, g as ZONE_TYPE, e as ZylemBox, o as createActor, j as createBox, m as createPlane, q as createRect, k as createSphere, l as createSprite, p as createText, n as createZone } from './entities-DvByhMGU.js';
+import { G as GameEntity, g as GameEntityOptions } from './world-C8tQ7Plj.js';
+export { q as BehaviorDescriptor, s as BehaviorHandle, r as BehaviorRef, e as BehaviorSystem, f as BehaviorSystemFactory, t as DefineBehaviorConfig, o as EntityConfigPayload, k as EntityEvents, E as EventEmitterDelegate, j as GameEvents, l as GameLoadingPayload, L as LoadingEvent, a as SetupContext, n as StageConfigPayload, h as StageEvents, m as StateDispatchPayload, b as UpdateContext, i as ZylemEvents, Z as ZylemShaderObject, p as defineBehavior, z as zylemEventBus } from './world-C8tQ7Plj.js';
+export { Behavior, BoundaryRicochetCoordinator, MovementSequence2DBehavior, MovementSequence2DCurrentStep, MovementSequence2DEvent, MovementSequence2DFSM, MovementSequence2DHandle, MovementSequence2DMovement, MovementSequence2DOptions, MovementSequence2DProgress, MovementSequence2DState, MovementSequence2DStep, PhysicsBodyComponent, PhysicsStepBehavior, PhysicsSyncBehavior, PlayerInput, Ricochet2DBehavior, Ricochet2DCollisionContext, Ricochet2DEvent, Ricochet2DFSM, Ricochet2DHandle, Ricochet2DOptions, Ricochet2DResult, Ricochet2DState, ScreenWrapBehavior, ScreenWrapEvent, ScreenWrapFSM, ScreenWrapOptions, ScreenWrapState, ThrusterBehavior, ThrusterBehaviorOptions, ThrusterEntity, ThrusterEvent, ThrusterFSM, ThrusterFSMContext, ThrusterInputComponent, ThrusterMovementBehavior, ThrusterMovementComponent, ThrusterState, ThrusterStateComponent, TransformComponent, WorldBoundary2DBehavior, WorldBoundary2DBounds, WorldBoundary2DEvent, WorldBoundary2DFSM, WorldBoundary2DHandle, WorldBoundary2DHit, WorldBoundary2DHits, WorldBoundary2DOptions, WorldBoundary2DPosition, WorldBoundary2DState, computeWorldBoundary2DHits, createPhysicsBodyComponent, createThrusterInputComponent, createThrusterMovementComponent, createThrusterStateComponent, createTransformComponent, hasAnyWorldBoundary2DHit, useBehavior } from './behaviors.js';
 export { m as makeMoveable, b as move, a as moveable, r as resetVelocity } from './moveable-B_vyA6cw.js';
 export { m as makeRotatable, a as makeTransformable, r as rotatable, b as rotateInDirection } from './transformable-CUhvyuYO.js';
 export { Howl } from 'howler';
@@ -15,30 +15,75 @@ import * as three from 'three';
 export { three as THREE };
 import * as RAPIER from '@dimforge/rapier3d-compat';
 export { RAPIER };
+export { S as StageEntity } from './entity-Bq_eNEDI.js';
 import 'bitecs';
-import 'three/addons/controls/OrbitControls.js';
+import './entity-types-DAu8sGJH.js';
+import '@sinclair/typebox';
 import 'three/examples/jsm/postprocessing/EffectComposer.js';
+import 'mitt';
+import 'typescript-fsm';
 
-interface MovementSequence2DStep {
-    name: string;
-    moveX?: number;
-    moveY?: number;
-    timeInSeconds: number;
-}
-interface MovementSequence2DOptions {
-    sequence: MovementSequence2DStep[];
-    loop?: boolean;
+declare const stageState: {
+    previous: StageBlueprint | null;
+    current: StageBlueprint | null;
+    next: StageBlueprint | null;
+    isLoading: boolean;
+};
+declare const StageManager: {
+    staticRegistry: Map<string, {
+        name?: string | undefined;
+        assets?: string[] | undefined;
+        id: string;
+        entities: {
+            position?: [number, number] | undefined;
+            data?: {
+                [x: string]: any;
+            } | undefined;
+            type: string;
+            id: string;
+        }[];
+    }>;
+    registerStaticStage(id: string, blueprint: StageBlueprint): void;
+    loadStageData(stageId: string): Promise<StageBlueprint>;
+    transitionForward(nextStageId: string, loadStaticStage?: (id: string) => Promise<StageBlueprint>): Promise<void>;
+    /**
+     * Manually set the next stage to pre-load it.
+     */
+    preloadNext(stageId: string, loadStaticStage?: (id: string) => Promise<StageBlueprint>): Promise<void>;
+};
+
+/**
+ * Factory interface for generating entity copies
+ */
+interface TemplateFactory<E extends GameEntity<O>, O extends GameEntityOptions = GameEntityOptions> {
+    /** The template entity used for cloning */
+    readonly template: E;
+    /**
+     * Generate multiple copies of the template entity
+     * @param count Number of copies to generate
+     * @returns Array of new entity instances
+     */
+    generate(count: number): E[];
 }
-type MovementSequence2DCallback = (current: MovementSequence2DStep, index: number, ctx: UpdateContext<MoveableEntity>) => void;
 /**
- * Behavior that sequences 2D movements over time.
- * Each step sets linear velocity via `moveXY` for a duration, then advances.
- * Defaults to looping when the end is reached.
+ * Create an entity factory from a template entity.
+ *
+ * @param template The entity to use as a template for cloning
+ * @returns Factory object with generate() method
+ *
+ * @example
+ * ```typescript
+ * const asteroidTemplate = createSprite({ images: [{ name: 'asteroid', file: asteroidImg }] });
+ * const asteroidFactory = createEntityFactory(asteroidTemplate);
+ * const asteroids = asteroidFactory.generate(10);
+ *
+ * asteroids.forEach((asteroid, i) => {
+ *     asteroid.setPosition(Math.random() * 20 - 10, Math.random() * 15 - 7.5, 0);
+ *     stage.add(asteroid);
+ * });
+ * ```
  */
-declare function movementSequence2D(opts: MovementSequence2DOptions, onStep?: MovementSequence2DCallback): {
-    type: BehaviorCallbackType;
-    handler: (ctx: UpdateContext<MoveableEntity>) => void;
-};
+declare function createEntityFactory<E extends GameEntity<O>, O extends GameEntityOptions = GameEntityOptions>(template: E): TemplateFactory<E, O>;
 
 declare function destroy(entity: any, globals?: any): void;
 
@@ -54,6 +99,7 @@ declare function pingPongBeep(frequency?: number, duration?: number): void;
 
 /**
  * Set a global value by path.
+ * Emits a 'game:state:updated' event when the value changes.
  * @example setGlobal('score', 100)
  * @example setGlobal('player.health', 50)
  */
@@ -74,14 +120,15 @@ declare function createGlobal<T>(path: string, defaultValue: T): T;
 declare function getGlobal<T = unknown>(path: string): T | undefined;
 /**
  * Subscribe to changes on a global value at a specific path.
- * Returns an unsubscribe function.
+ * Returns an unsubscribe function. Subscriptions are automatically
+ * cleaned up when the game is disposed.
  * @example const unsub = onGlobalChange('score', (val) => console.log(val));
  */
 declare function onGlobalChange<T = unknown>(path: string, callback: (value: T) => void): () => void;
 /**
  * Subscribe to changes on multiple global paths.
  * Callback fires when any of the paths change, receiving all current values.
- * Returns an unsubscribe function.
+ * Subscriptions are automatically cleaned up when the game is disposed.
  * @example const unsub = onGlobalChanges(['score', 'lives'], ([score, lives]) => console.log(score, lives));
  */
 declare function onGlobalChanges<T extends unknown[] = unknown[]>(paths: string[], callback: (values: T) => void): () => void;
@@ -89,6 +136,11 @@ declare function onGlobalChanges<T extends unknown[] = unknown[]>(paths: string[
  * Get the entire globals object (read-only snapshot).
  */
 declare function getGlobals<T = Record<string, unknown>>(): T;
+/**
+ * Unsubscribe all active global subscriptions.
+ * Used internally on game dispose to prevent old callbacks from firing.
+ */
+declare function clearGlobalSubscriptions(): void;
 
 /**
  * Set a variable on an object by path.
@@ -123,13 +175,77 @@ declare function onVariableChange<T = unknown>(target: object, path: string, cal
  */
 declare function onVariableChanges<T extends unknown[] = unknown[]>(target: object, paths: string[], callback: (values: T) => void): () => void;
 
+type DebugTools = 'select' | 'translate' | 'rotate' | 'scale' | 'delete' | 'none';
+interface DebugState {
+    enabled: boolean;
+    paused: boolean;
+    tool: DebugTools;
+    selectedEntity: GameEntity<any> | null;
+    hoveredEntity: GameEntity<any> | null;
+    flags: Set<string>;
+}
+declare const debugState: DebugState;
+declare function setPaused(paused: boolean): void;
+declare function setDebugTool(tool: DebugTools): void;
+
+/**
+ * State interface for editor-to-game communication
+ */
+interface ZylemGameState {
+    gameState?: {
+        debugFlag?: boolean;
+        [key: string]: unknown;
+    };
+    toolbarState?: {
+        tool?: DebugTools;
+        paused?: boolean;
+    };
+    [key: string]: unknown;
+}
 declare class ZylemGameElement extends HTMLElement {
     private _game;
+    private _state;
     private container;
     constructor();
+    /**
+     * Focus the game container for keyboard input
+     */
+    focus(): void;
     set game(game: Game<any>);
     get game(): Game<any> | null;
+    set state(value: ZylemGameState);
+    get state(): ZylemGameState;
+    /**
+     * Sync the web component's state with the game-lib's internal debug state
+     */
+    private syncDebugState;
+    /**
+     * Sync toolbar state with game-lib's debug state
+     */
+    private syncToolbarState;
     disconnectedCallback(): void;
 }
 
-export { Game, ZylemGameElement, createGlobal, createVariable, destroy, getGlobal, getGlobals, getVariable, movementSequence2D, onGlobalChange, onGlobalChanges, onVariableChange, onVariableChanges, pingPongBeep, ricochetSound, setGlobal, setVariable };
+declare const fireShader: {
+    vertex: string;
+    fragment: string;
+};
+
+declare const starShader: {
+    vertex: string;
+    fragment: string;
+};
+
+declare const standardShader: {
+    vertex: string;
+    fragment: string;
+};
+
+declare const debugShader: {
+    vertex: string;
+    fragment: string;
+};
+
+declare const objectVertexShader = "\nuniform vec2 uvScale;\nvarying vec2 vUv;\n\nvoid main() {\n\tvUv = uv;\n\tvec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );\n\tgl_Position = projectionMatrix * mvPosition;\n}\n";
+
+export { type DebugTools, Game, StageBlueprint, StageManager, type TemplateFactory, ZylemGameElement, type ZylemGameState, clearGlobalSubscriptions, createEntityFactory, createGlobal, createVariable, debugShader, debugState, destroy, fireShader, getGlobal, getGlobals, getVariable, objectVertexShader, onGlobalChange, onGlobalChanges, onVariableChange, onVariableChanges, pingPongBeep, ricochetSound, setDebugTool, setGlobal, setPaused, setVariable, stageState, standardShader, starShader };