@zylem/behaviors 0.2.0

package/dist/first-person.d.ts

@@ -0,0 +1,204 @@
+import { F as FirstPersonInputComponent, b as FirstPersonStateComponent, a as FirstPersonMovementComponent } from './components-qWwOsvwh.js';
+export { c as createFirstPersonInputComponent, d as createFirstPersonMovementComponent, e as createFirstPersonStateComponent } from './components-qWwOsvwh.js';
+import { S as SyncStateMachine } from './sync-state-machine-CZyspBpj.js';
+import { Vector3, Euler } from 'three';
+import { F as FirstPersonPerspective } from './first-person-perspective-C9Mptl0-.js';
+import { a as BehaviorDescriptor } from './behavior-system-DYbx-x_-.js';
+import { i as Vec3Input } from './vector-Bm65-FOG.js';
+import 'typescript-fsm';
+import '@dimforge/rapier3d-compat';
+
+/**
+ * First Person Controller Finite State Machine
+ *
+ * Manages state transitions for first-person movement:
+ * - Idle: Standing still
+ * - Walking: Moving at walk speed
+ * - Running: Moving at run/sprint speed
+ */
+
+/**
+ * First-person movement states
+ */
+declare enum FirstPersonState {
+    Idle = "idle",
+    Walking = "walking",
+    Running = "running"
+}
+/**
+ * Events that trigger state transitions
+ */
+declare enum FirstPersonEvent {
+    Walk = "walk",
+    Run = "run",
+    Stop = "stop"
+}
+/**
+ * Context for the FSM
+ */
+interface FirstPersonContext {
+    input: FirstPersonInputComponent;
+    state: FirstPersonStateComponent;
+}
+/**
+ * First Person Controller FSM
+ */
+declare class FirstPersonFSM {
+    private ctx;
+    machine: SyncStateMachine<FirstPersonState, FirstPersonEvent, never>;
+    constructor(ctx: FirstPersonContext);
+    /** Get the current state */
+    getState(): FirstPersonState;
+    /** Dispatch an event to the FSM */
+    dispatch(event: FirstPersonEvent): void;
+    /** Get the current yaw from context */
+    getYaw(): number;
+    /** Get the current pitch from context */
+    getPitch(): number;
+    /**
+     * Update FSM based on current input and state.
+     */
+    update(input: FirstPersonInputComponent, state: FirstPersonStateComponent): void;
+}
+
+/**
+ * First Person Controller Behavior System
+ *
+ * Handles first-person camera control and movement:
+ * - Reads input component for WASD movement and mouse look deltas
+ * - Drives a FirstPersonPerspective (yaw/pitch accumulation)
+ * - Writes velocity to transformStore (physics-based movement)
+ * - Syncs camera position from the entity's rigid body each frame
+ * - Positions an optional viewmodel entity relative to the camera
+ */
+
+/**
+ * Viewmodel configuration for an entity that follows the camera.
+ */
+interface ViewmodelConfig {
+    /** The entity whose visual group should be positioned relative to the camera. */
+    entity: any;
+    /** Offset from the eye position in camera-local space (right, down, forward). */
+    offset: Vector3;
+    /** Additional rotation applied to the viewmodel in local space (Euler angles in radians). */
+    rotation?: Euler;
+}
+/**
+ * Entity interface for first-person controller.
+ * Entities with this behavior have these components attached.
+ */
+interface FirstPersonEntity {
+    uuid: string;
+    body: any;
+    transformStore: any;
+    firstPerson: FirstPersonMovementComponent;
+    $fps: FirstPersonInputComponent;
+    firstPersonState: FirstPersonStateComponent;
+}
+/**
+ * First Person Controller Behavior
+ *
+ * Core movement + look system for first-person cameras.
+ * Reads from entity.$fps input component and drives a FirstPersonPerspective.
+ */
+declare class FirstPersonControllerBehavior {
+    private world;
+    private perspectives;
+    private viewmodels;
+    constructor(world: any);
+    /**
+     * Associate a FirstPersonPerspective with an entity (by uuid).
+     * Called once by the descriptor system when the behavior is initialized.
+     */
+    setPerspective(entityUuid: string, perspective: FirstPersonPerspective): void;
+    hasPerspective(entityUuid: string): boolean;
+    /**
+     * Attach a viewmodel (weapon/item) to an entity.
+     * The viewmodel entity's group will be positioned relative to the camera each frame.
+     */
+    setViewmodel(entityUuid: string, config: ViewmodelConfig): void;
+    hasViewmodel(entityUuid: string): boolean;
+    /**
+     * Update one first-person entity.
+     */
+    updateEntity(entity: any, _delta: number): void;
+    /**
+     * Update all first-person entities.
+     */
+    update(delta: number): void;
+    /**
+     * Position a viewmodel entity relative to the camera's eye position and rotation.
+     *
+     * The physics transform system overwrites group.position from the rigid body
+     * each frame, so we must also move the body to keep them in sync.
+     */
+    private positionViewmodel;
+    /** Cleanup */
+    destroy(): void;
+}
+
+/**
+ * First-person controller behavior options (typed for entity.use() autocomplete).
+ */
+interface FirstPersonControllerOptions {
+    /** Base walking speed (default: 8) */
+    walkSpeed?: number;
+    /** Sprint/run speed (default: 16) */
+    runSpeed?: number;
+    /** Look sensitivity multiplier (default: 2) */
+    lookSensitivity?: number;
+    /** Eye height offset above entity position (default: 1.7) */
+    eyeHeight?: number;
+    /** The FirstPersonPerspective to drive (from camera.getPerspective()) */
+    perspective?: FirstPersonPerspective;
+    /** Optional viewmodel (weapon/item) to position relative to the camera */
+    viewmodel?: {
+        entity: any;
+        offset: Vec3Input;
+        rotation?: Euler;
+    };
+}
+/**
+ * FirstPersonController - typed descriptor for first-person movement and camera control.
+ *
+ * Provides complete first-person controller including:
+ * - WASD movement relative to camera yaw
+ * - Mouse look driving a FirstPersonPerspective
+ * - Optional viewmodel positioning (weapon/item following camera)
+ * - Walk/run state tracking via FSM
+ *
+ * @example
+ * ```typescript
+ * import { FirstPersonController } from "@zylem/game-lib/behavior";
+ * import { createCamera, Perspectives, FirstPersonPerspective } from "@zylem/game-lib/core";
+ * import { createActor } from "@zylem/game-lib/entity";
+ *
+ * const fpsCamera = createCamera({ perspective: Perspectives.FirstPerson, ... });
+ * const fps = fpsCamera.getPerspective<FirstPersonPerspective>();
+ *
+ * const player = createActor({ name: 'player', ... });
+ * const controller = player.use(FirstPersonController, {
+ *   perspective: fps,
+ *   walkSpeed: 8,
+ *   runSpeed: 16,
+ *   lookSensitivity: 2,
+ * });
+ *
+ * // In update loop - write input, behavior handles the rest
+ * player.onUpdate(({ inputs }) => {
+ *   player.$fps.moveX = inputs.p1.axes.Horizontal.value;
+ *   player.$fps.moveZ = inputs.p1.axes.Vertical.value;
+ *   player.$fps.lookX = inputs.p1.axes.SecondaryHorizontal.value;
+ *   player.$fps.lookY = inputs.p1.axes.SecondaryVertical.value;
+ *   player.$fps.sprint = inputs.p1.shoulders.LTrigger.held > 0;
+ * });
+ * ```
+ */
+declare const FirstPersonController: BehaviorDescriptor<FirstPersonControllerOptions, {
+    getState: () => FirstPersonState;
+    getYaw: () => number;
+    getPitch: () => number;
+    attachViewmodel: (entity: any, offset: Vec3Input) => void;
+}, FirstPersonEntity>;
+
+export { type FirstPersonContext, FirstPersonController, FirstPersonControllerBehavior, type FirstPersonControllerOptions, type FirstPersonEntity, FirstPersonEvent, FirstPersonFSM, FirstPersonInputComponent, FirstPersonMovementComponent, FirstPersonState, FirstPersonStateComponent, type ViewmodelConfig };

