@woosh/meep-engine 3.38.0 → 3.39.0

package/src/engine/control/first-person/FirstPersonPlayerControllerSystem.d.ts

@@ -7,6 +7,14 @@
  * - update runs L3 (camera composition) at render rate so the eye is never
  *   smoother than the screen.
  *
+ * The body is moved by the physics step, onto the pose each fixedUpdate
+ * resolves ({@link PhysicsSystem#setTargetPose}). The order the EntityManager
+ * derives runs this system's fixedUpdate before {@link PhysicsSystem}'s in the
+ * same step, so the body is on the tick's pose when the step ends. Run after
+ * it instead, nothing lags but the transform: the tick's own state, the
+ * published `pose.rootPosition` and the camera all use the pose it resolved,
+ * and the next step puts the body there.
+ *
  * The system itself integrates a simple flat-floor at y = `config.gravity.magnitude > 0
  * ? state.groundY : -Infinity` for the prototype. A real physics layer should
  * write `state.grounded`/`state.groundNormal` from outside instead; the
@@ -98,6 +106,18 @@ export class FirstPersonPlayerControllerSystem extends System<any> {
      * @param {number} entity
      */
     unlink(controller: FirstPersonPlayerController, bodyTransform: Transform64, entity: number): void;
+    /**
+     * Leave the body standing where the controller last put it. The velocities a target pose
+     * derives stay on the body after its step, so a body the controller stops driving would walk
+     * on at its last speed. When the last pose is still in flight - handed over, its step not run
+     * yet, as when the controller is removed from inside its own tick - the body is put there now,
+     * so the pending target derives no velocity either.
+     *
+     * @private
+     * @param {PerEntityRuntime} runtime
+     * @param {Transform64} bodyTransform
+     */
+    private _releaseBody;
     /**
      * Look up the per-entity runtime for an entity that has this
      * controller. Used by cross-system code (sensors system, future
@@ -117,11 +137,52 @@ export class FirstPersonPlayerControllerSystem extends System<any> {
      */
     private _tickEntity;
     /**
+     * One footfall: count it, alternate the foot, send `onFootStep` and kick the vertical impact
+     * spring. A method rather than a closure made in the tick, which cost an allocation a tick
+     * while walking.
+     *
      * @private
      * @param {FirstPersonPlayerController} controller
      * @param {PerEntityRuntime} runtime
-     * @returns {boolean}
+     * @param {number} horizSpeed this tick's horizontal speed, m/s
      */
+    private _fireFootstep;
+    /**
+     * Keep a move someone else made to the body during this tick. The tick resolved its pose from
+     * where the body was when it started ({@link PerEntityRuntime#bodyStartPosition}); a transform
+     * that is no longer there was moved under the tick - a signal listener's `setPose`, a respawn
+     * on a hard landing - and handing the resolved pose over would pull the body back from where
+     * it was put, at whatever velocity covers that distance in one step. The tick's pose becomes
+     * the transform's instead, and the camera jumps to it.
+     *
+     * @private
+     * @param {PerEntityRuntime} runtime
+     * @param {Transform64} bodyTransform
+     */
+    private _adoptExternalMove;
+    /**
+     * Hand the pose this tick resolved ({@link PerEntityRuntime#bodyPosition},
+     * {@link PerEntityRuntime#bodyRotation}) to the body.
+     *
+     * With physics, it is a target ({@link PhysicsSystem#setTargetPose}): the next step sets the
+     * body's velocities to cover the distance in the step and ends with the body exactly on the
+     * pose, so what the player meets or carries sees a body moving at the player's speed, and the
+     * step announces the move. Every tick sets one, standing still included - the velocities a
+     * target derives stay on the body, and without a new target the last move's would carry the
+     * player on. A warp ({@link PerEntityRuntime#bodyTeleport}) puts the body on the pose first with
+     * {@link PhysicsSystem#setPose}, so the target derives no velocity from the jump.
+     *
+     * Without physics no step will move the body, so the tick writes the transform and announces
+     * it itself: a Transform64 announces nothing on its own, and the announcement is what wakes the
+     * mesh placement, the audio emitter and anything else that follows a player.
+     *
+     * @private
+     * @param {import("../../ecs/EntityComponentDataset.js").EntityComponentDataset} ecd
+     * @param {number} entity
+     * @param {PerEntityRuntime} runtime
+     * @param {Transform64} bodyTransform
+     */
+    private _commitBodyPose;
     /**
      * Swap {@link Collider.shape} to the pre-built capsule that matches
      * the player's current posture. Cheap — just a reference swap when
@@ -138,7 +199,7 @@ export class FirstPersonPlayerControllerSystem extends System<any> {
      * @private
      */
     private _syncColliderShape;
-    _resolveCrouchHeld(controller: any, runtime: any, bodyTransform: any): any;
+    _resolveCrouchHeld(controller: any, runtime: any): any;
     /**
      * Headroom probe for a posture change that GROWS the collider.
      * Sweeps `fromShape` (the shorter posture's capsule) straight up by
@@ -151,8 +212,9 @@ export class FirstPersonPlayerControllerSystem extends System<any> {
      * overlap would false-positive on a wall *beside* the player. The
      * up-cast sweeps parallel to (and, per the mover's skin clearance,
      * clear of) lateral walls so they aren't hit; the floor is below
-     * the rising probe; the player's own body is filtered out. Only
-     * genuine overhead geometry blocks the grow. Relies on the player
+     * the rising probe; the player's own body, and sensors, are filtered
+     * out ({@link PerEntityRuntime#solidNotSelf}). Only genuine overhead
+     * geometry blocks the grow. Relies on the player
      * resting at `floor+skin` (the mover's stick-to-ground), so the
      * probe's bottom starts clear of the floor.
      *
@@ -168,7 +230,6 @@ export class FirstPersonPlayerControllerSystem extends System<any> {
      * @private
      * @param {FirstPersonPlayerController} controller
      * @param {PerEntityRuntime} runtime
-     * @param {Transform64} bodyTransform
      * @param {number} dt
      */
     private _advanceJumpFsm;
@@ -179,11 +240,13 @@ export class FirstPersonPlayerControllerSystem extends System<any> {
      * a physics layer is present; otherwise a lightweight flat-ground
      * integrator for headless / unit-test scenes with no collidable
      * geometry. Land / leave-ground events flow identically from either.
+     * The move is resolved into {@link PerEntityRuntime#bodyPosition}.
      *
      * @private
      * @param {FirstPersonPlayerController} controller
      * @param {PerEntityRuntime} runtime
-     * @param {Transform64} bodyTransform
+     * @param {Transform64} bodyTransform the body's transform, holding the pose the tick started
+     *   from; not written
      * @param {number} dt
      */
     private _integrateVerticalAndResolveGround;
@@ -197,6 +260,10 @@ export class FirstPersonPlayerControllerSystem extends System<any> {
      * and then call this directly — so motion routes through one motor for
      * everyone (sweep-and-slide, anti-tunnel, land/leave events) rather than
      * a bespoke `position._add` + hand-rolled ground-catch.
+     *
+     * The move starts from {@link PerEntityRuntime#bodyPosition} and is resolved into it; the
+     * body reaches it at the end of the tick. `bodyTransform` holds the pose the tick started from
+     * and is not written.
      * @private
      */
     private _resolveMotion;
@@ -282,10 +349,13 @@ export class FirstPersonPlayerControllerSystem extends System<any> {
      * Read-only with respect to controller state — this is purely a publish
      * step.
      *
+     * The root position is the pose this tick resolved ({@link PerEntityRuntime#bodyPosition}),
+     * which the body reaches in the physics step: published now, it is where the body is once
+     * the step has run, whichever of the two systems runs first.
+     *
      * @private
      * @param {FirstPersonPlayerController} controller
      * @param {PerEntityRuntime} runtime
-     * @param {Transform64} bodyTransform
      */
     private _publishPose;
     /**
@@ -295,6 +365,8 @@ export class FirstPersonPlayerControllerSystem extends System<any> {
      * position is smooth at any refresh rate. (Yaw/pitch aren't snapshotted —
      * they're render-rate.) On a teleport (`renderSnap`), prev and cur collapse
      * to the new position so the camera jumps rather than gliding across it.
+     * The position is the pose this tick resolved, not the transform, which
+     * reaches it only in the physics step.
      * @private
      */
     private _snapshotRenderPose;
@@ -349,9 +421,12 @@ import { Camera } from "../../graphics/ecs/camera/Camera.js";
 declare class PerEntityRuntime {
     /**
      * Co-attached kinematic body. Set by {@link FirstPersonPlayerControllerSystem.link}
-     * after asserting it's present. The controller writes Transform64.position
-     * directly (existing motion logic); physics derives the body's velocity
-     * from the per-step delta. Other physics systems (raycasts, contact
+     * after asserting it's present. Each tick ends by handing the pose the tick resolved
+     * ({@link bodyPosition}, {@link bodyRotation}) to {@link PhysicsSystem#setTargetPose}: the
+     * physics step that follows moves the body there with the velocity that covers the distance
+     * in the step, so what the player meets or carries sees a body moving at the player's speed,
+     * and the step ends with the body exactly on the pose. A warp ({@link bodyTeleport}) goes
+     * through {@link PhysicsSystem#setPose} instead. Other physics systems (raycasts, contact
      * events) see the player through this body.
      * @type {RigidBody|null}
      */
@@ -363,6 +438,23 @@ declare class PerEntityRuntime {
      * @type {Collider|null}
      */
     collider: Collider | null;
+    /**
+     * Query filter that leaves out every collider of the player's own body. A query asks its filter
+     * with the entity of the body a collider belongs to, so comparing that entity catches the
+     * capsule and anything else the body carries — a child trigger, a held item's collider — where
+     * comparing the capsule's Collider caught only the capsule, and a second collider on the body
+     * pushed the player out of itself. Made at link, so a tick allocates no closure.
+     * @type {((entity:number, collider:Collider)=>boolean)|null}
+     */
+    notSelf: ((entity: number, collider: Collider) => boolean) | null;
+    /**
+     * Shape-cast filter for the posture headroom probe: {@link notSelf}, and solid — a sensor (a
+     * collider or body flagged IsSensor) is no ceiling, as it is no wall to the mover. The shape cast
+     * reports sensors, so the probe drops them itself; it asks the physics system for the body behind
+     * the id the cast passes. Made at link.
+     * @type {((entity:number, collider:Collider, body_id:number)=>boolean)|null}
+     */
+    solidNotSelf: ((entity: number, collider: Collider, body_id: number) => boolean) | null;
     /**
      * This character's own mover.
      *
@@ -378,6 +470,39 @@ declare class PerEntityRuntime {
      * @type {KinematicMover|null}
      */
     mover: KinematicMover | null;
+    /**
+     * Where this tick puts the body. Read from the body's Transform64 at the top of the tick —
+     * the pose the body actually has — then moved by the mover, the flat-ground fallback or an
+     * ability, and handed to the body at the end of the tick (see {@link rigidBody}). Everything
+     * in the tick that asks where the player is reads it here, not from the transform, which
+     * does not move until the physics step: the land / apex bookkeeping, the posture probe, the
+     * published pose and the camera's interpolation endpoint.
+     * @type {Float64Array}
+     */
+    bodyPosition: Float64Array;
+    /**
+     * The body's orientation this tick as `[x, y, z, w]`: the pure yaw of {@link bodyYaw}, made at
+     * the top of the tick and handed to the body with {@link bodyPosition}. The mover's and the
+     * posture probe's casts use it.
+     * @type {Float64Array}
+     */
+    bodyRotation: Float64Array;
+    /**
+     * Where the body was at the top of this tick, as read into {@link bodyPosition}. Compared with
+     * the transform before the pose is handed over: a body moved under the tick by someone else —
+     * a respawn's `setPose` from a signal handler — is left where they put it, rather than pulled
+     * back to a pose resolved from where it used to be.
+     * @type {Float64Array}
+     */
+    bodyStartPosition: Float64Array;
+    /**
+     * Set by whoever moved {@link bodyPosition} by a warp this tick rather than a motion — the
+     * ledge grab's snap onto the hang pose. The tick then ends with {@link PhysicsSystem#setPose}
+     * to the pose, so the body gets no velocity from the jump. Cleared when the pose is handed
+     * over.
+     * @type {boolean}
+     */
+    bodyTeleport: boolean;
     /**
      * Pre-built capsule colliders, one per posture. Cached at link
      * from `config.body.{height, crouchHeight, proneHeight, radius}`

package/src/engine/control/first-person/FirstPersonPlayerControllerSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FirstPersonPlayerControllerSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/control/first-person/FirstPersonPlayerControllerSystem.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"FirstPersonPlayerControllerSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/control/first-person/FirstPersonPlayerControllerSystem.js"],"names":[],"mappings":"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"}