@zylem/game-lib 0.3.14

package/dist/lib/stage/zylem-stage.d.ts

@@ -0,0 +1,127 @@
+import { Color, Vector3 } from 'three';
+import { ZylemWorld } from '../collision/world';
+import { ZylemScene } from '../graphics/zylem-scene';
+import { Conditions } from '../interfaces/game';
+import { GameEntityInterface } from '../types/entity-types';
+import { SetupContext, UpdateContext, DestroyContext } from '../core/base-node-life-cycle';
+import { LifeCycleBase } from '../core/lifecycle-base';
+import { BaseNode } from '../core/base-node';
+import { Stage } from './stage';
+import { ZylemCamera } from '../camera/zylem-camera';
+import { CameraWrapper } from '../camera/camera';
+import { StageDebugDelegate } from './stage-debug-delegate';
+import { BaseEntityInterface } from '../types/entity-types';
+export interface ZylemStageConfig {
+    inputs: Record<string, string[]>;
+    backgroundColor: Color;
+    backgroundImage: string | null;
+    gravity: Vector3;
+    variables: Record<string, any>;
+    conditions?: Conditions<any>[];
+    stageRef?: Stage;
+}
+type NodeLike = {
+    create: Function;
+};
+type StageEntityInput = NodeLike | Promise<any> | (() => NodeLike | Promise<any>);
+export type StageOptions = Array<Partial<ZylemStageConfig> | CameraWrapper | StageEntityInput>;
+export type StageState = ZylemStageConfig & {
+    entities: GameEntityInterface[];
+};
+export declare const STAGE_TYPE = "Stage";
+/**
+ * ZylemStage orchestrates scene, physics world, entities, and lifecycle.
+ *
+ * Responsibilities:
+ * - Manage stage configuration (background, inputs, gravity, variables)
+ * - Initialize and own `ZylemScene` and `ZylemWorld`
+ * - Spawn, track, and remove entities; emit entity-added events
+ * - Drive per-frame updates and transform system
+ */
+export declare class ZylemStage extends LifeCycleBase<ZylemStage> {
+    type: string;
+    state: StageState;
+    gravity: Vector3;
+    world: ZylemWorld | null;
+    scene: ZylemScene | null;
+    conditions: Conditions<any>[];
+    children: Array<BaseNode>;
+    _childrenMap: Map<number, BaseNode>;
+    _removalMap: Map<number, BaseNode>;
+    private pendingEntities;
+    private pendingPromises;
+    private isLoaded;
+    _debugMap: Map<string, BaseNode>;
+    private entityAddedHandlers;
+    ecs: import("bitecs").IWorld;
+    testSystem: any;
+    transformSystem: any;
+    debugDelegate: StageDebugDelegate | null;
+    uuid: string;
+    wrapperRef: Stage | null;
+    camera?: CameraWrapper;
+    cameraRef?: ZylemCamera | null;
+    /**
+     * Create a new stage.
+     * @param options Stage options: partial config, camera, and initial entities or factories
+     */
+    constructor(options?: StageOptions);
+    private parseOptions;
+    private isZylemStageConfig;
+    private isBaseNode;
+    private isCameraWrapper;
+    private isEntityInput;
+    private isThenable;
+    private handleEntityImmediatelyOrQueue;
+    private handlePromiseWithSpawnOnResolve;
+    private saveState;
+    private setState;
+    /**
+     * Load and initialize the stage's scene and world.
+     * @param id DOM element id for the renderer container
+     * @param camera Optional camera override
+     */
+    load(id: string, camera?: ZylemCamera | null): Promise<void>;
+    private createDefaultCamera;
+    protected _setup(params: SetupContext<ZylemStage>): void;
+    protected _update(params: UpdateContext<ZylemStage>): void;
+    /** Update debug overlays and helpers if enabled. */
+    debugUpdate(): void;
+    /** Cleanup owned resources when the stage is destroyed. */
+    protected _destroy(params: DestroyContext<ZylemStage>): void;
+    /**
+     * Create, register, and add an entity to the scene/world.
+     * Safe to call only after `load` when scene/world exist.
+     */
+    spawnEntity(child: BaseNode): Promise<void>;
+    buildEntityState(child: BaseNode): Partial<BaseEntityInterface>;
+    /** Add the entity to internal maps and notify listeners. */
+    addEntityToStage(entity: BaseNode): void;
+    /**
+     * Subscribe to entity-added events.
+     * @param callback Invoked for each entity when added
+     * @param options.replayExisting If true and stage already loaded, replays existing entities
+     * @returns Unsubscribe function
+     */
+    onEntityAdded(callback: (entity: BaseNode) => void, options?: {
+        replayExisting?: boolean;
+    }): () => void;
+    /**
+     * Remove an entity and its resources by its UUID.
+     * @returns true if removed, false if not found or stage not ready
+     */
+    removeEntityByUuid(uuid: string): boolean;
+    /** Get an entity by its name; returns null if not found. */
+    getEntityByName(name: string): BaseNode<any, any> | null;
+    logMissingEntities(): void;
+    /** Resize renderer viewport. */
+    resize(width: number, height: number): void;
+    /**
+     * Enqueue items to be spawned. Items can be:
+     * - BaseNode instances (immediate or deferred until load)
+     * - Factory functions returning BaseNode or Promise<BaseNode>
+     * - Promises resolving to BaseNode
+     */
+    enqueue(...items: StageEntityInput[]): void;
+}
+export {};