package/dist/first-person.js

@@ -0,0 +1,27 @@
+import {
+  FirstPersonController,
+  FirstPersonControllerBehavior,
+  FirstPersonEvent,
+  FirstPersonFSM,
+  FirstPersonState
+} from "./chunk-YUO6SKJD.js";
+import {
+  createFirstPersonInputComponent,
+  createFirstPersonMovementComponent,
+  createFirstPersonStateComponent
+} from "./chunk-LD5SMIB3.js";
+import "./chunk-WWVD5DR5.js";
+import "./chunk-RTVRUNYR.js";
+import "./chunk-4URF65BR.js";
+import "./chunk-EZNCCO4L.js";
+export {
+  FirstPersonController,
+  FirstPersonControllerBehavior,
+  FirstPersonEvent,
+  FirstPersonFSM,
+  FirstPersonState,
+  createFirstPersonInputComponent,
+  createFirstPersonMovementComponent,
+  createFirstPersonStateComponent
+};
+//# sourceMappingURL=first-person.js.map

package/dist/first-person.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/index.d.ts

@@ -0,0 +1,40 @@
+export { a as BehaviorDescriptor, d as BehaviorHandle, e as BehaviorRef, f as BehaviorSystem, h as BehaviorSystemFactory, D as DefineBehaviorConfig, p as defineBehavior } from './behavior-system-DYbx-x_-.js';
+export { u as useBehavior } from './use-behavior-D_82jAL3.js';
+export { P as PhysicsBodyComponent, T as TransformComponent, c as createPhysicsBodyComponent, a as createTransformComponent } from './components-BWG1GkZA.js';
+export { T as ThrusterInputComponent, a as ThrusterMovementComponent, b as ThrusterStateComponent, c as createThrusterInputComponent, d as createThrusterMovementComponent, e as createThrusterStateComponent } from './components-B29WHGQN.js';
+export { Behavior, PlayerInput, ThrusterBehavior, ThrusterBehaviorOptions, ThrusterEntity, ThrusterEvent, ThrusterFSM, ThrusterFSMContext, ThrusterMovementBehavior, ThrusterState } from './thruster.js';
+export { T as TopDownMovementComponent, a as TopDownMovementInputComponent, b as TopDownMovementStateComponent, c as createTopDownMovementComponent, d as createTopDownMovementInputComponent, e as createTopDownMovementStateComponent } from './components-XCpL6IYt.js';
+export { TopDownMovementBehavior, TopDownMovementBehaviorOptions, TopDownMovementEntity, TopDownMovementHandle, TopDownMovementRuntimeBehavior } from './top-down-movement.js';
+export { Shooter2DBehavior, Shooter2DBehaviorOptions, Shooter2DFireArgs, Shooter2DHandle, Shooter2DProjectileFactory, Shooter2DSourceEntity, Shooter2DStageLike, Shooter2DStateComponent, Shooter2DTarget, createShooter2DStateComponent } from './shooter-2d.js';
+export { ScreenWrapBehavior, ScreenWrapEvent, ScreenWrapFSM, ScreenWrapOptions, ScreenWrapState } from './screen-wrap.js';
+export { ScreenVisibilityBehavior, ScreenVisibilityChangeContext, ScreenVisibilityFSM, ScreenVisibilityHandle, ScreenVisibilityOptions, ScreenVisibilitySize, ScreenVisibilitySnapshot } from './screen-visibility.js';
+export { WorldBoundary2DBehavior, WorldBoundary2DBounds, WorldBoundary2DEvent, WorldBoundary2DFSM, WorldBoundary2DHandle, WorldBoundary2DHit, WorldBoundary2DHits, WorldBoundary2DOptions, WorldBoundary2DPosition, WorldBoundary2DState, computeWorldBoundary2DHits, hasAnyWorldBoundary2DHit } from './world-boundary-2d.js';
+export { WorldBoundary3DBehavior, WorldBoundary3DBounds, WorldBoundary3DEvent, WorldBoundary3DFSM, WorldBoundary3DHandle, WorldBoundary3DHit, WorldBoundary3DHits, WorldBoundary3DOptions, WorldBoundary3DPosition, WorldBoundary3DState, computeWorldBoundary3DHits, hasAnyWorldBoundary3DHit } from './world-boundary-3d.js';
+export { Ricochet2DBehavior, Ricochet2DCollisionContext, Ricochet2DEvent, Ricochet2DFSM, Ricochet2DHandle, Ricochet2DOptions, Ricochet2DResult, Ricochet2DState, RicochetCallback } from './ricochet-2d.js';
+export { Ricochet3DBehavior, Ricochet3DCallback, Ricochet3DCollisionContext, Ricochet3DEvent, Ricochet3DFSM, Ricochet3DHandle, Ricochet3DOptions, Ricochet3DResult, Ricochet3DState } from './ricochet-3d.js';
+export { Platformer3DBehavior, Platformer3DBehaviorOptions, Platformer3DContext, Platformer3DEntity, Platformer3DEvent, Platformer3DFSM, Platformer3DInputComponent, Platformer3DMovementBehavior, Platformer3DMovementComponent, Platformer3DState, Platformer3DStateComponent, PlatformerCollisionContext, createPlatformer3DInputComponent, createPlatformer3DMovementComponent, createPlatformer3DStateComponent } from './platformer-3d.js';
+export { F as FirstPersonInputComponent, a as FirstPersonMovementComponent, b as FirstPersonStateComponent, c as createFirstPersonInputComponent, d as createFirstPersonMovementComponent, e as createFirstPersonStateComponent } from './components-qWwOsvwh.js';
+export { FirstPersonContext, FirstPersonController, FirstPersonControllerBehavior, FirstPersonControllerOptions, FirstPersonEntity, FirstPersonEvent, FirstPersonFSM, FirstPersonState, ViewmodelConfig } from './first-person.js';
+export { J as JumpConfig3D, a as JumpContext3D, b as JumpInput3D, c as JumpState3D, V as Vec3Like, d as createJumpConfig3D, e as createJumpInput3D, f as createJumpState3D } from './components--hjBMTnz.js';
+export { Jumper3D, Jumper3DBehavior, Jumper3DBehaviorOptions, Jumper3DEntity, Jumper3DEvent, Jumper3DFSM, Jumper3DState, JumperTickEvent, JumperTickResult } from './jumper-3d.js';
+export { JumpConfig2D, JumpContext2D, JumpInput2D, JumpState2D, Jumper2D, Jumper2DBehavior, Jumper2DBehaviorOptions, Jumper2DEntity, Jumper2DEvent, Jumper2DFSM, Jumper2DState, Jumper2DTickEvent, Jumper2DTickResult, createJumpConfig2D, createJumpInput2D, createJumpState2D } from './jumper-2d.js';
+export { CooldownBehavior, CooldownConfig, CooldownEntry, CooldownHandle, CooldownOptions, fireCooldown, getCooldown, getCooldownStore, registerCooldown, resetCooldown, tickCooldowns } from './cooldown.js';
+export { Destructible3DBehavior, Destructible3DBehaviorOptions, Destructible3DColliderOptions, Destructible3DFragmentColliderShape, Destructible3DFragmentPhysicsOptions, Destructible3DHandle, FractureOptionsInput } from './destructible-3d.js';
+export { DestructibleMesh, FractureOptions, VoronoiOptions } from '@dgreenheck/three-pinata';
+export { D as DestructiblePrebakeWorkerAPI, P as PlainBufferGeometryPayload, a as PlainFractureOptions, c as PrebakeWorkerRequest, d as PrebakeWorkerResponse } from './payload-BQzu-oY_.js';
+export { BurstParticlePresetOptions, ParticleEmitterBehavior, ParticleEmitterBehaviorOptions, ParticleEmitterHandle, particlePresets } from './particle-emitter.js';
+export { BoundaryRicochetCoordinator } from './coordinators/boundary-ricochet.js';
+export { BoundaryRicochet3DCoordinator } from './coordinators/boundary-ricochet-3d.js';
+export { FirstPersonShooterCoordinator, FirstPersonShooterInput } from './coordinators/first-person-shooter.js';
+export { TopDownShooterCoordinator, TopDownShooterInput } from './coordinators/top-down-shooter.js';
+export { MultidirectionalSpaceShooterCoordinator, MultidirectionalSpaceShooterInput } from './coordinators/multidirectional-space-shooter.js';
+export { P as ParticleEffectDefinition, a as ParticleMagicAgency, b as ParticleMagicAlignment, c as ParticleMagicModifierInput, d as ParticleMagicModifierOptions, e as ParticleMagicOrder, f as ParticleMagicRealityEffect, g as ParticleMagicTemperament, h as ParticlePresetMaterialOptions, S as SemanticParticlePresetOptions, u as particleEffect } from './spark-DDlIg1nM.js';
+import '@dimforge/rapier3d-compat';
+import 'three';
+import './sync-state-machine-CZyspBpj.js';
+import 'typescript-fsm';
+import './vector-Bm65-FOG.js';
+import './entity-types-CmtQ-IBp.js';
+import './first-person-perspective-C9Mptl0-.js';
+import 'three.quarks';
+import './moveable-BCRpjAQb.js';

