@zylem/game-lib 0.6.4 → 0.7.0

package/dist/world-C9zdyl5d.d.ts

@@ -0,0 +1,103 @@
+import { Group, Mesh, Vector3 } from 'three';
+import RAPIER, { RigidBody, Collider, KinematicCharacterController, World } from '@dimforge/rapier3d-compat';
+import { V as Vec3Components } from './material-Wz83vTTp.js';
+import { f as UpdateContext } from './base-node-life-cycle-CnJ-7zX-.js';
+import { G as GameEntity } from './entity-DNkYKfdp.js';
+
+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;
+    /** When true, a Rapier KinematicCharacterController is allocated on this entity. Opt-in; default false. */
+    useCharacterController?: boolean;
+    characterController: KinematicCharacterController;
+    name: string;
+    markedForRemoval: boolean;
+}
+
+/**
+ * Interface for entities that handle collision events.
+ */
+interface CollisionHandlerDelegate {
+    handlePostCollision(params: any): boolean;
+    handleIntersectionEvent(params: any): void;
+}
+/**
+ * Physics world wrapper.
+ *
+ * Owns a single Rapier world that lives on the main thread and is advanced
+ * with a fixed-timestep accumulator. The off-thread JS Web Worker physics
+ * path that previously sat alongside this implementation has been removed;
+ * the long-term off-main-thread story is the wasm runtime adapter, which
+ * sits behind {@link StageRuntimeAdapter} rather than inside this class.
+ */
+declare class ZylemWorld implements Entity<ZylemWorld> {
+    type: string;
+    world: World;
+    collisionMap: Map<string, GameEntity<any>>;
+    collisionBehaviorMap: Map<string, GameEntity<any>>;
+    _removalMap: Map<string, GameEntity<any>>;
+    private activeCollisionPairs;
+    private currentCollisionTimeMs;
+    /** Fixed timestep in seconds used for each physics step. */
+    readonly fixedTimestep: number;
+    /** Unprocessed time carried over between frames. */
+    private accumulator;
+    /** Maximum number of physics steps allowed per frame to prevent spiral-of-death. */
+    private static readonly MAX_STEPS_PER_FRAME;
+    /**
+     * Interpolation alpha (0..1) representing the fraction of an unprocessed
+     * timestep remaining after the last physics step. Can be used to interpolate
+     * rendering transforms between the previous and current physics state.
+     */
+    interpolationAlpha: number;
+    private readonly trackedDirectBodies;
+    static loadPhysics(gravity: Vector3 | Vec3Components): Promise<RAPIER.World>;
+    /**
+     * @param world The Rapier physics world instance.
+     * @param physicsRate Physics update rate in Hz (default 60).
+     */
+    constructor(world: World, physicsRate?: number);
+    addEntity(entity: any): void;
+    setForRemoval(entity: any): void;
+    destroyEntity(entity: GameEntity<any>): void;
+    setup(): void;
+    /**
+     * Advance the physics simulation using the fixed-timestep accumulator.
+     */
+    update(params: UpdateContext<any>): void;
+    private addEntityDirect;
+    private destroyEntityDirect;
+    private updateDirect;
+    private captureDirectBodyPreviousPoses;
+    private captureDirectBodyCurrentPoses;
+    private patchDirectBodyPoseTracking;
+    updatePostCollisionBehaviors(delta: number): void;
+    private processPendingRemovals;
+    private removeEntityFromTracking;
+    private pruneActiveCollisionPairs;
+    private collectCollisionPairsFromWorld;
+    private entityHasCollisionPhaseListener;
+    private processCollisionPairs;
+    private dispatchCollisionPhase;
+    private dispatchIntersectionDelegates;
+    destroy(): void;
+    private clearEntityPhysicsState;
+}
+
+export { type CollisionHandlerDelegate as C, type Entity as E, type LifecycleFunction as L, type StageEntity as S, ZylemWorld as Z };