@zylem/game-lib 0.6.2 → 0.6.4

package/dist/behavior/platformer-3d.js

@@ -0,0 +1,761 @@
+// src/lib/behaviors/platformer-3d/components.ts
+function createPlatformer3DMovementComponent(options = {}) {
+  return {
+    walkSpeed: options.walkSpeed ?? 12,
+    runSpeed: options.runSpeed ?? 24,
+    jumpForce: options.jumpForce ?? 12,
+    maxJumps: options.maxJumps ?? 1,
+    gravity: options.gravity ?? 9.82,
+    groundRayLength: options.groundRayLength ?? 1,
+    coyoteTime: options.coyoteTime ?? 0.1,
+    jumpBufferTime: options.jumpBufferTime ?? 0.1,
+    jumpCutMultiplier: options.jumpCutMultiplier ?? 0.5,
+    multiJumpWindowTime: options.multiJumpWindowTime ?? 0.15,
+    // 150ms default
+    debugGroundProbe: options.debugGroundProbe ?? false
+  };
+}
+function createPlatformer3DInputComponent() {
+  return {
+    moveX: 0,
+    moveZ: 0,
+    jump: false,
+    run: false
+  };
+}
+function createPlatformer3DStateComponent() {
+  return {
+    grounded: false,
+    jumping: false,
+    falling: false,
+    jumpCount: 0,
+    jumpStartHeight: 0,
+    currentSpeed: 0,
+    lastGroundedY: 0,
+    jumpPressedLastFrame: false,
+    collisionGrounded: false,
+    groundedCollisionTime: 0,
+    timeSinceGrounded: 0,
+    jumpBuffered: false,
+    jumpBufferTimer: 0,
+    jumpHeld: false,
+    jumpCutApplied: false,
+    jumpReleasedSinceLastJump: true,
+    timeSinceJump: 0
+  };
+}
+
+// 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/platformer-3d/platformer-3d-fsm.ts
+var Platformer3DState = /* @__PURE__ */ ((Platformer3DState2) => {
+  Platformer3DState2["Idle"] = "idle";
+  Platformer3DState2["Walking"] = "walking";
+  Platformer3DState2["Running"] = "running";
+  Platformer3DState2["Jumping"] = "jumping";
+  Platformer3DState2["Falling"] = "falling";
+  Platformer3DState2["Landing"] = "landing";
+  return Platformer3DState2;
+})(Platformer3DState || {});
+var Platformer3DEvent = /* @__PURE__ */ ((Platformer3DEvent2) => {
+  Platformer3DEvent2["Walk"] = "walk";
+  Platformer3DEvent2["Run"] = "run";
+  Platformer3DEvent2["Jump"] = "jump";
+  Platformer3DEvent2["Fall"] = "fall";
+  Platformer3DEvent2["Land"] = "land";
+  Platformer3DEvent2["Stop"] = "stop";
+  return Platformer3DEvent2;
+})(Platformer3DEvent || {});
+var Platformer3DFSM = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+    this.machine = new SyncStateMachine(
+      "idle" /* Idle */,
+      [
+        // Idle transitions
+        t("idle" /* Idle */, "walk" /* Walk */, "walking" /* Walking */),
+        t("idle" /* Idle */, "run" /* Run */, "running" /* Running */),
+        t("idle" /* Idle */, "jump" /* Jump */, "jumping" /* Jumping */),
+        t("idle" /* Idle */, "fall" /* Fall */, "falling" /* Falling */),
+        // Walking transitions
+        t("walking" /* Walking */, "run" /* Run */, "running" /* Running */),
+        t("walking" /* Walking */, "jump" /* Jump */, "jumping" /* Jumping */),
+        t("walking" /* Walking */, "stop" /* Stop */, "idle" /* Idle */),
+        t("walking" /* Walking */, "fall" /* Fall */, "falling" /* Falling */),
+        // Running transitions
+        t("running" /* Running */, "walk" /* Walk */, "walking" /* Walking */),
+        t("running" /* Running */, "jump" /* Jump */, "jumping" /* Jumping */),
+        t("running" /* Running */, "stop" /* Stop */, "idle" /* Idle */),
+        t("running" /* Running */, "fall" /* Fall */, "falling" /* Falling */),
+        // Jumping transitions
+        t("jumping" /* Jumping */, "fall" /* Fall */, "falling" /* Falling */),
+        t("jumping" /* Jumping */, "land" /* Land */, "landing" /* Landing */),
+        t("jumping" /* Jumping */, "jump" /* Jump */, "jumping" /* Jumping */),
+        // Multi-jump
+        // Falling transitions
+        t("falling" /* Falling */, "land" /* Land */, "landing" /* Landing */),
+        // Landing transitions
+        t("landing" /* Landing */, "walk" /* Walk */, "walking" /* Walking */),
+        t("landing" /* Landing */, "run" /* Run */, "running" /* Running */),
+        t("landing" /* Landing */, "stop" /* Stop */, "idle" /* Idle */),
+        // Self-transitions (no-ops)
+        t("idle" /* Idle */, "stop" /* Stop */, "idle" /* Idle */)
+      ]
+    );
+  }
+  machine;
+  /**
+   * Get the current state
+   */
+  getState() {
+    return this.machine.getState();
+  }
+  /**
+   * Dispatch an event to the FSM
+   */
+  dispatch(event) {
+    if (this.machine.can(event)) {
+      this.machine.syncDispatch(event);
+    }
+  }
+  /**
+   * Check if grounded
+   */
+  isGrounded() {
+    const state = this.getState();
+    return state === "idle" /* Idle */ || state === "walking" /* Walking */ || state === "running" /* Running */ || state === "landing" /* Landing */;
+  }
+  /**
+   * Get current jump count from context
+   */
+  getJumpCount() {
+    return this.ctx.state.jumpCount;
+  }
+  /**
+   * Handle collision event to update ground state
+   */
+  handleCollision(ctx) {
+    if (ctx.contact.normal.y > 0.5) {
+      this.ctx.state.collisionGrounded = true;
+      this.ctx.state.groundedCollisionTime = performance.now();
+    }
+  }
+  /**
+   * Update FSM based on current state
+   */
+  update(input, state) {
+    this.ctx.input = input;
+    this.ctx.state = state;
+    const currentState = this.getState();
+    const hasInput = Math.abs(input.moveX) > 0.1 || Math.abs(input.moveZ) > 0.1;
+    const isRunning = input.run;
+    if (currentState === "falling" /* Falling */ && state.grounded) {
+      this.dispatch("land" /* Land */);
+    }
+    if (state.grounded) {
+      if (hasInput) {
+        if (isRunning) {
+          this.dispatch("run" /* Run */);
+        } else {
+          this.dispatch("walk" /* Walk */);
+        }
+      } else {
+        this.dispatch("stop" /* Stop */);
+      }
+    } else {
+      if (state.falling) {
+        this.dispatch("fall" /* Fall */);
+      }
+    }
+    if (input.jump && !state.jumpPressedLastFrame) {
+      this.dispatch("jump" /* Jump */);
+    }
+  }
+};
+
+// 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 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;
+}
+
+// src/lib/behaviors/platformer-3d/platformer-3d.behavior.ts
+var Platformer3DBehavior = class {
+  world;
+  scene;
+  groundProbe;
+  constructor(world, scene) {
+    this.world = world;
+    this.scene = scene;
+    this.groundProbe = new GroundProbe3D(world);
+  }
+  /**
+   * Apply horizontal movement based on input
+   */
+  applyMovement(entity, delta) {
+    const input = entity.$platformer;
+    const movement = entity.platformer;
+    const state = entity.platformerState;
+    const speed = input.run ? movement.runSpeed : movement.walkSpeed;
+    state.currentSpeed = speed;
+    const moveX = input.moveX * speed;
+    const moveZ = input.moveZ * speed;
+    const currentVel = entity.body.linvel();
+    entity.transformStore.velocity.x = moveX;
+    entity.transformStore.velocity.y = currentVel.y;
+    entity.transformStore.velocity.z = moveZ;
+    entity.transformStore.dirty.velocity = true;
+  }
+  /**
+   * Handle jump logic with multi-jump support
+   */
+  /**
+   * Handle jump logic with multi-jump, coyote time, and buffering
+   */
+  handleJump(entity, delta) {
+    const input = entity.$platformer;
+    const movement = entity.platformer;
+    const state = entity.platformerState;
+    if (state.jumping || state.falling) {
+      state.timeSinceJump += delta;
+    }
+    if (!input.jump && state.jumpHeld) {
+      state.jumpReleasedSinceLastJump = true;
+    }
+    if (input.jump && !state.jumpPressedLastFrame) {
+      state.jumpBuffered = true;
+      state.jumpBufferTimer = movement.jumpBufferTime;
+    }
+    state.jumpPressedLastFrame = input.jump;
+    state.jumpHeld = input.jump;
+    if (state.jumpBuffered) {
+      state.jumpBufferTimer -= delta;
+      if (state.jumpBufferTimer <= 0) {
+        state.jumpBuffered = false;
+      }
+    }
+    const minTimeBeforeCut = 0.1;
+    const canApplyCut = state.timeSinceJump >= minTimeBeforeCut;
+    if (!input.jump && state.jumping && !state.jumpCutApplied && canApplyCut) {
+      const velocity = entity.body.linvel();
+      entity.transformStore.velocity.y = velocity.y * movement.jumpCutMultiplier;
+      entity.transformStore.dirty.velocity = true;
+      state.jumpCutApplied = true;
+    }
+    if (!state.jumpBuffered) return;
+    const inCoyoteWindow = !state.grounded && state.timeSinceGrounded <= movement.coyoteTime;
+    const isFirstJump = state.grounded || inCoyoteWindow && state.jumpCount === 0;
+    const hasJumpsRemaining = state.jumpCount < movement.maxJumps;
+    const buttonReleased = state.jumpReleasedSinceLastJump;
+    const inMultiJumpWindow = state.timeSinceJump >= movement.multiJumpWindowTime;
+    const canMultiJump = !state.grounded && hasJumpsRemaining && buttonReleased && inMultiJumpWindow;
+    if (isFirstJump || canMultiJump) {
+      state.jumpBuffered = false;
+      state.jumpCount++;
+      state.jumpReleasedSinceLastJump = false;
+      state.timeSinceJump = 0;
+      state.jumpStartHeight = entity.body.translation().y;
+      state.jumping = true;
+      state.falling = false;
+      state.jumpCutApplied = false;
+      entity.transformStore.velocity.y = movement.jumpForce;
+      entity.transformStore.dirty.velocity = true;
+    }
+  }
+  /**
+   * Apply gravity when not grounded
+   */
+  applyGravity(entity, delta) {
+    const movement = entity.platformer;
+    const state = entity.platformerState;
+    if (state.grounded) return;
+    if (state.jumping && state.timeSinceJump < 0.01) {
+      return;
+    }
+    const currentVel = entity.body.linvel();
+    const newYVelocity = currentVel.y - movement.gravity * delta;
+    entity.transformStore.velocity.y = newYVelocity;
+    entity.transformStore.dirty.velocity = true;
+  }
+  /**
+   * Update entity state based on physics
+   */
+  updateState(entity, delta) {
+    const state = entity.platformerState;
+    const wasGrounded = state.grounded;
+    const velocity = entity.body.linvel();
+    let isGrounded = false;
+    const isAirborne = state.jumping || state.falling;
+    if (isAirborne) {
+      const probeOriginYOffset = 0.05 - getGroundAnchorOffsetY(entity);
+      const nearGround = this.groundProbe.detect(entity, {
+        rayLength: entity.platformer.groundRayLength,
+        mode: "any",
+        debug: entity.platformer.debugGroundProbe,
+        scene: this.scene,
+        originYOffset: probeOriginYOffset
+      });
+      const canLand = state.falling && !state.jumping;
+      const hasLanded = Math.abs(velocity.y) < 0.5;
+      isGrounded = nearGround && canLand && hasLanded;
+    } else {
+      const probeOriginYOffset = 0.05 - getGroundAnchorOffsetY(entity);
+      const nearGround = this.groundProbe.detect(entity, {
+        rayLength: entity.platformer.groundRayLength,
+        mode: "any",
+        debug: entity.platformer.debugGroundProbe,
+        scene: this.scene,
+        originYOffset: probeOriginYOffset
+      });
+      const notFallingFast = velocity.y > -2;
+      isGrounded = nearGround && notFallingFast;
+    }
+    state.grounded = isGrounded;
+    if (state.grounded) {
+      state.timeSinceGrounded = 0;
+      state.lastGroundedY = entity.body.translation().y;
+    } else {
+      state.timeSinceGrounded += delta;
+    }
+    if (!wasGrounded && state.grounded) {
+      state.jumpCount = 0;
+      state.jumping = false;
+      state.falling = false;
+      state.jumpCutApplied = false;
+    }
+    if (velocity.y < -0.1 && !state.grounded) {
+      if (state.jumping && velocity.y < 0) {
+        state.jumping = false;
+        state.falling = true;
+      } else if (!state.jumping) {
+        state.falling = true;
+      }
+    }
+  }
+  /**
+   * Update one platformer entity.
+   */
+  updateEntity(entity, delta) {
+    if (!entity.platformer || !entity.$platformer || !entity.platformerState) {
+      return;
+    }
+    const platformerEntity = entity;
+    this.updateState(platformerEntity, delta);
+    this.applyMovement(platformerEntity, delta);
+    this.handleJump(platformerEntity, delta);
+    this.applyGravity(platformerEntity, delta);
+  }
+  /**
+   * Update all platformer entities.
+   */
+  update(delta) {
+    if (!this.world?.collisionMap) return;
+    for (const [, entity] of this.world.collisionMap) {
+      this.updateEntity(entity, delta);
+    }
+  }
+  /**
+   * Cleanup
+   */
+  destroy() {
+    this.groundProbe.destroy();
+  }
+};
+
+// 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/behaviors/platformer-3d/platformer-3d.descriptor.ts
+var defaultOptions = {
+  walkSpeed: 12,
+  runSpeed: 24,
+  jumpForce: 12,
+  maxJumps: 1,
+  gravity: 9.82,
+  groundRayLength: 1,
+  debugGroundProbe: false
+};
+var PLATFORMER_BEHAVIOR_KEY = /* @__PURE__ */ Symbol.for("zylem:behavior:platformer-3d");
+var Platformer3DBehaviorSystem = class {
+  constructor(world, scene, getBehaviorLinks) {
+    this.world = world;
+    this.scene = scene;
+    this.getBehaviorLinks = getBehaviorLinks;
+    this.movementBehavior = new Platformer3DBehavior(world, scene);
+  }
+  movementBehavior;
+  update(_ecs, delta) {
+    const links = this.getBehaviorLinks?.(PLATFORMER_BEHAVIOR_KEY);
+    if (!links) return;
+    for (const link of links) {
+      const gameEntity = link.entity;
+      const platformerRef = link.ref;
+      if (!gameEntity.body) continue;
+      const options = platformerRef.options;
+      if (!gameEntity.platformer) {
+        gameEntity.platformer = createPlatformer3DMovementComponent(options);
+      }
+      if (!gameEntity.$platformer) {
+        gameEntity.$platformer = createPlatformer3DInputComponent();
+      }
+      if (!gameEntity.platformerState) {
+        gameEntity.platformerState = createPlatformer3DStateComponent();
+      }
+      if (!platformerRef.fsm && gameEntity.$platformer && gameEntity.platformerState) {
+        platformerRef.fsm = new Platformer3DFSM({
+          input: gameEntity.$platformer,
+          state: gameEntity.platformerState
+        });
+      }
+      if (platformerRef.fsm && gameEntity.$platformer && gameEntity.platformerState) {
+        platformerRef.fsm.update(gameEntity.$platformer, gameEntity.platformerState);
+      }
+      this.movementBehavior.updateEntity(gameEntity, delta);
+    }
+  }
+  destroy(_ecs) {
+    this.movementBehavior.destroy();
+  }
+};
+var Platformer3DBehavior2 = defineBehavior({
+  name: "platformer-3d",
+  defaultOptions,
+  systemFactory: (ctx) => new Platformer3DBehaviorSystem(
+    ctx.world,
+    ctx.scene,
+    ctx.getBehaviorLinks
+  ),
+  createHandle: (ref) => ({
+    getState: () => ref.fsm?.getState() ?? "idle" /* Idle */,
+    isGrounded: () => ref.fsm?.isGrounded() ?? false,
+    getJumpCount: () => ref.fsm?.getJumpCount() ?? 0,
+    onPlatformCollision: (ctx) => ref.fsm?.handleCollision(ctx)
+  })
+});
+export {
+  Platformer3DBehavior2 as Platformer3DBehavior,
+  Platformer3DEvent,
+  Platformer3DFSM,
+  Platformer3DBehavior as Platformer3DMovementBehavior,
+  Platformer3DState,
+  createPlatformer3DInputComponent,
+  createPlatformer3DMovementComponent,
+  createPlatformer3DStateComponent
+};
+//# sourceMappingURL=platformer-3d.js.map