package/dist/index.js

@@ -0,0 +1,263 @@
+import {
+  FirstPersonShooterCoordinator
+} from "./chunk-VAN4WW3F.js";
+import {
+  MultidirectionalSpaceShooterCoordinator
+} from "./chunk-RTRVBEIB.js";
+import {
+  TopDownShooterCoordinator
+} from "./chunk-FPTWVCPN.js";
+import "./chunk-6C6NXNEW.js";
+import {
+  ScreenWrapBehavior,
+  ScreenWrapEvent,
+  ScreenWrapFSM,
+  ScreenWrapState
+} from "./chunk-XIJNE67Y.js";
+import {
+  Shooter2DBehavior,
+  createShooter2DStateComponent
+} from "./chunk-STCCNLPC.js";
+import {
+  ThrusterBehavior,
+  ThrusterEvent,
+  ThrusterFSM,
+  ThrusterMovementBehavior,
+  ThrusterState
+} from "./chunk-2CLT36VB.js";
+import {
+  createThrusterInputComponent,
+  createThrusterMovementComponent,
+  createThrusterStateComponent
+} from "./chunk-KS72RZHX.js";
+import {
+  TopDownMovementBehavior,
+  TopDownMovementRuntimeBehavior
+} from "./chunk-OYWFPIHF.js";
+import {
+  createTopDownMovementComponent,
+  createTopDownMovementInputComponent,
+  createTopDownMovementStateComponent
+} from "./chunk-EIWQM6U3.js";
+import "./chunk-ID5QJYF5.js";
+import {
+  WorldBoundary2DBehavior,
+  WorldBoundary2DEvent,
+  WorldBoundary2DFSM,
+  WorldBoundary2DState,
+  computeWorldBoundary2DHits,
+  hasAnyWorldBoundary2DHit
+} from "./chunk-XG2YMCJW.js";
+import {
+  WorldBoundary3DBehavior,
+  WorldBoundary3DEvent,
+  WorldBoundary3DFSM,
+  WorldBoundary3DState,
+  computeWorldBoundary3DHits,
+  hasAnyWorldBoundary3DHit
+} from "./chunk-4I6E6DGV.js";
+import {
+  BoundaryRicochetCoordinator
+} from "./chunk-GCNRXAKH.js";
+import "./chunk-KDY5N6J4.js";
+import {
+  BoundaryRicochet3DCoordinator
+} from "./chunk-3PYGRHAL.js";
+import "./chunk-OHCPV2NT.js";
+import {
+  ParticleEmitterBehavior,
+  particlePresets
+} from "./chunk-POZER3MQ.js";
+import {
+  particleEffect
+} from "./chunk-GYURWCIQ.js";
+import {
+  Platformer3DBehavior,
+  Platformer3DBehavior2,
+  Platformer3DEvent,
+  Platformer3DFSM,
+  Platformer3DState,
+  createPlatformer3DInputComponent,
+  createPlatformer3DMovementComponent,
+  createPlatformer3DStateComponent
+} from "./chunk-JAN34G6S.js";
+import {
+  Ricochet2DBehavior,
+  Ricochet2DEvent,
+  Ricochet2DFSM,
+  Ricochet2DState
+} from "./chunk-KOZUNIIE.js";
+import {
+  Ricochet3DBehavior,
+  Ricochet3DEvent,
+  Ricochet3DFSM,
+  Ricochet3DState
+} from "./chunk-ARJWUNRE.js";
+import {
+  ScreenVisibilityBehavior,
+  ScreenVisibilityFSM
+} from "./chunk-WOMHL23C.js";
+import {
+  createPhysicsBodyComponent,
+  createTransformComponent,
+  useBehavior
+} from "./chunk-UYFOLI2X.js";
+import "./chunk-Y6UJOUE5.js";
+import {
+  CooldownBehavior,
+  fireCooldown,
+  getCooldown,
+  getCooldownStore,
+  registerCooldown,
+  resetCooldown,
+  tickCooldowns
+} from "./chunk-K3UNLQ7W.js";
+import {
+  Destructible3DBehavior,
+  DestructibleMesh,
+  FractureOptions
+} from "./chunk-BXP4K7RF.js";
+import "./chunk-HZMY3TT4.js";
+import {
+  FirstPersonController,
+  FirstPersonControllerBehavior,
+  FirstPersonEvent,
+  FirstPersonFSM,
+  FirstPersonState
+} from "./chunk-YUO6SKJD.js";
+import {
+  createFirstPersonInputComponent,
+  createFirstPersonMovementComponent,
+  createFirstPersonStateComponent
+} from "./chunk-LD5SMIB3.js";
+import "./chunk-WWVD5DR5.js";
+import {
+  Jumper2D,
+  Jumper2DBehavior,
+  Jumper2DEvent,
+  Jumper2DFSM,
+  Jumper2DState,
+  Jumper2DTickEvent,
+  createJumpConfig2D,
+  createJumpInput2D,
+  createJumpState2D
+} from "./chunk-SS7ELMJ7.js";
+import {
+  Jumper3D,
+  Jumper3DBehavior,
+  Jumper3DEvent,
+  Jumper3DFSM,
+  Jumper3DState,
+  JumperTickEvent
+} from "./chunk-F3KRX2V4.js";
+import {
+  createJumpConfig3D,
+  createJumpInput3D,
+  createJumpState3D
+} from "./chunk-DYLH6K7B.js";
+import "./chunk-SVLNF434.js";
+import "./chunk-RTVRUNYR.js";
+import "./chunk-4URF65BR.js";
+import {
+  defineBehavior
+} from "./chunk-EZNCCO4L.js";
+export {
+  BoundaryRicochet3DCoordinator,
+  BoundaryRicochetCoordinator,
+  CooldownBehavior,
+  Destructible3DBehavior,
+  DestructibleMesh,
+  FirstPersonController,
+  FirstPersonControllerBehavior,
+  FirstPersonEvent,
+  FirstPersonFSM,
+  FirstPersonShooterCoordinator,
+  FirstPersonState,
+  FractureOptions,
+  Jumper2D,
+  Jumper2DBehavior,
+  Jumper2DEvent,
+  Jumper2DFSM,
+  Jumper2DState,
+  Jumper2DTickEvent,
+  Jumper3D,
+  Jumper3DBehavior,
+  Jumper3DEvent,
+  Jumper3DFSM,
+  Jumper3DState,
+  JumperTickEvent,
+  MultidirectionalSpaceShooterCoordinator,
+  ParticleEmitterBehavior,
+  Platformer3DBehavior2 as Platformer3DBehavior,
+  Platformer3DEvent,
+  Platformer3DFSM,
+  Platformer3DBehavior as Platformer3DMovementBehavior,
+  Platformer3DState,
+  Ricochet2DBehavior,
+  Ricochet2DEvent,
+  Ricochet2DFSM,
+  Ricochet2DState,
+  Ricochet3DBehavior,
+  Ricochet3DEvent,
+  Ricochet3DFSM,
+  Ricochet3DState,
+  ScreenVisibilityBehavior,
+  ScreenVisibilityFSM,
+  ScreenWrapBehavior,
+  ScreenWrapEvent,
+  ScreenWrapFSM,
+  ScreenWrapState,
+  Shooter2DBehavior,
+  ThrusterBehavior,
+  ThrusterEvent,
+  ThrusterFSM,
+  ThrusterMovementBehavior,
+  ThrusterState,
+  TopDownMovementBehavior,
+  TopDownMovementRuntimeBehavior,
+  TopDownShooterCoordinator,
+  WorldBoundary2DBehavior,
+  WorldBoundary2DEvent,
+  WorldBoundary2DFSM,
+  WorldBoundary2DState,
+  WorldBoundary3DBehavior,
+  WorldBoundary3DEvent,
+  WorldBoundary3DFSM,
+  WorldBoundary3DState,
+  computeWorldBoundary2DHits,
+  computeWorldBoundary3DHits,
+  createFirstPersonInputComponent,
+  createFirstPersonMovementComponent,
+  createFirstPersonStateComponent,
+  createJumpConfig2D,
+  createJumpConfig3D,
+  createJumpInput2D,
+  createJumpInput3D,
+  createJumpState2D,
+  createJumpState3D,
+  createPhysicsBodyComponent,
+  createPlatformer3DInputComponent,
+  createPlatformer3DMovementComponent,
+  createPlatformer3DStateComponent,
+  createShooter2DStateComponent,
+  createThrusterInputComponent,
+  createThrusterMovementComponent,
+  createThrusterStateComponent,
+  createTopDownMovementComponent,
+  createTopDownMovementInputComponent,
+  createTopDownMovementStateComponent,
+  createTransformComponent,
+  defineBehavior,
+  fireCooldown,
+  getCooldown,
+  getCooldownStore,
+  hasAnyWorldBoundary2DHit,
+  hasAnyWorldBoundary3DHit,
+  particleEffect,
+  particlePresets,
+  registerCooldown,
+  resetCooldown,
+  tickCooldowns,
+  useBehavior
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/jumper-2d.d.ts

@@ -0,0 +1,113 @@
+import { S as SyncStateMachine } from './sync-state-machine-CZyspBpj.js';
+import { a as BehaviorDescriptor } from './behavior-system-DYbx-x_-.js';
+import 'typescript-fsm';
+
+interface JumpConfig2D {
+    jumpHeight: number;
+    gravity: number;
+    maxFallSpeed?: number;
+    maxJumps: number;
+    resetJumpsOnGround: boolean;
+    coyoteTimeMs: number;
+    jumpBufferMs: number;
+    minTimeBetweenJumpsMs?: number;
+    variableJump?: {
+        enabled: boolean;
+        cutGravityMultiplier: number;
+        maxHoldMs?: number;
+    };
+}
+declare function createJumpConfig2D(options?: Partial<JumpConfig2D>): JumpConfig2D;
+interface JumpInput2D {
+    jumpPressed: boolean;
+    jumpHeld: boolean;
+    jumpReleased: boolean;
+    fastFall?: boolean;
+}
+declare function createJumpInput2D(): JumpInput2D;
+interface JumpContext2D {
+    dt: number;
+    velocityY: number;
+    isGrounded: boolean;
+    timeSinceGroundedMs: number;
+    setVerticalVelocity(y: number): void;
+}
+interface JumpState2D {
+    jumpsUsed: number;
+    lastJumpTimeMs: number;
+    bufferedJumpMs: number;
+    coyoteMs: number;
+    isJumping: boolean;
+    jumpHoldMs: number;
+    jumpCutApplied: boolean;
+}
+declare function createJumpState2D(): JumpState2D;
+
+declare enum Jumper2DTickEvent {
+    None = "none",
+    Jump = "jump",
+    Fall = "fall",
+    Land = "land"
+}
+interface Jumper2DTickResult {
+    event: Jumper2DTickEvent;
+}
+declare class Jumper2DBehavior {
+    tick(config: JumpConfig2D, input: JumpInput2D, ctx: JumpContext2D, state: JumpState2D): Jumper2DTickResult;
+}
+
+declare enum Jumper2DState {
+    Grounded = "grounded",
+    Jumping = "jumping",
+    Falling = "falling"
+}
+declare enum Jumper2DEvent {
+    Jump = "jump",
+    Fall = "fall",
+    Land = "land"
+}
+interface Jumper2DFSMContext {
+    state: JumpState2D;
+}
+declare class Jumper2DFSM {
+    private ctx;
+    machine: SyncStateMachine<Jumper2DState, Jumper2DEvent, never>;
+    constructor(ctx: Jumper2DFSMContext);
+    getState(): Jumper2DState;
+    dispatch(event: Jumper2DEvent): void;
+    isJumping(): boolean;
+    isGrounded(): boolean;
+    getJumpsUsed(): number;
+    applyTickEvent(tickEvent: string, isGrounded: boolean): void;
+}
+
+interface Jumper2DBehaviorOptions {
+    jumpHeight?: number;
+    gravity?: number;
+    maxFallSpeed?: number;
+    maxJumps?: number;
+    resetJumpsOnGround?: boolean;
+    coyoteTimeMs?: number;
+    jumpBufferMs?: number;
+    minTimeBetweenJumpsMs?: number;
+    variableJump?: JumpConfig2D['variableJump'];
+    groundRayLength?: number;
+    snapToGroundDistance?: number;
+    debugGroundProbe?: boolean;
+}
+interface Jumper2DEntity {
+    uuid: string;
+    body: any;
+    transformStore: any;
+    jumper2d: JumpConfig2D;
+    $jumper2d: JumpInput2D;
+    jumper2dState: JumpState2D;
+}
+declare const Jumper2D: BehaviorDescriptor<Jumper2DBehaviorOptions, {
+    getState: () => Jumper2DState;
+    isJumping: () => boolean;
+    getJumpsUsed: () => number;
+    getJumpsRemaining: () => number;
+}, Jumper2DEntity>;
+
+export { type JumpConfig2D, type JumpContext2D, type JumpInput2D, type JumpState2D, Jumper2D, Jumper2DBehavior, type Jumper2DBehaviorOptions, type Jumper2DEntity, Jumper2DEvent, Jumper2DFSM, Jumper2DState, Jumper2DTickEvent, type Jumper2DTickResult, createJumpConfig2D, createJumpInput2D, createJumpState2D };

package/dist/jumper-2d.js

@@ -0,0 +1,27 @@
+import {
+  Jumper2D,
+  Jumper2DBehavior,
+  Jumper2DEvent,
+  Jumper2DFSM,
+  Jumper2DState,
+  Jumper2DTickEvent,
+  createJumpConfig2D,
+  createJumpInput2D,
+  createJumpState2D
+} from "./chunk-SS7ELMJ7.js";
+import "./chunk-SVLNF434.js";
+import "./chunk-RTVRUNYR.js";
+import "./chunk-4URF65BR.js";
+import "./chunk-EZNCCO4L.js";
+export {
+  Jumper2D,
+  Jumper2DBehavior,
+  Jumper2DEvent,
+  Jumper2DFSM,
+  Jumper2DState,
+  Jumper2DTickEvent,
+  createJumpConfig2D,
+  createJumpInput2D,
+  createJumpState2D
+};
+//# sourceMappingURL=jumper-2d.js.map

package/dist/jumper-2d.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}