@zylem/behaviors 0.2.0

package/dist/ricochet-3d.d.ts

@@ -0,0 +1,116 @@
+import { S as SyncStateMachine } from './sync-state-machine-CZyspBpj.js';
+import { B as BaseEntityInterface } from './entity-types-CmtQ-IBp.js';
+import { a as BehaviorDescriptor } from './behavior-system-DYbx-x_-.js';
+import 'typescript-fsm';
+import 'three';
+import '@dimforge/rapier3d-compat';
+
+interface Ricochet3DResult {
+    velocity: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    speed: number;
+    normal: {
+        x: number;
+        y: number;
+        z: number;
+    };
+}
+interface Ricochet3DCollisionContext {
+    entity?: BaseEntityInterface;
+    otherEntity?: BaseEntityInterface;
+    selfVelocity?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    contact: {
+        normal?: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        position?: {
+            x: number;
+            y: number;
+            z: number;
+        };
+    };
+    selfPosition?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    otherPosition?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    otherSize?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+}
+declare enum Ricochet3DState {
+    Idle = "idle",
+    Ricocheting = "ricocheting"
+}
+declare enum Ricochet3DEvent {
+    StartRicochet = "start-ricochet",
+    EndRicochet = "end-ricochet"
+}
+type Ricochet3DCallback = (result: Ricochet3DResult) => void;
+declare class Ricochet3DFSM {
+    readonly machine: SyncStateMachine<Ricochet3DState, Ricochet3DEvent, never>;
+    private lastResult;
+    private lastUpdatedAtMs;
+    private currentTimeMs;
+    private listeners;
+    constructor();
+    addListener(callback: Ricochet3DCallback): () => void;
+    getState(): Ricochet3DState;
+    getLastResult(): Ricochet3DResult | null;
+    getLastUpdatedAtMs(): number | null;
+    setCurrentTimeMs(timeMs: number): void;
+    isOnCooldown(cooldownMs?: number): boolean;
+    resetCooldown(): void;
+    computeRicochet(ctx: Ricochet3DCollisionContext, options?: {
+        minSpeed?: number;
+        maxSpeed?: number;
+        speedMultiplier?: number;
+        reflectionMode?: 'simple' | 'angled';
+        maxAngleDeg?: number;
+    }): Ricochet3DResult | null;
+    clearRicochet(): void;
+    private emitToListeners;
+    private extractDataFromEntities;
+    private computeNormalFromPositions;
+    private normalizeVector;
+    private dot;
+    private computeBasicReflection;
+    private computeAngledDeflection;
+    private computeHitOffsetVector;
+    private getDominantAxis;
+    private applySpeedClamp;
+    private dispatch;
+}
+
+interface Ricochet3DOptions {
+    minSpeed: number;
+    maxSpeed: number;
+    speedMultiplier: number;
+    reflectionMode: 'simple' | 'angled';
+    maxAngleDeg: number;
+}
+interface Ricochet3DHandle {
+    getRicochet(ctx: Ricochet3DCollisionContext): Ricochet3DResult | null;
+    applyRicochet(ctx: Ricochet3DCollisionContext): boolean;
+    getLastResult(): Ricochet3DResult | null;
+    onRicochet(callback: Ricochet3DCallback): () => void;
+}
+declare const Ricochet3DBehavior: BehaviorDescriptor<Ricochet3DOptions, Ricochet3DHandle, unknown>;
+
+export { Ricochet3DBehavior, type Ricochet3DCallback, type Ricochet3DCollisionContext, Ricochet3DEvent, Ricochet3DFSM, type Ricochet3DHandle, type Ricochet3DOptions, type Ricochet3DResult, Ricochet3DState };

package/dist/ricochet-3d.js

