@zylem/game-lib 0.6.4 → 0.7.0

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

@@ -1,711 +0,0 @@
-// 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