@woosh/meep-engine 2.154.0 → 2.156.0

package/src/engine/control/first-person/FirstPersonPlayerControllerConfig.js

@@ -22,6 +22,15 @@ export class FirstPersonPlayerControllerConfig {
         mass: 80,
         /** Reference mass against which `mass` is normalized (massRatio = mass/refMass). */
         referenceMass: 80,
+        /**
+         * Leg push-off distance, meters — the crouch-to-full-extension travel
+         * over which the legs do their launching work. Together with `mass` it
+         * turns a jump FORCE (newtons) into a launch velocity via the work-energy
+         * model in {@link jumpDynamics} (`v₀ = √(2·F·d/m)`). ~0.45 m matches a
+         * ~1.8 m human countermovement jump. See {@link jumpForceForHeight} for
+         * the back-calculation from a desired apex height.
+         */
+        jumpPushoffDistance: 0.45,
         /**
          * How strongly `mass` couples into derived effects. 0 = mass is
          * cosmetic; 1.0 = full coupling (heavier ⇒ lower jump, lower accel,
@@ -169,6 +178,44 @@ export class FirstPersonPlayerControllerConfig {
         nearWallMaxDistance: 0.6,
     };
 
+    /**
+     * Scramble-up ability — a short vertical wall-run up a wall the player runs
+     * INTO (à la Assassin's Creed), to reach a high ledge to grab or to kick
+     * off. Fields here are consumed by the {@link ScrambleUp} ability if
+     * registered; ignored otherwise.
+     */
+    scrambleUp = {
+        // Scramble "purchase" is a physical leg PUSH-OFF FORCE (newtons), turned
+        // into a launch velocity through the body's mass + push-off distance via
+        // {@link jumpDynamics} — so a heavier character scrambles lower for the
+        // same effort, exactly like a jump. To pick these from a desired climb
+        // height h, use `jumpForceForHeight(mass, gravity, jumpPushoffDistance, h)`.
+        /** Standstill push-off force (N) — a scramble jumped with no run-up. At
+         *  the default 80 kg body + 0.45 m push-off this launches ~5 m/s (~0.9 m
+         *  up the wall at the default decel). */
+        baseJumpForce: 2200,
+        /** Force (N) added per m/s of horizontal approach speed at the jump —
+         *  the running-start reward, in the same physical currency as the base. */
+        momentumForcePerSpeed: 470,
+        /** Cap on the push-off force (N) — a full sprint run-up tops out here
+         *  (~9 m/s launch, ~2.9 m climb at the default body + decel). */
+        maxJumpForce: 7200,
+        /** Upward deceleration (m/s²) — strong, so the climb is a SHORT burst:
+         *  apex ≈ launchVy²/(2·decel) m high, reached in launchVy/decel s. */
+        decel: 14.0,
+        /** Small into-wall speed (m/s) holding the body against the face as it
+         *  climbs (the mover clips the penetration). */
+        hugSpeed: 1.0,
+        /** Safety cap on scramble duration (s) — releases even if the apex
+         *  somehow isn't reached. */
+        maxDuration: 0.8,
+        /** Wall-kick (jump during the scramble): outward impulse (m/s along the
+         *  wall normal). The kick's UPWARD launch is not tuned here — it uses the
+         *  body's full jump push-off force (`runtime.jumpForce`), so a wall-kick
+         *  rises like a max-height jump. */
+        kickOutwardImpulse: 5.0,
+    };
+
     /**
      * Ledge-grab ability — snap to a forward ledge while descending and
      * hang from it until the player releases. Climbing fatigue is
@@ -197,6 +244,49 @@ export class FirstPersonPlayerControllerConfig {
          *  ledge so mantle's ledgeAhead probe still resolves correctly
          *  on the next tick. */
         mantleUpUpFactor: 0.3,
+
+        // -- Ledge TRAVERSAL (shimmy / pull-up / dismount). While hanging,
+        //    the move intent is taken to world space and decomposed against
+        //    the captured wall normal n and edge tangent t — so toward/away/
+        //    lateral are facing-INDEPENDENT (looking away never dismounts). --
+        /** Shimmy speed along the edge (m/s). */
+        shimmySpeed: 1.4,
+        /** Pressing jump pulls up only when facing within this half-cone of
+         *  the wall (degrees); facing further away leaves you hanging. */
+        pullUpFacingConeDeg: 50,
+        /** World-move toward the wall above this (unit move) triggers pull-up. */
+        moveTowardThreshold: 0.4,
+        /** World-move away from the wall must exceed this AND dominate the
+         *  lateral component to trigger a drop. Set HIGHER than
+         *  `moveTowardThreshold` on purpose: dismounting (you fall) is more
+         *  consequential than a pull-up or a shimmy, so it takes a clearly
+         *  committed, off-the-wall push — a strafe taken while looking somewhat
+         *  off the wall reads as a shimmy, not an ejection. */
+        moveAwayThreshold: 0.6,
+        /** Refractory window (seconds) after ANY ledge release during which the
+         *  auto-catch can't re-grab. A deliberate dismount drops you straight
+         *  down the wall face, where the forward/ledge probes keep firing — so
+         *  without this the auto-catch would immediately re-grab the same lip,
+         *  snapping the body back onto the wall. ~0.3s lets the body fall clear
+         *  of the grab window first. (The old forward-intent grab gate hid this;
+         *  auto-catch needs it explicit.) */
+        regrabCooldown: 0.3,
+        /** Lateral world-move above this (and dominant) triggers a shimmy step. */
+        shimmyLateralMin: 0.3,
+        /** Extra gap beyond the capsule radius the lateral clearance ray needs. */
+        shimmyClearanceGap: 0.05,
+        /** Height (relative to the edge) to cast the lateral clearance ray. */
+        shimmyClearanceProbeY: -0.3,
+        /** Forward (into-wall) offset of the continuity down-probe past the edge. */
+        shimmyEdgeProbeForward: 0.17,
+        /** Continuity down-probe starts this far above the edge… */
+        shimmyContinuityProbeUp: 0.3,
+        /** …and reaches this far below it. */
+        shimmyContinuityProbeDown: 0.5,
+        /** Continuity hit must be within this of the edge height to count. */
+        shimmyContinuityTol: 0.2,
+        /** Exertion rises this much faster while actively shimmying. */
+        shimmyExertionFactor: 1.5,
     };
 
     /**
@@ -221,6 +311,23 @@ export class FirstPersonPlayerControllerConfig {
          *  forward bias so the player ends on top of the surface, not
          *  on the edge. */
         forwardOffsetOnLand: 0.4,