@@ -0,0 +1,16 @@
+import {
+  Ricochet3DBehavior,
+  Ricochet3DEvent,
+  Ricochet3DFSM,
+  Ricochet3DState
+} from "./chunk-ARJWUNRE.js";
+import "./chunk-Y6UJOUE5.js";
+import "./chunk-4URF65BR.js";
+import "./chunk-EZNCCO4L.js";
+export {
+  Ricochet3DBehavior,
+  Ricochet3DEvent,
+  Ricochet3DFSM,
+  Ricochet3DState
+};
+//# sourceMappingURL=ricochet-3d.js.map

package/dist/ricochet-3d.js.map

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

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

@@ -0,0 +1,2 @@
+export { RUNTIME_WORLD_BOUNDARY_2D_BEHAVIOR_KEY as RUNTIME_BOUNDARY_2D_BEHAVIOR_KEY, RUNTIME_PONG_BALL_BEHAVIOR_KEY as RUNTIME_DYNAMIC_CIRCLE_BODY_2D_BEHAVIOR_KEY, RUNTIME_PADDLE_INPUT_2D_BEHAVIOR_KEY as RUNTIME_PLAYER_INPUT_2D_BEHAVIOR_KEY, RUNTIME_RICOCHET_2D_BEHAVIOR_KEY, RUNTIME_TRIGGER_REGION_2D_BEHAVIOR_KEY, RuntimeWorldBoundary2DBehavior as RuntimeBoundary2DBehavior, RuntimeWorldBoundary2DOptions as RuntimeBoundary2DOptions, RuntimePongBallBehavior as RuntimeDynamicCircleBody2DBehavior, RuntimePongBallHandle as RuntimeDynamicCircleBody2DHandle, RuntimePongBallOptions as RuntimeDynamicCircleBody2DOptions, RuntimePaddleInput2DBehavior as RuntimePlayerInput2DBehavior, RuntimePaddleInput2DOptions as RuntimePlayerInput2DOptions, RuntimeRicochet2DBehavior, RuntimeRicochet2DEvent, RuntimeRicochet2DHandle, RuntimeRicochet2DOptions, RuntimeTriggerRegion2DBehavior, RuntimeTriggerRegion2DEvent, RuntimeTriggerRegion2DHandle, RuntimeTriggerRegion2DOptions, bindRuntimePongBallHandle as bindRuntimeDynamicCircleBody2DHandle, emitRuntimeRicochet, emitRuntimeTriggerRegionEnter } from './runtime-pong.js';
+import './behavior-system-DYbx-x_-.js';

package/dist/runtime-2d.js

@@ -0,0 +1,32 @@
+import {
+  RUNTIME_PADDLE_INPUT_2D_BEHAVIOR_KEY,
+  RUNTIME_PONG_BALL_BEHAVIOR_KEY,
+  RUNTIME_RICOCHET_2D_BEHAVIOR_KEY,
+  RUNTIME_TRIGGER_REGION_2D_BEHAVIOR_KEY,
+  RUNTIME_WORLD_BOUNDARY_2D_BEHAVIOR_KEY,
+  RuntimePaddleInput2DBehavior,
+  RuntimePongBallBehavior,
+  RuntimeRicochet2DBehavior,
+  RuntimeTriggerRegion2DBehavior,
+  RuntimeWorldBoundary2DBehavior,
+  bindRuntimePongBallHandle,
+  emitRuntimeRicochet,
+  emitRuntimeTriggerRegionEnter
+} from "./chunk-2C3Z5GE7.js";
+import "./chunk-EZNCCO4L.js";
+export {
+  RUNTIME_WORLD_BOUNDARY_2D_BEHAVIOR_KEY as RUNTIME_BOUNDARY_2D_BEHAVIOR_KEY,
+  RUNTIME_PONG_BALL_BEHAVIOR_KEY as RUNTIME_DYNAMIC_CIRCLE_BODY_2D_BEHAVIOR_KEY,
+  RUNTIME_PADDLE_INPUT_2D_BEHAVIOR_KEY as RUNTIME_PLAYER_INPUT_2D_BEHAVIOR_KEY,
+  RUNTIME_RICOCHET_2D_BEHAVIOR_KEY,
+  RUNTIME_TRIGGER_REGION_2D_BEHAVIOR_KEY,
+  RuntimeWorldBoundary2DBehavior as RuntimeBoundary2DBehavior,
+  RuntimePongBallBehavior as RuntimeDynamicCircleBody2DBehavior,
+  RuntimePaddleInput2DBehavior as RuntimePlayerInput2DBehavior,
+  RuntimeRicochet2DBehavior,
+  RuntimeTriggerRegion2DBehavior,
+  bindRuntimePongBallHandle as bindRuntimeDynamicCircleBody2DHandle,
+  emitRuntimeRicochet,
+  emitRuntimeTriggerRegionEnter
+};
+//# sourceMappingURL=runtime-2d.js.map

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

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

