@zylem/game-lib 0.6.3 → 0.6.4

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

@@ -10,8 +10,9 @@ function createPlatformer3DMovementComponent(options = {}) {
     coyoteTime: options.coyoteTime ?? 0.1,
     jumpBufferTime: options.jumpBufferTime ?? 0.1,
     jumpCutMultiplier: options.jumpCutMultiplier ?? 0.5,
-    multiJumpWindowTime: options.multiJumpWindowTime ?? 0.15
+    multiJumpWindowTime: options.multiJumpWindowTime ?? 0.15,
     // 150ms default
+    debugGroundProbe: options.debugGroundProbe ?? false
   };
 }
 function createPlatformer3DInputComponent() {
@@ -44,8 +45,46 @@ function createPlatformer3DStateComponent() {
   };
 }
 
+// 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
-import { StateMachine, t } from "typescript-fsm";
 var Platformer3DState = /* @__PURE__ */ ((Platformer3DState2) => {
   Platformer3DState2["Idle"] = "idle";
   Platformer3DState2["Walking"] = "walking";
@@ -67,7 +106,7 @@ var Platformer3DEvent = /* @__PURE__ */ ((Platformer3DEvent2) => {
 var Platformer3DFSM = class {
   constructor(ctx) {
     this.ctx = ctx;
-    this.machine = new StateMachine(
+    this.machine = new SyncStateMachine(
       "idle" /* Idle */,
       [
         // Idle transitions
@@ -113,7 +152,7 @@ var Platformer3DFSM = class {
    */
   dispatch(event) {
     if (this.machine.can(event)) {
-      this.machine.dispatch(event);
+      this.machine.syncDispatch(event);
     }
   }
   /**
@@ -171,97 +210,294 @@ var Platformer3DFSM = class {
   }
 };
 
-// src/lib/behaviors/platformer-3d/platformer-3d.behavior.ts
-import { Vector3, BufferGeometry, LineBasicMaterial, Line } from "three";
+// src/lib/behaviors/shared/ground-probe-3d.ts
 import { Ray } from "@dimforge/rapier3d-compat";
-var Platformer3DBehavior = class {
-  world;
-  scene;
-  rays = /* @__PURE__ */ new Map();
-  debugLines = /* @__PURE__ */ new Map();
-  // Store Line objects for debug visualization
-  constructor(world, scene) {
+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;
-    this.scene = scene;
   }
-  /**
-   * Detect if entity is on the ground using raycasting
-   */
-  /**
-   * Detect if entity is on the ground using raycasting (multi-sample: center + 4 corners)
-   */
-  detectGround(entity) {
-    if (!this.world?.world || !entity.body) return false;
+  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 rayLength = entity.platformer.groundRayLength;
-    const radius = 0.4;
-    const offsets = [
-      { x: 0, z: 0 },
-      { x: radius, z: radius },
-      { x: -radius, z: radius },
-      { x: radius, z: -radius },
-      { x: -radius, z: -radius }
-    ];
-    let entityRays = this.rays.get(entity.uuid);
-    if (!entityRays) {
-      entityRays = offsets.map(() => new Ray({ x: 0, y: 0, z: 0 }, { x: 0, y: -1, z: 0 }));
-      this.rays.set(entity.uuid, entityRays);
-    }
-    let grounded = false;
-    offsets.forEach((offset, i) => {
-      if (grounded) return;
-      const ray = entityRays[i];
+    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,
+        y: translation.y + originYOffset,
         z: translation.z + offset.z
       };
       ray.dir = { x: 0, y: -1, z: 0 };
       const hit = this.world.world.castRay(
         ray,
-        rayLength,
+        options.rayLength,
         true,
         void 0,
         void 0,
         void 0,
-        void 0,
-        (collider) => {
-          const ref = collider._parent?.userData?.uuid;
-          if (ref === entity.uuid) return false;
-          grounded = true;
-          return true;
-        }
+        entity.body
       );
-    });
-    if (this.scene) {
-      this.updateDebugLines(entity, entityRays, grounded, rayLength);
+      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);
     }
-    return grounded;
+    this.debugLines.clear();
   }
-  updateDebugLines(entity, rays, hasGround, length) {
-    let lines = this.debugLines.get(entity.uuid);
+  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 geometry = new BufferGeometry().setFromPoints([
+          new Vector3(),
+          new Vector3()
+        ]);
         const material = new LineBasicMaterial({ color: 16711680 });
         const line = new Line(geometry, material);
-        this.scene.add(line);
+        scene.add(line);
         return line;
       });
-      this.debugLines.set(entity.uuid, lines);
+      this.debugLines.set(uuid, lines);
     }
-    rays.forEach((ray, i) => {
-      const line = lines[i];
+    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);
+      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
    */
@@ -322,22 +558,7 @@ var Platformer3DBehavior = class {
     const buttonReleased = state.jumpReleasedSinceLastJump;
     const inMultiJumpWindow = state.timeSinceJump >= movement.multiJumpWindowTime;
     const canMultiJump = !state.grounded && hasJumpsRemaining && buttonReleased && inMultiJumpWindow;
-    console.log("[JUMP DEBUG] Attempting jump:", {
-      grounded: state.grounded,
-      jumpCount: state.jumpCount,
-      maxJumps: movement.maxJumps,
-      isFirstJump,
-      canMultiJump,
-      "--- Multi-jump conditions ---": "",
-      "!grounded": !state.grounded,
-      hasJumpsRemaining,
-      buttonReleased,
-      inMultiJumpWindow,
-      timeSinceJump: state.timeSinceJump.toFixed(3),
-      multiJumpWindowTime: movement.multiJumpWindowTime
-    });
     if (isFirstJump || canMultiJump) {
-      console.log("[JUMP DEBUG] \u2705 EXECUTING JUMP #" + (state.jumpCount + 1));
       state.jumpBuffered = false;
       state.jumpCount++;
       state.jumpReleasedSinceLastJump = false;
@@ -348,8 +569,6 @@ var Platformer3DBehavior = class {
       state.jumpCutApplied = false;
       entity.transformStore.velocity.y = movement.jumpForce;
       entity.transformStore.dirty.velocity = true;
-    } else {
-      console.log("[JUMP DEBUG] \u274C JUMP BLOCKED - conditions not met");
     }
   }
   /**
@@ -377,12 +596,26 @@ var Platformer3DBehavior = class {
     let isGrounded = false;
     const isAirborne = state.jumping || state.falling;
     if (isAirborne) {
-      const nearGround = this.detectGround(entity);
+      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 nearGround = this.detectGround(entity);
+      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;
     }
@@ -409,26 +642,32 @@ var Platformer3DBehavior = class {
     }
   }
   /**
-   * Update all platformer entities
+   * 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) {
-      const platformerEntity = entity;
-      if (!platformerEntity.platformer || !platformerEntity.$platformer || !platformerEntity.platformerState) {
-        continue;
-      }
-      this.updateState(platformerEntity, delta);
-      this.applyMovement(platformerEntity, delta);
-      this.handleJump(platformerEntity, delta);
-      this.applyGravity(platformerEntity, delta);
+      this.updateEntity(entity, delta);
     }
   }
   /**
    * Cleanup
    */
   destroy() {
-    this.rays.clear();
+    this.groundProbe.destroy();
   }
 };
 
@@ -449,25 +688,25 @@ var defaultOptions = {
   jumpForce: 12,
   maxJumps: 1,
   gravity: 9.82,
-  groundRayLength: 1
+  groundRayLength: 1,
+  debugGroundProbe: false
 };
+var PLATFORMER_BEHAVIOR_KEY = /* @__PURE__ */ Symbol.for("zylem:behavior:platformer-3d");
 var Platformer3DBehaviorSystem = class {
-  constructor(world, scene) {
+  constructor(world, scene, getBehaviorLinks) {
     this.world = world;
     this.scene = scene;
+    this.getBehaviorLinks = getBehaviorLinks;
     this.movementBehavior = new Platformer3DBehavior(world, scene);
   }
   movementBehavior;
-  update(ecs, delta) {
-    if (!this.world?.collisionMap) return;
-    for (const [, entity] of this.world.collisionMap) {
-      const gameEntity = entity;
-      if (typeof gameEntity.getBehaviorRefs !== "function") continue;
-      const refs = gameEntity.getBehaviorRefs();
-      const platformerRef = refs.find(
-        (r) => r.descriptor.key === /* @__PURE__ */ Symbol.for("zylem:behavior:platformer-3d")
-      );
-      if (!platformerRef || !gameEntity.body) continue;
+  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);
@@ -487,8 +726,8 @@ var Platformer3DBehaviorSystem = class {
       if (platformerRef.fsm && gameEntity.$platformer && gameEntity.platformerState) {
         platformerRef.fsm.update(gameEntity.$platformer, gameEntity.platformerState);
       }
+      this.movementBehavior.updateEntity(gameEntity, delta);
     }
-    this.movementBehavior.update(delta);
   }
   destroy(_ecs) {
     this.movementBehavior.destroy();
@@ -497,7 +736,11 @@ var Platformer3DBehaviorSystem = class {
 var Platformer3DBehavior2 = defineBehavior({
   name: "platformer-3d",
   defaultOptions,
-  systemFactory: (ctx) => new Platformer3DBehaviorSystem(ctx.world, ctx.scene),
+  systemFactory: (ctx) => new Platformer3DBehaviorSystem(
+    ctx.world,
+    ctx.scene,
+    ctx.getBehaviorLinks
+  ),
   createHandle: (ref) => ({
     getState: () => ref.fsm?.getState() ?? "idle" /* Idle */,
     isGrounded: () => ref.fsm?.isGrounded() ?? false,