@woosh/meep-engine 2.155.0 → 2.157.0

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

@@ -22,6 +22,15 @@ export class FirstPersonPlayerControllerConfig {
         mass: number;
         /** Reference mass against which `mass` is normalized (massRatio = mass/refMass). */
         referenceMass: number;
+        /**
+         * 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: number;
         /**
          * How strongly `mass` couples into derived effects. 0 = mass is
          * cosmetic; 1.0 = full coupling (heavier ⇒ lower jump, lower accel,
@@ -158,6 +167,38 @@ export class FirstPersonPlayerControllerConfig {
          *  is allowed (when not already wall-running). */
         nearWallMaxDistance: number;
     };
+    /**
+     * 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: {
+        /** 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: number;
+        /** 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: number;
+        /** 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: number;
+        /** Upward deceleration (m/s²) — strong, so the climb is a SHORT burst:
+         *  apex ≈ launchVy²/(2·decel) m high, reached in launchVy/decel s. */
+        decel: number;
+        /** Small into-wall speed (m/s) holding the body against the face as it
+         *  climbs (the mover clips the penetration). */
+        hugSpeed: number;
+        /** Safety cap on scramble duration (s) — releases even if the apex
+         *  somehow isn't reached. */
+        maxDuration: number;
+        /** 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: number;
+    };
     /**
      * Ledge-grab ability — snap to a forward ledge while descending and
      * hang from it until the player releases. Climbing fatigue is
@@ -186,6 +227,44 @@ export class FirstPersonPlayerControllerConfig {
          *  ledge so mantle's ledgeAhead probe still resolves correctly
          *  on the next tick. */
         mantleUpUpFactor: number;
+        /** Shimmy speed along the edge (m/s). */
+        shimmySpeed: number;
+        /** Pressing jump pulls up only when facing within this half-cone of
+         *  the wall (degrees); facing further away leaves you hanging. */
+        pullUpFacingConeDeg: number;
+        /** World-move toward the wall above this (unit move) triggers pull-up. */
+        moveTowardThreshold: number;
+        /** 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: number;
+        /** 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: number;
+        /** Lateral world-move above this (and dominant) triggers a shimmy step. */
+        shimmyLateralMin: number;
+        /** Extra gap beyond the capsule radius the lateral clearance ray needs. */
+        shimmyClearanceGap: number;
+        /** Height (relative to the edge) to cast the lateral clearance ray. */
+        shimmyClearanceProbeY: number;
+        /** Forward (into-wall) offset of the continuity down-probe past the edge. */
+        shimmyEdgeProbeForward: number;
+        /** Continuity down-probe starts this far above the edge… */
+        shimmyContinuityProbeUp: number;
+        /** …and reaches this far below it. */
+        shimmyContinuityProbeDown: number;
+        /** Continuity hit must be within this of the edge height to count. */
+        shimmyContinuityTol: number;
+        /** Exertion rises this much faster while actively shimmying. */
+        shimmyExertionFactor: number;
     };
     /**
      * Mantle ability — auto-triggers when the player approaches a
@@ -209,6 +288,19 @@ export class FirstPersonPlayerControllerConfig {
          *  forward bias so the player ends on top of the surface, not
          *  on the edge. */
         forwardOffsetOnLand: number;
+        /** Reachable-height ceiling when pulling up from a hang (vs maxHeight
+         *  for auto-mantle) — the hang sits right at ~maxHeight, so give slack. */
+        pullUpMaxHeight: number;
+        /** How far past the grab edge the vault carries the body before release. */
+        vaultDistance: number;
+        /** Apex height above the edge the vault hump rises to. */
+        vaultApexClearance: number;
+        /** How far below the apex the vault descends before it releases. */
+        vaultDropOnExit: number;
+        /** Forward speed handed back on a vault release (carries you over). */
+        vaultExitSpeed: number;
+        /** Downward speed handed back on a vault release (so you commit over). */
+        vaultExitDownSpeed: number;
     };
     /**
      * Slide ability — activates from sprint+crouch when grounded. The
@@ -422,6 +514,14 @@ export class FirstPersonPlayerControllerConfig {
         pitchMinDeg: number;
         pitchMaxDeg: number;
         invertY: boolean;
+        /** 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: number;
     };
     /**
      * Postural shifts driven by intent — distinct from look (which is
@@ -461,6 +561,15 @@ export class FirstPersonPlayerControllerConfig {
             mass: number;
             /** Reference mass against which `mass` is normalized (massRatio = mass/refMass). */
             referenceMass: number;