package/dist/runtime-pong.d.ts

@@ -0,0 +1,92 @@
+import { a as BehaviorDescriptor, e as BehaviorRef } from './behavior-system-DYbx-x_-.js';
+
+interface RuntimePongBallOptions {
+    initialVelocity: readonly [number, number];
+}
+interface RuntimePongBallHandle {
+    setRuntimePosition(x: number, y: number, z?: number): void;
+    setRuntimeVelocity(x: number, y: number): void;
+    getRuntimePosition(): {
+        x: number;
+        y: number;
+        z: number;
+    } | null;
+}
+interface RuntimePaddleInput2DOptions {
+    player: 'p1' | 'p2';
+    speed: number;
+}
+interface RuntimeWorldBoundary2DOptions {
+    boundaries: {
+        left: number;
+        right: number;
+        bottom: number;
+        top: number;
+    };
+}
+interface RuntimeRicochet2DOptions {
+    minSpeed: number;
+    maxSpeed: number;
+    speedMultiplier: number;
+    reflectionMode: 'simple' | 'angled';
+    maxAngleDeg: number;
+}
+interface RuntimeRicochet2DEvent {
+    kind: 'wall' | 'paddle';
+}
+interface RuntimeRicochet2DHandle {
+    onRicochet(callback: (event: RuntimeRicochet2DEvent) => void): () => void;
+}
+/** Registers a gameplay2d trigger AABB (sensor); wasm reports overlap via {@link emitRuntimeTriggerRegionEnter}. */
+interface RuntimeTriggerRegion2DOptions {
+    triggerId: number;
+    halfExtents: readonly [number, number];
+}
+interface RuntimeTriggerRegion2DEvent {
+    triggerId: number;
+}
+interface RuntimeTriggerRegion2DHandle {
+    onRegionEnter(callback: (event: RuntimeTriggerRegion2DEvent) => void): () => void;
+}
+interface RuntimeGoalZone2DOptions {
+    scorer: 'p1' | 'p2';
+}
+interface RuntimeGoalZone2DEvent {
+    scorer: 'p1' | 'p2';
+}
+interface RuntimeGoalZone2DHandle {
+    onGoal(callback: (event: RuntimeGoalZone2DEvent) => void): () => void;
+}
+declare const RUNTIME_PONG_BALL_BEHAVIOR_KEY: unique symbol;
+declare const RUNTIME_PADDLE_INPUT_2D_BEHAVIOR_KEY: unique symbol;
+declare const RUNTIME_WORLD_BOUNDARY_2D_BEHAVIOR_KEY: unique symbol;
+declare const RUNTIME_RICOCHET_2D_BEHAVIOR_KEY: unique symbol;
+declare const RUNTIME_TRIGGER_REGION_2D_BEHAVIOR_KEY: unique symbol;
+declare const RUNTIME_GOAL_ZONE_2D_BEHAVIOR_KEY: unique symbol;
+declare const RuntimePongBallBehavior: BehaviorDescriptor<RuntimePongBallOptions, RuntimePongBallHandle, unknown>;
+declare const RuntimePaddleInput2DBehavior: BehaviorDescriptor<RuntimePaddleInput2DOptions, Record<string, never>, unknown>;
+declare const RuntimeWorldBoundary2DBehavior: BehaviorDescriptor<{
+    boundaries: {
+        left: number;
+        right: number;
+        bottom: number;
+        top: number;
+    };
+}, Record<string, never>, unknown>;
+declare const RuntimeRicochet2DBehavior: BehaviorDescriptor<RuntimeRicochet2DOptions, RuntimeRicochet2DHandle, unknown>;
+declare const RuntimeTriggerRegion2DBehavior: BehaviorDescriptor<RuntimeTriggerRegion2DOptions, RuntimeTriggerRegion2DHandle, unknown>;
+declare const RuntimeGoalZone2DBehavior: BehaviorDescriptor<RuntimeGoalZone2DOptions, RuntimeGoalZone2DHandle, unknown>;
+declare function emitRuntimeRicochet(ref: BehaviorRef<RuntimeRicochet2DOptions>, event: RuntimeRicochet2DEvent): void;
+declare function emitRuntimeTriggerRegionEnter(ref: BehaviorRef<RuntimeTriggerRegion2DOptions>, event: RuntimeTriggerRegion2DEvent): void;
+declare function emitRuntimeGoal(ref: BehaviorRef<RuntimeGoalZone2DOptions>, event: RuntimeGoalZone2DEvent): void;
+declare function bindRuntimePongBallHandle(ref: BehaviorRef<RuntimePongBallOptions>, controls: {
+    setPosition: (x: number, y: number, z: number) => void;
+    setVelocity: (x: number, y: number) => void;
+    getPosition: () => {
+        x: number;
+        y: number;
+        z: number;
+    } | null;
+}): void;
+
+export { RUNTIME_GOAL_ZONE_2D_BEHAVIOR_KEY, RUNTIME_PADDLE_INPUT_2D_BEHAVIOR_KEY, RUNTIME_PONG_BALL_BEHAVIOR_KEY, RUNTIME_RICOCHET_2D_BEHAVIOR_KEY, RUNTIME_TRIGGER_REGION_2D_BEHAVIOR_KEY, RUNTIME_WORLD_BOUNDARY_2D_BEHAVIOR_KEY, RuntimeGoalZone2DBehavior, type RuntimeGoalZone2DEvent, type RuntimeGoalZone2DHandle, type RuntimeGoalZone2DOptions, RuntimePaddleInput2DBehavior, type RuntimePaddleInput2DOptions, RuntimePongBallBehavior, type RuntimePongBallHandle, type RuntimePongBallOptions, RuntimeRicochet2DBehavior, type RuntimeRicochet2DEvent, type RuntimeRicochet2DHandle, type RuntimeRicochet2DOptions, RuntimeTriggerRegion2DBehavior, type RuntimeTriggerRegion2DEvent, type RuntimeTriggerRegion2DHandle, type RuntimeTriggerRegion2DOptions, RuntimeWorldBoundary2DBehavior, type RuntimeWorldBoundary2DOptions, bindRuntimePongBallHandle, emitRuntimeGoal, emitRuntimeRicochet, emitRuntimeTriggerRegionEnter };