+
+        // -- VAULT-over (pull-up from a hang onto a top too thin to STAND on).
+        //    Reached only via a ledge-grab pull-up request; auto-mantle still
+        //    requires a standable top. --
+        /** Reachable-height ceiling when pulling up from a hang (vs maxHeight
+         *  for auto-mantle) — the hang sits right at ~maxHeight, so give slack. */
+        pullUpMaxHeight: 1.6,
+        /** How far past the grab edge the vault carries the body before release. */
+        vaultDistance: 0.9,
+        /** Apex height above the edge the vault hump rises to. */
+        vaultApexClearance: 0.15,
+        /** How far below the apex the vault descends before it releases. */
+        vaultDropOnExit: 0.3,
+        /** Forward speed handed back on a vault release (carries you over). */
+        vaultExitSpeed: 3.0,
+        /** Downward speed handed back on a vault release (so you commit over). */
+        vaultExitDownSpeed: 1.0,
     };
 
     /**
@@ -445,6 +552,14 @@ export class FirstPersonPlayerControllerConfig {
         pitchMinDeg: -85,
         pitchMaxDeg: 85,
         invertY: false,
+        /** Input-SPIKE rejection. A single render frame whose look delta
+         *  (radians, after sensitivity) exceeds this is treated as a corrupt
+         *  mouse/driver `movementX` glitch — NOT a real turn — and dropped. This
+         *  is what stops the 20–100° camera snap from a high-res mouse under OS
+         *  pointer acceleration / a browser pointer-lock burst. Even an
+         *  extremely fast flick stays well under this at render rate (~0.3 rad ≈
+         *  17° in one frame would already be ~4000°/s). */
+        maxFrameDeltaRad: 0.3,
     };
 
     /**

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

@@ -283,6 +283,44 @@ export class FirstPersonPlayerControllerSystem extends System<any, any, any, any
      * @param {Transform} bodyTransform
      */
     private _publishPose;
