@zylem/game-lib 0.6.2 → 0.6.4

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

@@ -0,0 +1,711 @@
+// src/lib/behaviors/jumper-2d/components.ts
+function createJumpConfig2D(options = {}) {
+  return {
+    jumpHeight: options.jumpHeight ?? 2.5,
+    gravity: options.gravity ?? 20,
+    maxFallSpeed: options.maxFallSpeed,
+    maxJumps: options.maxJumps ?? 1,
+    resetJumpsOnGround: options.resetJumpsOnGround ?? true,
+    coyoteTimeMs: options.coyoteTimeMs ?? 100,
+    jumpBufferMs: options.jumpBufferMs ?? 80,
+    minTimeBetweenJumpsMs: options.minTimeBetweenJumpsMs,
+    variableJump: options.variableJump
+  };
+}
+function createJumpInput2D() {
+  return {
+    jumpPressed: false,
+    jumpHeld: false,
+    jumpReleased: false,
+    fastFall: false
+  };
+}
+function createJumpState2D() {
+  return {
+    jumpsUsed: 0,
+    lastJumpTimeMs: 0,
+    bufferedJumpMs: 0,
+    coyoteMs: 0,
+    isJumping: false,
+    jumpHoldMs: 0,
+    jumpCutApplied: false
+  };
+}
+
+// src/lib/behaviors/jumper-2d/jumper-2d.behavior.ts
+function jumpVelocityFromHeight(gravity, height) {
+  return Math.sqrt(2 * gravity * height);
+}
+var Jumper2DTickEvent = /* @__PURE__ */ ((Jumper2DTickEvent3) => {
+  Jumper2DTickEvent3["None"] = "none";
+  Jumper2DTickEvent3["Jump"] = "jump";
+  Jumper2DTickEvent3["Fall"] = "fall";
+  Jumper2DTickEvent3["Land"] = "land";
+  return Jumper2DTickEvent3;
+})(Jumper2DTickEvent || {});
+var Jumper2DBehavior = class {
+  tick(config, input, ctx, state) {
+    const dtMs = ctx.dt * 1e3;
+    const now = performance.now();
+    let event = "none" /* None */;
+    let jumpedThisFrame = false;
+    if (ctx.isGrounded) {
+      state.coyoteMs = config.coyoteTimeMs;
+      if (config.resetJumpsOnGround) {
+        state.jumpsUsed = 0;
+      }
+      if (state.isJumping) {
+        state.isJumping = false;
+        state.jumpCutApplied = false;
+        event = "land" /* Land */;
+      }
+    } else {
+      state.coyoteMs = Math.max(0, state.coyoteMs - dtMs);
+    }
+    if (input.jumpPressed) {
+      state.bufferedJumpMs = config.jumpBufferMs;
+    } else {
+      state.bufferedJumpMs = Math.max(0, state.bufferedJumpMs - dtMs);
+    }
+    if (state.isJumping && input.jumpHeld) {
+      state.jumpHoldMs += dtMs;
+    }
+    const wantsJump = state.bufferedJumpMs > 0;
+    const isFirstJump = ctx.isGrounded || state.coyoteMs > 0 && state.jumpsUsed === 0;
+    const hasAirJumps = state.jumpsUsed > 0 && state.jumpsUsed < config.maxJumps;
+    const canJump = isFirstJump || hasAirJumps;
+    const cooldownOk = config.minTimeBetweenJumpsMs == null || now - state.lastJumpTimeMs >= config.minTimeBetweenJumpsMs;
+    if (wantsJump && canJump && cooldownOk) {
+      ctx.setVerticalVelocity(jumpVelocityFromHeight(config.gravity, config.jumpHeight));
+      jumpedThisFrame = true;
+      state.jumpsUsed++;
+      state.lastJumpTimeMs = now;
+      state.bufferedJumpMs = 0;
+      state.coyoteMs = 0;
+      state.isJumping = true;
+      state.jumpHoldMs = 0;
+      state.jumpCutApplied = false;
+      event = "jump" /* Jump */;
+    }
+    if (!ctx.isGrounded || jumpedThisFrame) {
+      let gravityMul = 1;
+      const isFalling = ctx.velocityY < 0;
+      if (isFalling) {
+        gravityMul = input.fastFall ? 1.75 : 1;
+        if (event !== "land" /* Land */) {
+          event = "fall" /* Fall */;
+        }
+      } else if (state.isJumping) {
+        const variableJump = config.variableJump;
+        if (variableJump?.enabled && !state.jumpCutApplied) {
+          const holdExpired = variableJump.maxHoldMs != null && state.jumpHoldMs >= variableJump.maxHoldMs;
+          if (!input.jumpHeld || holdExpired) {
+            gravityMul = variableJump.cutGravityMultiplier;
+            state.jumpCutApplied = true;
+          }
+        }
+      }
+      let newVelocityY = ctx.velocityY - config.gravity * gravityMul * ctx.dt;
+      if (config.maxFallSpeed != null) {
+        newVelocityY = Math.max(-config.maxFallSpeed, newVelocityY);
+      }
+      ctx.setVerticalVelocity(newVelocityY);
+    } else {
+      ctx.setVerticalVelocity(0);
+    }
+    return { event };
+  }
+};
+
+// src/lib/core/utility/sync-state-machine.ts
+import {
+  StateMachine as BaseStateMachine
+} from "typescript-fsm";
+import { t } from "typescript-fsm";
+var SyncStateMachine = class extends BaseStateMachine {
+  constructor(init, transitions = [], logger = console) {
+    super(init, transitions, logger);
+  }
+  dispatch(_event, ..._args) {
+    throw new Error("SyncStateMachine does not support async dispatch.");
+  }
+  syncDispatch(event, ...args) {
+    const found = this.transitions.some((transition) => {
+      if (transition.fromState !== this._current || transition.event !== event) {
+        return false;
+      }
+      const current = this._current;
+      this._current = transition.toState;
+      if (!transition.cb) {
+        return true;
+      }
+      try {
+        transition.cb(...args);
+        return true;
+      } catch (error) {
+        this._current = current;
+        this.logger.error("Exception in callback", error);
+        throw error;
+      }
+    });
+    if (!found) {
+      const errorMessage = this.formatErr(this._current, event);
+      this.logger.error(errorMessage);
+    }
+    return found;
+  }
+};
+
+// src/lib/behaviors/jumper-2d/jumper-2d-fsm.ts
+var Jumper2DState = /* @__PURE__ */ ((Jumper2DState2) => {
+  Jumper2DState2["Grounded"] = "grounded";
+  Jumper2DState2["Jumping"] = "jumping";
+  Jumper2DState2["Falling"] = "falling";
+  return Jumper2DState2;
+})(Jumper2DState || {});
+var Jumper2DEvent = /* @__PURE__ */ ((Jumper2DEvent2) => {
+  Jumper2DEvent2["Jump"] = "jump";
+  Jumper2DEvent2["Fall"] = "fall";
+  Jumper2DEvent2["Land"] = "land";
+  return Jumper2DEvent2;
+})(Jumper2DEvent || {});
+var Jumper2DFSM = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+    this.machine = new SyncStateMachine(
+      "grounded" /* Grounded */,
+      [
+        t("grounded" /* Grounded */, "jump" /* Jump */, "jumping" /* Jumping */),
+        t("grounded" /* Grounded */, "fall" /* Fall */, "falling" /* Falling */),
+        t("grounded" /* Grounded */, "land" /* Land */, "grounded" /* Grounded */),
+        t("jumping" /* Jumping */, "fall" /* Fall */, "falling" /* Falling */),
+        t("jumping" /* Jumping */, "land" /* Land */, "grounded" /* Grounded */),
+        t("jumping" /* Jumping */, "jump" /* Jump */, "jumping" /* Jumping */),
+        t("falling" /* Falling */, "land" /* Land */, "grounded" /* Grounded */),
+        t("falling" /* Falling */, "jump" /* Jump */, "jumping" /* Jumping */),
+        t("falling" /* Falling */, "fall" /* Fall */, "falling" /* Falling */)
+      ]
+    );
+  }
+  machine;
+  getState() {
+    return this.machine.getState();
+  }
+  dispatch(event) {
+    if (this.machine.can(event)) {
+      this.machine.syncDispatch(event);
+    }
+  }
+  isJumping() {
+    return this.getState() === "jumping" /* Jumping */;
+  }
+  isGrounded() {
+    return this.getState() === "grounded" /* Grounded */;
+  }
+  getJumpsUsed() {
+    return this.ctx.state.jumpsUsed;
+  }
+  applyTickEvent(tickEvent, isGrounded) {
+    switch (tickEvent) {
+      case "jump":
+        this.dispatch("jump" /* Jump */);
+        break;
+      case "fall":
+        this.dispatch("fall" /* Fall */);
+        break;
+      case "land":
+        this.dispatch("land" /* Land */);
+        break;
+      default:
+        if (!isGrounded && this.getState() === "grounded" /* Grounded */) {
+          this.dispatch("fall" /* Fall */);
+        }
+        if (isGrounded && this.getState() !== "grounded" /* Grounded */) {
+          this.dispatch("land" /* Land */);
+        }
+        break;
+    }
+  }
+};
+
+// src/lib/behaviors/behavior-descriptor.ts
+function defineBehavior(config) {
+  return {
+    key: /* @__PURE__ */ Symbol.for(`zylem:behavior:${config.name}`),
+    defaultOptions: config.defaultOptions,
+    systemFactory: config.systemFactory,
+    createHandle: config.createHandle
+  };
+}
+
+// src/lib/actions/capabilities/velocity-intents.ts
+function setVelocityIntent(store, sourceId, vector, options = {}) {
+  const prev = store.velocityChannels[sourceId];
+  const mode = options.mode ?? prev?.mode ?? "replace";
+  const priority = options.priority ?? prev?.priority ?? 0;
+  const isAdditiveMerge = mode === "add" && prev?.mode === "add";
+  const x = vector.x == null ? prev?.x : isAdditiveMerge ? (prev?.x ?? 0) + vector.x : vector.x;
+  const y = vector.y == null ? prev?.y : isAdditiveMerge ? (prev?.y ?? 0) + vector.y : vector.y;
+  const z = vector.z == null ? prev?.z : isAdditiveMerge ? (prev?.z ?? 0) + vector.z : vector.z;
+  store.velocityChannels[sourceId] = {
+    x,
+    y,
+    z,
+    mode,
+    priority
+  };
+  store.dirty.velocityChannels = true;
+}
+
+// src/lib/behaviors/shared/ground-probe-3d.ts
+import { Ray } from "@dimforge/rapier3d-compat";
+import { BufferGeometry, Line, LineBasicMaterial, Vector3 } from "three";
+
+// src/lib/physics/serialize-descriptors.ts
+import { RigidBodyType } from "@dimforge/rapier3d-compat";
+function serializeColliderDesc(desc) {
+  const internal = desc;
+  const customShapeData = internal.__zylemShapeData;
+  if (customShapeData?.shape === "trimesh") {
+    const result2 = {
+      shape: "trimesh",
+      dimensions: [],
+      vertices: [...customShapeData.vertices],
+      indices: [...customShapeData.indices]
+    };
+    const translation = internal.translation;
+    if (translation && (translation.x !== 0 || translation.y !== 0 || translation.z !== 0)) {
+      result2.translation = [translation.x, translation.y, translation.z];
+    }
+    if (internal.isSensor) {
+      result2.sensor = true;
+    }
+    if (internal.collisionGroups !== void 0 && internal.collisionGroups !== 4294967295) {
+      result2.collisionGroups = internal.collisionGroups;
+    }
+    if (internal.activeCollisionTypes !== void 0) {
+      result2.activeCollisionTypes = internal.activeCollisionTypes;
+    }
+    return result2;
+  }
+  const shapeType = internal.shape?.type ?? internal.shapeType ?? 0;
+  const { shape, dimensions, heightfieldMeta } = extractShapeData(shapeType, internal);
+  const result = {
+    shape,
+    dimensions
+  };
+  const t2 = internal.translation;
+  if (t2 && (t2.x !== 0 || t2.y !== 0 || t2.z !== 0)) {
+    result.translation = [t2.x, t2.y, t2.z];
+  }
+  if (internal.isSensor) {
+    result.sensor = true;
+  }
+  if (internal.collisionGroups !== void 0 && internal.collisionGroups !== 4294967295) {
+    result.collisionGroups = internal.collisionGroups;
+  }
+  if (internal.activeCollisionTypes !== void 0) {
+    result.activeCollisionTypes = internal.activeCollisionTypes;
+  }
+  if (heightfieldMeta) {
+    result.heightfieldMeta = heightfieldMeta;
+  }
+  return result;
+}
+function extractShapeData(shapeType, internal) {
+  switch (shapeType) {
+    case 0:
+      return {
+        shape: "ball",
+        dimensions: [internal.shape?.radius ?? internal.halfExtents?.x ?? 1]
+      };
+    case 1:
+      return {
+        shape: "cuboid",
+        dimensions: [
+          internal.shape?.halfExtents?.x ?? internal.halfExtents?.x ?? 0.5,
+          internal.shape?.halfExtents?.y ?? internal.halfExtents?.y ?? 0.5,
+          internal.shape?.halfExtents?.z ?? internal.halfExtents?.z ?? 0.5
+        ]
+      };
+    case 2:
+      return {
+        shape: "capsule",
+        dimensions: [
+          internal.shape?.halfHeight ?? 0.5,
+          internal.shape?.radius ?? 0.5
+        ]
+      };
+    case 6:
+      return {
+        shape: "cone",
+        dimensions: [
+          internal.shape?.halfHeight ?? 1,
+          internal.shape?.radius ?? 1
+        ]
+      };
+    case 7:
+      return {
+        shape: "cylinder",
+        dimensions: [
+          internal.shape?.halfHeight ?? 1,
+          internal.shape?.radius ?? 1
+        ]
+      };
+    case 11: {
+      const nrows = internal.shape?.nrows ?? 10;
+      const ncols = internal.shape?.ncols ?? 10;
+      const heights = internal.shape?.heights;
+      return {
+        shape: "heightfield",
+        dimensions: heights ? Array.from(heights) : [],
+        heightfieldMeta: { nrows, ncols }
+      };
+    }
+    default:
+      return { shape: "cuboid", dimensions: [0.5, 0.5, 0.5] };
+  }
+}
+
+// src/lib/behaviors/shared/ground-probe-3d.ts
+var GROUND_SNAP_EPSILON = 1e-3;
+var DEFAULT_OFFSETS = [
+  { x: 0, z: 0 },
+  { x: 0.4, z: 0.4 },
+  { x: -0.4, z: 0.4 },
+  { x: 0.4, z: -0.4 },
+  { x: -0.4, z: -0.4 }
+];
+var GroundProbe3D = class {
+  constructor(world) {
+    this.world = world;
+  }
+  rays = /* @__PURE__ */ new Map();
+  debugLines = /* @__PURE__ */ new Map();
+  probeSupport(entity, options) {
+    if (!this.world?.world || !entity.body) return null;
+    const mode = options.mode ?? "any";
+    const offsets = mode === "center" ? (options.offsets ?? DEFAULT_OFFSETS).slice(0, 1) : options.offsets ?? DEFAULT_OFFSETS;
+    const translation = entity.body.translation();
+    const rays = this.getOrCreateRays(entity.uuid, offsets.length);
+    const originYOffset = options.originYOffset ?? 0;
+    let support = null;
+    for (let index = 0; index < offsets.length; index++) {
+      const offset = offsets[index];
+      const ray = rays[index];
+      ray.origin = {
+        x: translation.x + offset.x,
+        y: translation.y + originYOffset,
+        z: translation.z + offset.z
+      };
+      ray.dir = { x: 0, y: -1, z: 0 };
+      const hit = this.world.world.castRay(
+        ray,
+        options.rayLength,
+        true,
+        void 0,
+        void 0,
+        void 0,
+        entity.body
+      );
+      if (!hit) continue;
+      const nextSupport = {
+        toi: hit.toi,
+        point: {
+          x: ray.origin.x + ray.dir.x * hit.toi,
+          y: ray.origin.y + ray.dir.y * hit.toi,
+          z: ray.origin.z + ray.dir.z * hit.toi
+        },
+        origin: {
+          x: ray.origin.x,
+          y: ray.origin.y,
+          z: ray.origin.z
+        },
+        rayIndex: index,
+        colliderUuid: hit.collider?._parent?.userData?.uuid
+      };
+      if (mode === "center") {
+        support = nextSupport;
+        break;
+      }
+      if (!support || nextSupport.toi < support.toi) {
+        support = nextSupport;
+      }
+    }
+    if (options.debug && options.scene) {
+      this.updateDebugLines(
+        entity.uuid,
+        rays,
+        Boolean(support),
+        options.rayLength,
+        options.scene
+      );
+    } else {
+      this.disposeDebugLines(entity.uuid);
+    }
+    return support;
+  }
+  detect(entity, options) {
+    return this.probeSupport(entity, options) != null;
+  }
+  destroyEntity(uuid) {
+    this.rays.delete(uuid);
+    this.disposeDebugLines(uuid);
+  }
+  destroy() {
+    this.rays.clear();
+    for (const uuid of this.debugLines.keys()) {
+      this.disposeDebugLines(uuid);
+    }
+    this.debugLines.clear();
+  }
+  getOrCreateRays(uuid, count) {
+    let rays = this.rays.get(uuid);
+    if (!rays || rays.length !== count) {
+      rays = Array.from(
+        { length: count },
+        () => new Ray({ x: 0, y: 0, z: 0 }, { x: 0, y: -1, z: 0 })
+      );
+      this.rays.set(uuid, rays);
+    }
+    return rays;
+  }
+  updateDebugLines(uuid, rays, hasGround, length, scene) {
+    let lines = this.debugLines.get(uuid);
+    if (!lines) {
+      lines = rays.map(() => {
+        const geometry = new BufferGeometry().setFromPoints([
+          new Vector3(),
+          new Vector3()
+        ]);
+        const material = new LineBasicMaterial({ color: 16711680 });
+        const line = new Line(geometry, material);
+        scene.add(line);
+        return line;
+      });
+      this.debugLines.set(uuid, lines);
+    }
+    rays.forEach((ray, index) => {
+      const line = lines[index];
+      const start = new Vector3(ray.origin.x, ray.origin.y, ray.origin.z);
+      const end = new Vector3(
+        ray.origin.x + ray.dir.x * length,
+        ray.origin.y + ray.dir.y * length,
+        ray.origin.z + ray.dir.z * length
+      );
+      line.visible = true;
+      line.geometry.setFromPoints([start, end]);
+      line.material.color.setHex(
+        hasGround ? 65280 : 16711680
+      );
+    });
+  }
+  disposeDebugLines(uuid) {
+    const lines = this.debugLines.get(uuid);
+    if (!lines) return;
+    for (const line of lines) {
+      line.removeFromParent();
+      line.geometry.dispose();
+      line.material.dispose();
+    }
+    this.debugLines.delete(uuid);
+  }
+};
+function getGroundAnchorOffsetY(entity) {
+  const runtimeColliderDesc = entity?.colliderDesc;
+  if (runtimeColliderDesc) {
+    const serialized = serializeColliderDesc(runtimeColliderDesc);
+    const centerY2 = serialized.translation?.[1] ?? 0;
+    if (serialized.shape === "capsule" && serialized.dimensions.length >= 2) {
+      const halfCylinder = serialized.dimensions[0] ?? 0;
+      const radius = serialized.dimensions[1] ?? 0;
+      return halfCylinder + radius - centerY2;
+    }
+    if (serialized.shape === "cuboid" && serialized.dimensions.length >= 2) {
+      const halfHeight = serialized.dimensions[1] ?? 0;
+      return halfHeight - centerY2;
+    }
+  }
+  const collisionSize = entity?.options?.collision?.size ?? entity?.options?.collisionSize ?? entity?.options?.size;
+  const height = collisionSize?.y ?? 0;
+  if (height <= 0) {
+    return 0;
+  }
+  const collisionPosition = entity?.options?.collision?.position ?? entity?.options?.collisionPosition;
+  const centerY = collisionPosition?.y ?? height / 2;
+  return height / 2 - centerY;
+}
+function getGroundSnapTargetY(entity, support, epsilon = GROUND_SNAP_EPSILON) {
+  return support.point.y + getGroundAnchorOffsetY(entity) + epsilon;
+}
+
+// src/lib/behaviors/jumper-2d/jumper-2d.descriptor.ts
+var defaultOptions = {
+  jumpHeight: 2.5,
+  gravity: 20,
+  maxJumps: 1,
+  resetJumpsOnGround: true,
+  coyoteTimeMs: 100,
+  jumpBufferMs: 80,
+  groundRayLength: 1,
+  debugGroundProbe: false
+};
+var JUMPER_2D_BEHAVIOR_KEY = /* @__PURE__ */ Symbol.for("zylem:behavior:jumper-2d");
+var JUMPER_2D_OFFSETS = [
+  { x: 0, z: 0 },
+  { x: 0.35, z: 0 },
+  { x: -0.35, z: 0 }
+];
+function isJumper2DGrounded(params) {
+  if (params.velocityY > 0) {
+    return false;
+  }
+  if (params.snapToGroundDistance != null) {
+    return params.supportToi != null && params.supportToi <= params.snapToGroundDistance;
+  }
+  return params.nearGround === true;
+}
+function shouldSnapJumper2DToGround(support, options, velocityY) {
+  return support != null && options.snapToGroundDistance != null && velocityY <= 0 && support.toi <= options.snapToGroundDistance;
+}
+var Jumper2DBehaviorSystem = class {
+  constructor(world, scene, getBehaviorLinks) {
+    this.world = world;
+    this.scene = scene;
+    this.getBehaviorLinks = getBehaviorLinks;
+    this.groundProbe = new GroundProbe3D(world);
+  }
+  behavior = new Jumper2DBehavior();
+  groundProbe;
+  initializedEntities = /* @__PURE__ */ new Set();
+  timeSinceGroundedMs = /* @__PURE__ */ new Map();
+  wasJumpHeld = /* @__PURE__ */ new Map();
+  update(_ecs, delta) {
+    const links = this.getBehaviorLinks?.(JUMPER_2D_BEHAVIOR_KEY);
+    if (!links) return;
+    for (const link of links) {
+      const gameEntity = link.entity;
+      const jumperRef = link.ref;
+      if (!gameEntity.body) continue;
+      const options = jumperRef.options;
+      if (!gameEntity.jumper2d) {
+        gameEntity.jumper2d = createJumpConfig2D(options);
+      }
+      if (!gameEntity.$jumper2d) {
+        gameEntity.$jumper2d = createJumpInput2D();
+      }
+      if (!gameEntity.jumper2dState) {
+        gameEntity.jumper2dState = createJumpState2D();
+      }
+      if (!this.initializedEntities.has(gameEntity.uuid)) {
+        this.initializedEntities.add(gameEntity.uuid);
+        gameEntity.body.setGravityScale(0, true);
+      }
+      if (!jumperRef.fsm && gameEntity.jumper2dState) {
+        jumperRef.fsm = new Jumper2DFSM({
+          state: gameEntity.jumper2dState
+        });
+      }
+      const rayLength = options.groundRayLength ?? 1;
+      const bodyVelocity = gameEntity.body.linvel();
+      const probeOriginYOffset = 0.05 - getGroundAnchorOffsetY(gameEntity);
+      const support = this.groundProbe.probeSupport(gameEntity, {
+        rayLength,
+        offsets: JUMPER_2D_OFFSETS,
+        mode: "any",
+        debug: options.debugGroundProbe ?? false,
+        scene: this.scene,
+        originYOffset: probeOriginYOffset
+      });
+      const nearGround = support != null;
+      const isGrounded = isJumper2DGrounded({
+        nearGround,
+        velocityY: bodyVelocity.y,
+        supportToi: support?.toi ?? null,
+        snapToGroundDistance: options.snapToGroundDistance
+      });
+      if (shouldSnapJumper2DToGround(support, options, bodyVelocity.y)) {
+        const currentPosition = gameEntity.body.translation();
+        gameEntity.body.setTranslation(
+          {
+            x: currentPosition.x,
+            y: getGroundSnapTargetY(gameEntity, support),
+            z: currentPosition.z
+          },
+          true
+        );
+      }
+      let timeSinceGroundedMs = this.timeSinceGroundedMs.get(gameEntity.uuid) ?? 0;
+      if (isGrounded) {
+        timeSinceGroundedMs = 0;
+      } else {
+        timeSinceGroundedMs += delta * 1e3;
+      }
+      this.timeSinceGroundedMs.set(gameEntity.uuid, timeSinceGroundedMs);
+      const config = gameEntity.jumper2d;
+      const input = gameEntity.$jumper2d;
+      const state = gameEntity.jumper2dState;
+      const previousHeld = this.wasJumpHeld.get(gameEntity.uuid) ?? false;
+      const held = input.jumpHeld === true;
+      const effectiveInput = {
+        ...input,
+        jumpPressed: input.jumpPressed || held && !previousHeld,
+        jumpReleased: input.jumpReleased || !held && previousHeld
+      };
+      const store = gameEntity.transformStore;
+      const ctx = {
+        dt: delta,
+        velocityY: bodyVelocity.y,
+        isGrounded,
+        timeSinceGroundedMs,
+        setVerticalVelocity: (y) => {
+          setVelocityIntent(
+            store,
+            "jumper-2d",
+            { y },
+            { mode: "replace", priority: 20 }
+          );
+          ctx.velocityY = y;
+        }
+      };
+      const result = this.behavior.tick(config, effectiveInput, ctx, state);
+      this.wasJumpHeld.set(gameEntity.uuid, held);
+      if (jumperRef.fsm) {
+        jumperRef.fsm.applyTickEvent(result.event, isGrounded);
+      }
+    }
+  }
+  destroy(_ecs) {
+    this.groundProbe.destroy();
+    this.initializedEntities.clear();
+    this.timeSinceGroundedMs.clear();
+    this.wasJumpHeld.clear();
+  }
+};
+var Jumper2D = defineBehavior({
+  name: "jumper-2d",
+  defaultOptions,
+  systemFactory: (ctx) => new Jumper2DBehaviorSystem(ctx.world, ctx.scene, ctx.getBehaviorLinks),
+  createHandle: (ref) => ({
+    getState: () => ref.fsm?.getState() ?? "grounded" /* Grounded */,
+    isJumping: () => ref.fsm?.isJumping() ?? false,
+    getJumpsUsed: () => ref.fsm?.getJumpsUsed() ?? 0,
+    getJumpsRemaining: () => {
+      const maxJumps = ref.options.maxJumps ?? 1;
+      const used = ref.fsm?.getJumpsUsed() ?? 0;
+      return maxJumps - used;
+    }
+  })
+});
+export {
+  Jumper2D,
+  Jumper2DBehavior,
+  Jumper2DEvent,
+  Jumper2DFSM,
+  Jumper2DState,
+  Jumper2DTickEvent,
+  createJumpConfig2D,
+  createJumpInput2D,
+  createJumpState2D
+};
+//# sourceMappingURL=jumper-2d.js.map