package/dist/runtime-pong.js

@@ -0,0 +1,38 @@
+import {
+  RUNTIME_GOAL_ZONE_2D_BEHAVIOR_KEY,
+  RUNTIME_PADDLE_INPUT_2D_BEHAVIOR_KEY,
+  RUNTIME_PONG_BALL_BEHAVIOR_KEY,
+  RUNTIME_RICOCHET_2D_BEHAVIOR_KEY,
+  RUNTIME_TRIGGER_REGION_2D_BEHAVIOR_KEY,
+  RUNTIME_WORLD_BOUNDARY_2D_BEHAVIOR_KEY,
+  RuntimeGoalZone2DBehavior,
+  RuntimePaddleInput2DBehavior,
+  RuntimePongBallBehavior,
+  RuntimeRicochet2DBehavior,
+  RuntimeTriggerRegion2DBehavior,
+  RuntimeWorldBoundary2DBehavior,
+  bindRuntimePongBallHandle,
+  emitRuntimeGoal,
+  emitRuntimeRicochet,
+  emitRuntimeTriggerRegionEnter
+} from "./chunk-2C3Z5GE7.js";
+import "./chunk-EZNCCO4L.js";
+export {
+  RUNTIME_GOAL_ZONE_2D_BEHAVIOR_KEY,
+  RUNTIME_PADDLE_INPUT_2D_BEHAVIOR_KEY,
+  RUNTIME_PONG_BALL_BEHAVIOR_KEY,
+  RUNTIME_RICOCHET_2D_BEHAVIOR_KEY,
+  RUNTIME_TRIGGER_REGION_2D_BEHAVIOR_KEY,
+  RUNTIME_WORLD_BOUNDARY_2D_BEHAVIOR_KEY,
+  RuntimeGoalZone2DBehavior,
+  RuntimePaddleInput2DBehavior,
+  RuntimePongBallBehavior,
+  RuntimeRicochet2DBehavior,
+  RuntimeTriggerRegion2DBehavior,
+  RuntimeWorldBoundary2DBehavior,
+  bindRuntimePongBallHandle,
+  emitRuntimeGoal,
+  emitRuntimeRicochet,
+  emitRuntimeTriggerRegionEnter
+};
+//# sourceMappingURL=runtime-pong.js.map