package/dist/lib/systems/test-system.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/systems/transformable.system.d.ts

@@ -0,0 +1,24 @@
+import { StageEntity } from '../interfaces/entity';
+import RAPIER from '@dimforge/rapier3d-compat';
+export type StageSystem = {
+    _childrenMap: Map<number, StageEntity & {
+        body: RAPIER.RigidBody;
+    }>;
+};
+export declare const position: import("bitecs").ComponentType<{
+    x: "f32";
+    y: "f32";
+    z: "f32";
+}>;
+export declare const rotation: import("bitecs").ComponentType<{
+    x: "f32";
+    y: "f32";
+    z: "f32";
+    w: "f32";
+}>;
+export declare const scale: import("bitecs").ComponentType<{
+    x: "f32";
+    y: "f32";
+    z: "f32";
+}>;
+export default function createTransformSystem(stage: StageSystem): import("bitecs").System<[], import("bitecs").IWorld>;

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

@@ -0,0 +1,38 @@
+import { Group } from 'three';
+import { RigidBody, Collider } from '@dimforge/rapier3d-compat';
+/**
+ * Base entity interface - shared across modules to prevent circular dependencies
+ */
+export interface BaseEntityInterface {
+    uuid: string;
+    name: string;
+    eid: number;
+    group: Group | null;
+    body: RigidBody | null;
+    collider: Collider | null;
+}
+/**
+ * Game entity interface - minimal interface to break circular dependencies
+ */
+export 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;
+}
+/**
+ * Stage entity interface - for entities that can be part of a stage
+ */
+export interface StageEntityInterface extends GameEntityInterface {
+    stageId?: string;
+    isActive: boolean;
+}
+/**
+ * Entity with collision capabilities
+ */
+export interface CollisionEntityInterface extends GameEntityInterface {
+    onCollision?: (other: GameEntityInterface) => void;
+    onEnter?: (other: GameEntityInterface) => void;
+    onExit?: (other: GameEntityInterface) => void;
+}

package/dist/lib/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from './entity-types';
+export * from './stage-types';

package/dist/lib/types/stage-types.d.ts

@@ -0,0 +1,34 @@
+import { Color, Vector3 } from 'three';
+import { BaseEntityInterface } from './entity-types';
+/**
+ * Stage state interface - minimal to prevent circular dependencies
+ */
+export interface StageStateInterface {
+    backgroundColor: Color;
+    backgroundImage: string | null;
+    inputs: {
+        p1: string[];
+        p2: string[];
+    };
+    variables: Record<string, any>;
+    gravity: Vector3;
+    entities: Partial<BaseEntityInterface>[];
+    stageRef?: any;
+}
+/**
+ * Stage configuration interface
+ */
+export interface StageConfigInterface {
+    id?: string;
+    backgroundColor?: Color;
+    backgroundImage?: string;
+    gravity?: Vector3;
+}
+/**
+ * Minimal stage interface to break circular dependencies
+ */
+export interface StageInterface {
+    uuid: string;
+    children: any[];
+    state: StageStateInterface;
+}

package/dist/lib/ui/Debug.d.ts

@@ -0,0 +1 @@
+import './Debug.css';

package/dist/lib/ui/console/Console.d.ts

@@ -0,0 +1,6 @@
+import { type Component } from 'solid-js';
+import './Console.css';
+/**
+ * Console component for debug UI. Displays console messages and allows user input.
+ */
+export declare const Console: Component;

package/dist/lib/ui/debug-panel/AccordionMenu.d.ts

@@ -0,0 +1,6 @@
+import type { Component } from 'solid-js';
+import './AccordionMenu.css';
+/**
+ * Accordion menu for debug UI with multiple panels.
+ */
+export declare const AccordionMenu: Component;

package/dist/lib/ui/debug-panel/Menu.d.ts

@@ -0,0 +1,5 @@
+import type { Component } from 'solid-js';
+import './Menu.css';
+export declare const Menu: Component<{
+    onClose?: () => void;
+}>;

package/dist/lib/ui/debug-panel/sections/EntitiesSection.d.ts

@@ -0,0 +1,11 @@
+import { Component } from 'solid-js';
+import './EntitiesSection.css';
+import { BaseEntityInterface } from '~/lib/types';
+interface EntityRowProps {
+    entity: Partial<BaseEntityInterface>;
+    index: number;
+    hoveredUuid: string | null;
+}
+export declare const EntityRow: Component<EntityRowProps>;
+export declare const EntitiesSection: Component;
+export {};

package/dist/lib/ui/debug-panel/sections/GameSection.d.ts

@@ -0,0 +1,2 @@
+import type { Component } from 'solid-js';
+export declare const GameSection: Component;

package/dist/lib/ui/debug-panel/sections/StagesSection.d.ts

@@ -0,0 +1,2 @@
+import { Component } from 'solid-js';
+export declare const StagesSection: Component;

package/dist/lib/ui/debug-panel/sections/all.d.ts

@@ -0,0 +1,3 @@
+export * from './EntitiesSection';
+export * from './GameSection';
+export * from './StagesSection';

package/dist/lib/ui/toolbar/Toolbar.d.ts

@@ -0,0 +1,5 @@
+import type { Component } from 'solid-js';
+import './Toolbar.css';
+export declare const Toolbar: Component<{
+    onClose?: () => void;
+}>;