+            /**
+             * 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: number;
             /**
              * How strongly `mass` couples into derived effects. 0 = mass is
              * cosmetic; 1.0 = full coupling (heavier ⇒ lower jump, lower accel,
@@ -578,6 +687,44 @@ export class FirstPersonPlayerControllerConfig {
              *  ledge so mantle's ledgeAhead probe still resolves correctly
              *  on the next tick. */
             mantleUpUpFactor: number;
+            /** Shimmy speed along the edge (m/s). */
+            shimmySpeed: number;
+            /** Pressing jump pulls up only when facing within this half-cone of
+             *  the wall (degrees); facing further away leaves you hanging. */
+            pullUpFacingConeDeg: number;
+            /** World-move toward the wall above this (unit move) triggers pull-up. */
+            moveTowardThreshold: number;
+            /** 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: number;
+            /** 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: number;
+            /** Lateral world-move above this (and dominant) triggers a shimmy step. */
+            shimmyLateralMin: number;
+            /** Extra gap beyond the capsule radius the lateral clearance ray needs. */
+            shimmyClearanceGap: number;
+            /** Height (relative to the edge) to cast the lateral clearance ray. */
+            shimmyClearanceProbeY: number;
+            /** Forward (into-wall) offset of the continuity down-probe past the edge. */
+            shimmyEdgeProbeForward: number;
+            /** Continuity down-probe starts this far above the edge… */
+            shimmyContinuityProbeUp: number;
+            /** …and reaches this far below it. */
+            shimmyContinuityProbeDown: number;
+            /** Continuity hit must be within this of the edge height to count. */
+            shimmyContinuityTol: number;
+            /** Exertion rises this much faster while actively shimmying. */
+            shimmyExertionFactor: number;
         };
         mantle: {
             /** Below this height (m above feet), the obstacle is just a step
@@ -594,6 +741,19 @@ export class FirstPersonPlayerControllerConfig {
              *  forward bias so the player ends on top of the surface, not
              *  on the edge. */
             forwardOffsetOnLand: number;
+            /** Reachable-height ceiling when pulling up from a hang (vs maxHeight
+             *  for auto-mantle) — the hang sits right at ~maxHeight, so give slack. */
+            pullUpMaxHeight: number;
+            /** How far past the grab edge the vault carries the body before release. */
+            vaultDistance: number;
+            /** Apex height above the edge the vault hump rises to. */
+            vaultApexClearance: number;
+            /** How far below the apex the vault descends before it releases. */
+            vaultDropOnExit: number;
+            /** Forward speed handed back on a vault release (carries you over). */
+            vaultExitSpeed: number;
+            /** Downward speed handed back on a vault release (so you commit over). */
+            vaultExitDownSpeed: number;
         };
         wallRun: {
             /**
@@ -830,6 +990,14 @@ export class FirstPersonPlayerControllerConfig {
             pitchMinDeg: number;
             pitchMaxDeg: number;
             invertY: boolean;
+            /** 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: number;
         };
         posture: {
             /** Forward pitch (deg) applied to the eye at full sprint. Positive = look-down. */

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

@@ -1 +1 @@
-{"version":3,"file":"FirstPersonPlayerControllerConfig.d.ts","sourceRoot":"","sources":["../../../../../src/engine/control/first-person/FirstPersonPlayerControllerConfig.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"FirstPersonPlayerControllerConfig.d.ts","sourceRoot":"","sources":["../../../../../src/engine/control/first-person/FirstPersonPlayerControllerConfig.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH;IACI;QACI,qDAAqD;;QAErD,2BAA2B;;QAE3B;;yBAEiB;;QAEjB,8CAA8C;;QAE9C,iFAAiF;;QAEjF,oFAAoF;;QAEpF;;;;;;;WAOG;;QAEH;;;;;;;;;WASG;;MAEL;IAMF;;;;QAII,iEAAiE;;QAEjE;;;;;;;;;;;;;;;;;;;WAmBG;;QAEH,kEAAkE;;QAElE,oDAAoD;;QAEpD;;;;;WAKG;;QAEH;;;;WAIG;;MAEL;IAEF;QACI,2CAA2C;;QAE3C,sEAAsE;;;;QAItE,kDAAkD;;QAElD,iEAAiE;;;;;;MAMnE;IAEF;QACI,yDAAyD;;QAEzD,yDAAyD;;;YAGrD,oDAAoD;;YAEpD,0BAA0B;;;;gBAItB,mEAAmE;;;;MAI7E;IAEF;QACI,gEAAgE;;QAEhE,yBAAyB;;MAE3B;IAEF;;;;;;OAMG;IACH;QACI;;;;;WAKG;;QAEH;+EACuE;;QAEvE,4DAA4D;;QAE5D,0EAA0E;;QAE1E;kEAC0D;;MAE5D;IAEF;;;;OAIG;IACH;QACI,6EAA6E;;QAE7E,oDAAoD;;QAEpD;0DACkD;;MAEpD;IAEF;;;;;OAKG;IACH;QAMI;;iDAEyC;;QAEzC;mFAC2E;;QAE3E;yEACiE;;QAEjE;8EACsE;;QAEtE;wDACgD;;QAEhD;qCAC6B;;QAE7B;;;4CAGoC;;MAEtC;IAEF;;;;;;OAMG;IACH;QACI;;qBAEa;;QAEb;;;4DAGoD;;QAEpD;0EACkE;;QAElE;iEACyD;;QAEzD;;;gCAGwB;;QAOxB,yCAAyC;;QAEzC;0EACkE;;QAElE,0EAA0E;;QAE1E;;;;;+DAKuD;;QAEvD;;;;;;6CAMqC;;QAErC,2EAA2E;;QAE3E,2EAA2E;;QAE3E,uEAAuE;;QAEvE,6EAA6E;;QAE7E,4DAA4D;;QAE5D,sCAAsC;;QAEtC,sEAAsE;;QAEtE,gEAAgE;;MAElE;IAEF;;;;;;OAMG;IACH;QACI;oDAC4C;;QAE5C;;qEAE6D;;QAE7D;8DACsD;;QAEtD;;2BAEmB;;QAMnB;mFAC2E;;QAE3E,4EAA4E;;QAE5E,0DAA0D;;QAE1D,oEAAoE;;QAEpE,uEAAuE;;QAEvE,0EAA0E;;MAE5E;IAEF;;;;OAIG;IACH;QACI;;;;;;;;;;;;;;WAcG;;QAEH,oEAAoE;;QAEpE;qEAC6D;;QAE7D;;0EAEkE;;QAElE;;6CAEqC;;QAErC;4DACoD;;MAEtD;IAEF;;;;;QAKI,0DAA0D;;;QAG1D,sDAAsD;;QAEtD;;;;;;;WAOG;;QAEH;;;;;;;WAOG;;QAEH,qEAAqE;;QAErE;;;;;;WAMG;;QAEH;;;;;;;;;;;WAWG;;;;QAIH;;;;;;;;;WASG;;MAEL;IAEF;;;;;;;QAOI,8CAA8C;;QAE9C;;;;;;;;;;;;;;;;;;WAkBG;;QAEH;;6DAEqD;;MAEvD;IAEF;QAEI,wEAAwE;;QAExE,+DAA+D;;QAI/D,+DAA+D;;QAE/D;yEACiE;;QAEjE;;;;;WAKG;;QAEH,yDAAyD;;QAIzD,sEAAsE;;QAEtE,2EAA2E;;QAI3E;yEACiE;;QAEjE;qEAC6D;;QAE7D,sDAAsD;;MAExD;IAEF;;QAEI,kDAAkD;;;;;;QAGlD;;;WAGG;;QAEH;;;;WAIG;;QAEH;gEACwD;;QAExD;;;;;;;WAOG;;MAEL;IAEF;;;;;MAKE;IAEF;;;;QAII;;;;;;2DAMmD;;MAErD;IAEF;;;;;;;OAOG;IACH;QACI,mFAAmF;;QAEnF,wDAAwD;;QAExD,iFAAiF;;MAEnF;IAEF;QACI;;mEAE2D;;MAE7D;IAEF;;YAlkBI,qDAAqD;;YAErD,2BAA2B;;YAE3B;;6BAEiB;;YAEjB,8CAA8C;;YAE9C,iFAAiF;;YAEjF,oFAAoF;;YAEpF;;;;;;;eAOG;;YAEH;;;;;;;;;eASG;;;;;;;YAYH,iEAAiE;;YAEjE;;;;;;;;;;;;;;;;;;;eAmBG;;YAEH,kEAAkE;;YAElE,oDAAoD;;YAEpD;;;;;eAKG;;YAEH;;;;eAIG;;;;;;;;YAKH,2CAA2C;;YAE3C,sEAAsE;;;;YAItE,kDAAkD;;YAElD,iEAAiE;;;;;;;oBAoBzD,mEAAmE;;;gBANvE,oDAAoD;;gBAEpD,0BAA0B;;;YAP9B,yDAAyD;;YAEzD,yDAAyD;;;;YAgBzD,gEAAgE;;YAEhE,yBAAyB;;;;YA4FzB;;yBAEa;;YAEb;;;gEAGoD;;YAEpD;8EACkE;;YAElE;qEACyD;;YAEzD;;;oCAGwB;;YAOxB,yCAAyC;;YAEzC;8EACkE;;YAElE,0EAA0E;;YAE1E;;;;;mEAKuD;;YAEvD;;;;;;iDAMqC;;YAErC,2EAA2E;;YAE3E,2EAA2E;;YAE3E,uEAAuE;;YAEvE,6EAA6E;;YAE7E,4DAA4D;;YAE5D,sCAAsC;;YAEtC,sEAAsE;;YAEtE,gEAAgE;;;;YAYhE;wDAC4C;;YAE5C;;yEAE6D;;YAE7D;kEACsD;;YAEtD;;+BAEmB;;YAMnB;uFAC2E;;YAE3E,4EAA4E;;YAE5E,0DAA0D;;YAE1D,oEAAoE;;YAEpE,uEAAuE;;YAEvE,0EAA0E;;;;YAtL1E;;;;;eAKG;;YAEH;mFACuE;;YAEvE,4DAA4D;;YAE5D,0EAA0E;;YAE1E;sEAC0D;;;;YAU1D,6EAA6E;;YAE7E,oDAAoD;;YAEpD;8DACkD;;;;YAkKlD;;;;;;;;;;;;;;eAcG;;YAEH,oEAAoE;;YAEpE;yEAC6D;;YAE7D;;8EAEkE;;YAElE;;iDAEqC;;YAErC;gEACoD;;;;;;;;YASpD,0DAA0D;;;YAG1D,sDAAsD;;YAEtD;;;;;;;eAOG;;YAEH;;;;;;;eAOG;;YAEH,qEAAqE;;YAErE;;;;;;eAMG;;YAEH;;;;;;;;;;;eAWG;;;;YAIH;;;;;;;;;eASG;;;;;;;;;;YAWH,8CAA8C;;YAE9C;;;;;;;;;;;;;;;;;;eAkBG;;YAEH;;iEAEqD;;;;YAMrD,wEAAwE;;YAExE,+DAA+D;;YAI/D,+DAA+D;;YAE/D;6EACiE;;YAEjE;;;;;eAKG;;YAEH,yDAAyD;;YAIzD,sEAAsE;;YAEtE,2EAA2E;;YAI3E;6EACiE;;YAEjE;yEAC6D;;YAE7D,sDAAsD;;;;;;;;;YAMtD,kDAAkD;;YAGlD;;;eAGG;;YAEH;;;;eAIG;;YAEH;oEACwD;;YAExD;;;;;;;eAOG;;;;;;;;;;;;;YAeH;;;;;;+DAMmD;;;;YAanD,mFAAmF;;YAEnF,wDAAwD;;YAExD,iFAAiF;;;;YAKjF;;uEAE2D;;;MA+B9D;IAED,0BAmCC;IAED;;OAEG;IACH,YAFW,iCAAiC,QAI3C;IAED,2CAIC;CACJ"}

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