package/dist/runtime-pong.js.map

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

package/dist/screen-visibility.d.ts

@@ -0,0 +1,74 @@
+import { a as BehaviorDescriptor, G as GameEntity } from './behavior-system-DYbx-x_-.js';
+
+interface ScreenVisibilitySnapshot {
+    initialized: boolean;
+    visible: boolean;
+    justEntered: boolean;
+    justExited: boolean;
+    visibleCameraNames: string[];
+}
+declare class ScreenVisibilityFSM {
+    private initialized;
+    private visible;
+    private justEntered;
+    private justExited;
+    private visibleCameraNames;
+    update(visible: boolean, visibleCameraNames: readonly string[]): void;
+    isInitialized(): boolean;
+    isVisible(): boolean;
+    wasJustEntered(): boolean;
+    wasJustExited(): boolean;
+    getVisibleCameraNames(): string[];
+    getState(): ScreenVisibilitySnapshot;
+}
+
+interface ScreenVisibilitySize {
+    x: number;
+    y: number;
+    z: number;
+}
+interface ScreenVisibilityChangeContext {
+    entity: GameEntity<any>;
+    visible: boolean;
+    wasVisible: boolean;
+    justEntered: boolean;
+    justExited: boolean;
+    visibleCameraNames: string[];
+    cameraName: string | null;
+}
+interface ScreenVisibilityOptions {
+    /**
+     * Restrict visibility checks to one active camera by name.
+     * When omitted, any active camera can make the entity visible.
+     */
+    cameraName: string | null;
+    /**
+     * Require the full entity bounds to remain inside the camera frustum.
+     * Defaults to partial visibility (any intersection counts).
+     */
+    requireFullyVisible: boolean;
+    /**
+     * Expand or shrink the computed bounds in world units.
+     * Positive values make visibility checks more generous.
+     */
+    padding: number;
+    /**
+     * Optional bounds to use when the entity has no renderable mesh/group.
+     * Falls back to the entity's configured size when available.
+     */
+    fallbackSize: ScreenVisibilitySize | null;
+    onChange?: (context: ScreenVisibilityChangeContext) => void;
+    onEnter?: (context: ScreenVisibilityChangeContext) => void;
+    onExit?: (context: ScreenVisibilityChangeContext) => void;
+}
+interface ScreenVisibilityHandle {
+    isVisible(): boolean;
+    isOffscreen(): boolean;
+    wasJustEntered(): boolean;
+    wasJustExited(): boolean;
+    getVisibleCameraNames(): string[];
+    getState(): ScreenVisibilitySnapshot | null;
+}
+declare const ScreenVisibilityBehavior: BehaviorDescriptor<ScreenVisibilityOptions, ScreenVisibilityHandle, unknown>;
+
+export { ScreenVisibilityBehavior, type ScreenVisibilityChangeContext, ScreenVisibilityFSM, type ScreenVisibilityHandle, type ScreenVisibilityOptions, type ScreenVisibilitySize, type ScreenVisibilitySnapshot };