+    /**
+     * Record this fixed step's authoritative body position as the latest
+     * render-interpolation endpoint, shifting the old latest to "previous".
+     * {@link _composeEye} blends prev→cur by the sub-step alpha so the camera
+     * 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.
+     * @private
+     */
+    private _snapshotRenderPose;
+    /**
+     * Dev-only invariant guard (meep asserts compile out of prod, so this is
+     * free there). Catches the class of corruption that surfaces as an
+     * unexplained camera "snap": a NaN/Infinity leaking into the yaw/pitch the
+     * eye composes from, or into the body's velocity / position. Runs once at
+     * the END of every fixed step, so a bad value is caught the tick it appears
+     * — naming the layer that produced it — instead of manifesting as a camera
+     * jump frames (or seconds) later when something finally reads it.
+     * @private
+     */
+    private _assertTickInvariants;
+    /**
+     * Consume the accumulated mouse-look delta into body yaw + eye pitch at
+     * RENDER rate (once per render frame, from {@link _composeEye}). This is the
+     * fix for the slow-turn camera snap: sampling `intent.look` at the 60Hz
+     * fixed step aliases an unaligned mouse report rate into an uneven turn,
+     * whereas consuming it every render frame tracks the mouse as smoothly as it
+     * arrives. `intent.look` is zeroed after consuming so the same delta isn't
+     * re-applied next frame.
+     *
+     * Conventions (raw mouse delta source — movementX/Y positive moving
+     * right/down): look.x > 0 ("mouse right") → turn right (the yaw sign is
+     * negated because the engine is left-handed with +Z forward, so a +Y
+     * rotation reads as a LEFT turn through the camera); look.y > 0 → look down,
+     * flipped by invertY.
+     * @private
+     */
+    private _consumeLook;
     /**
      * Compose the eye transform from body + state-driven offsets.
      * @private
@@ -345,6 +383,16 @@ declare class PerEntityRuntime {
     bodyYaw: number;
     /** Yaw rate (rad/s) computed in look consumption — for evaluators. */
     yawRateRadPerSec: number;
+    /** Body yaw at the end of the previous fixed step — used to derive the
+     *  per-step turn RATE that drives look-lean, decoupled from per-frame
+     *  input jitter. */
+    prevFixedYaw: number;
+    renderPrevPos: Vector3;
+    renderCurPos: Vector3;
+    /** When true, the next position snapshot collapses prev=cur (no blend)
+     *  — set on a body teleport (e.g. the ledge-grab hang snap) so the
+     *  camera doesn't glide across the jump. */
+    renderSnap: boolean;
     /** Horizontal+vertical velocity. We integrate these inside the system
      *  when no external physics layer is attached. */
     velocityX: number;
@@ -360,6 +408,13 @@ declare class PerEntityRuntime {
     anticipationRemaining: number;
     /** Cached derived gravity (m/s^2) from peakHeight + timeToApex. */
     gravity: number;
+    /**
+     * Cached jump PUSH-OFF FORCE (newtons) — the physical leg force that
+     * reaches `peakHeight` at the reference mass, the quantity jump power is
+     * expressed in. Derived at link via {@link jumpForceForHeight}; abilities
+     * (e.g. the scramble wall-kick) launch off this same force.
+     */
+    jumpForce: number;
     /** Cached derived jump impulse (m/s upward), post-mass-scaling. */
     jumpInitialVy: number;
     /**
@@ -483,9 +538,25 @@ declare class PerEntityRuntime {
     sensors: FirstPersonSensors;
     /** Cached eye entity ID. -1 until link assigns it. */
     eyeEntity: number;
+    /**
+     * One-shot hand-off flag: LedgeGrab sets it on a pull-up release so
+     * Mantle (next tick) knows this is a ledge pull-up — it then allows a
+     * too-thin top (auto-mantle still requires a standable one) and vaults
+     * OVER instead of onto. Mantle consumes it in onActivate.
+     */
+    ledgePullUpRequest: boolean;
+    /**
+     * Seconds remaining in the post-release ledge re-grab refractory
+     * window. Set by {@link LedgeGrab} on deactivation, aged down by dt
+     * each fixed step, and read by LedgeGrab.canActivate — so a deliberate
+     * dismount can fall clear of the grab window without the auto-catch
+     * snapping the body straight back onto the same lip.
+     */
+    ledgeRegrabCooldown: number;
 }
 import { PhysicsSystem } from "../../physics/ecs/PhysicsSystem.js";
 import { Collider } from "../../physics/ecs/Collider.js";
+import Vector3 from "../../../core/geom/Vector3.js";
 import { Spring } from "./math/Spring.js";
 import { EyeOffsetStack } from "./composer/EyeOffsetStack.js";
 import { FirstPersonSensors } from "./sensors/FirstPersonSensors.js";

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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"}