package/dist/screen-visibility.js

@@ -0,0 +1,10 @@
+import {
+  ScreenVisibilityBehavior,
+  ScreenVisibilityFSM
+} from "./chunk-WOMHL23C.js";
+import "./chunk-EZNCCO4L.js";
+export {
+  ScreenVisibilityBehavior,
+  ScreenVisibilityFSM
+};
+//# sourceMappingURL=screen-visibility.js.map

package/dist/screen-visibility.js.map

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

package/dist/screen-wrap.d.ts

@@ -0,0 +1,86 @@
+import { a as BehaviorDescriptor } from './behavior-system-DYbx-x_-.js';
+import { S as SyncStateMachine } from './sync-state-machine-CZyspBpj.js';
+import 'typescript-fsm';
+
+/**
+ * ScreenWrapBehavior
+ *
+ * When an entity exits the defined 2D bounds, it wraps around to the opposite edge.
+ * Asteroids-style screen wrapping with FSM for edge detection.
+ */
+/**
+ * Screen wrap options (typed for entity.use() autocomplete)
+ */
+interface ScreenWrapOptions {
+    /** Width of the wrapping area (default: 20) */
+    width: number;
+    /** Height of the wrapping area (default: 15) */
+    height: number;
+    /** Center X position (default: 0) */
+    centerX: number;
+    /** Center Y position (default: 0) */
+    centerY: number;
+    /** Distance from edge to trigger NearEdge state (default: 2) */
+    edgeThreshold: number;
+}
+/**
+ * ScreenWrapBehavior - Wraps entities around 2D bounds
+ *
+ * @example
+ * ```typescript
+ * import { ScreenWrapBehavior } from "@zylem/game-lib/behavior";
+ *
+ * const ship = createSprite({ ... });
+ * const wrapRef = ship.use(ScreenWrapBehavior, { width: 20, height: 15 });
+ *
+ * // Access FSM to observe edge state
+ * const fsm = wrapRef.getFSM();
+ * console.log(fsm?.getState()); // 'center', 'near-edge-left', 'wrapped', etc.
+ * ```
+ */
+declare const ScreenWrapBehavior: BehaviorDescriptor<ScreenWrapOptions, Record<string, never>, unknown>;
+
+/**
+ * ScreenWrapFSM
+ *
+ * State machine for screen wrap behavior.
+ * Reports position relative to bounds edges.
+ */
+
+declare enum ScreenWrapState {
+    Center = "center",
+    NearEdgeLeft = "near-edge-left",
+    NearEdgeRight = "near-edge-right",
+    NearEdgeTop = "near-edge-top",
+    NearEdgeBottom = "near-edge-bottom",
+    Wrapped = "wrapped"
+}
+declare enum ScreenWrapEvent {
+    EnterCenter = "enter-center",
+    ApproachLeft = "approach-left",
+    ApproachRight = "approach-right",
+    ApproachTop = "approach-top",
+    ApproachBottom = "approach-bottom",
+    Wrap = "wrap"
+}
+declare class ScreenWrapFSM {
+    machine: SyncStateMachine<ScreenWrapState, ScreenWrapEvent, never>;
+    constructor();
+    getState(): ScreenWrapState;
+    dispatch(event: ScreenWrapEvent): void;
+    /**
+     * Update FSM based on entity position relative to bounds
+     */
+    update(position: {
+        x: number;
+        y: number;
+    }, bounds: {
+        minX: number;
+        maxX: number;
+        minY: number;
+        maxY: number;
+        edgeThreshold: number;
+    }, wrapped: boolean): void;
+}
+
+export { ScreenWrapBehavior, ScreenWrapEvent, ScreenWrapFSM, type ScreenWrapOptions, ScreenWrapState };

package/dist/screen-wrap.js

@@ -0,0 +1,16 @@
+import {
+  ScreenWrapBehavior,
+  ScreenWrapEvent,
+  ScreenWrapFSM,
+  ScreenWrapState
+} from "./chunk-XIJNE67Y.js";
+import "./chunk-KDY5N6J4.js";
+import "./chunk-4URF65BR.js";
+import "./chunk-EZNCCO4L.js";
+export {
+  ScreenWrapBehavior,
+  ScreenWrapEvent,
+  ScreenWrapFSM,
+  ScreenWrapState
+};
+//# sourceMappingURL=screen-wrap.js.map

package/dist/screen-wrap.js.map

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

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

@@ -0,0 +1,77 @@
+import { a as BehaviorDescriptor } from './behavior-system-DYbx-x_-.js';
+import { i as Vec3Input } from './vector-Bm65-FOG.js';
+import 'three';
+import '@dimforge/rapier3d-compat';
+
+interface Shooter2DStateComponent {
+    cooldownRemainingMs: number;
+}
+declare function createShooter2DStateComponent(): Shooter2DStateComponent;
+
+interface Shooter2DTarget {
+    x: number;
+    y: number;
+}
+interface Shooter2DStageLike {
+    add(...inputs: any[]): void;
+}
+interface Shooter2DProjectileEntity {
+    transformStore: {
+        velocity: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        dirty: {
+            velocity: boolean;
+        };
+    };
+    prependSetup(callback: (params: {
+        me: Shooter2DProjectileEntity;
+    }) => void): unknown;
+    setPosition(x: number, y: number, z: number): void;
+    setRotationZ(angle: number): void;
+}
+type Shooter2DProjectileFactory = () => Shooter2DProjectileEntity | Promise<Shooter2DProjectileEntity>;
+interface Shooter2DBehaviorOptions {
+    projectileFactory: Shooter2DProjectileFactory;
+    projectileSpeed: number;
+    cooldownMs?: number;
+    spawnOffset?: Shooter2DTarget;
+    rotateProjectile?: boolean;
+}
+interface Shooter2DSourceEntity {
+    body?: {
+        translation(): {
+            x: number;
+            y: number;
+            z: number;
+        };
+        rotation?: () => {
+            x: number;
+            y: number;
+            z: number;
+            w: number;
+        };
+    } | null;
+    options?: {
+        position?: Vec3Input;
+    };
+    topDownMovementState?: {
+        facingAngle: number;
+    };
+    shooter2dState?: Shooter2DStateComponent;
+    _rotation2DAngle?: number;
+}
+interface Shooter2DFireArgs {
+    source: Shooter2DSourceEntity;
+    stage: Shooter2DStageLike;
+    target: Shooter2DTarget;
+}
+interface Shooter2DHandle {
+    isReady(source: Shooter2DSourceEntity): boolean;
+    fire(args: Shooter2DFireArgs): Promise<Shooter2DProjectileEntity | null>;
+}
+declare const Shooter2DBehavior: BehaviorDescriptor<Shooter2DBehaviorOptions, Shooter2DHandle, Shooter2DSourceEntity>;
+
+export { Shooter2DBehavior, type Shooter2DBehaviorOptions, type Shooter2DFireArgs, type Shooter2DHandle, type Shooter2DProjectileFactory, type Shooter2DSourceEntity, type Shooter2DStageLike, type Shooter2DStateComponent, type Shooter2DTarget, createShooter2DStateComponent };

package/dist/shooter-2d.js

@@ -0,0 +1,12 @@
+import {
+  Shooter2DBehavior,
+  createShooter2DStateComponent
+} from "./chunk-STCCNLPC.js";
+import "./chunk-ID5QJYF5.js";
+import "./chunk-WWVD5DR5.js";
+import "./chunk-EZNCCO4L.js";
+export {
+  Shooter2DBehavior,
+  createShooter2DStateComponent
+};
+//# sourceMappingURL=shooter-2d.js.map

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

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