@woosh/meep-engine 2.169.4 → 2.170.0

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

@@ -1 +1 @@
-{"version":3,"file":"Mantle.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/control/first-person/abilities/Mantle.js"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH;IAOQ,6CAA6C;IAC7C,WAAW;IACX,uCAAuC;IACvC,kBAAoB;IACpB,gBAAgB;IAChB,gBAAgB;IAChB,gBAAgB;IAChB,cAAc;IACd,cAAc;IACd,cAAc;IACd;;0EAEsE;IACtE,cAAqB;IACrB,8CAA8C;IAC9C,eAAe;IAGnB,kEAgCC;IAED,gDAiEC;IAED,wBAGC;IAED,wFA0DC;IAED,oDAEC;CACJ;wBA1OuB,cAAc"}
+{"version":3,"file":"Mantle.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/control/first-person/abilities/Mantle.js"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH;IAKI,6CAA6C;IAC7C,WAAO;IAEP,uCAAuC;IACvC,kBAAgB;IAEhB,gBAAY;IACZ,gBAAY;IACZ,gBAAY;IACZ,cAAU;IACV,cAAU;IACV,cAAU;IAEV;;0EAEsE;IACtE,cAAiB;IAEjB,8CAA8C;IAC9C,eAAW;IAEX,kEAgCC;IAED,gDAiEC;IAED,wBAGC;IAED,wFA0DC;IAED,oDAEC;CACJ;wBA3OuB,cAAc"}

package/src/engine/control/first-person/abilities/Mantle.js

@@ -42,29 +42,30 @@ const easeInCubic = TransitionFunctions.EaseInCubic;
  * @copyright Company Named Limited (c) 2026
  */
 export class Mantle extends Ability {
-    constructor() {
-        super();
-        this.name = "Mantle";
-        this.priority = 30;
-
-        // -- per-instance scripted-path state --
-        /** @private Elapsed fraction of duration. */
-        this._t = 0;
-        /** @private Captured at activation. */
-        this._duration = 0.5;
-        this._startX = 0;
-        this._startY = 0;
-        this._startZ = 0;
-        this._endX = 0;
-        this._endY = 0;
-        this._endZ = 0;
-        /** @private "mantle" = climb ONTO a standable top (lands grounded);
-         *  "vault" = pull up and OVER a too-thin top (releases airborne on the
-         *  far side). Chosen in onActivate from the ledge-pull-up request. */
-        this._kind = "mantle";
-        /** @private Apex height of the vault hump. */
-        this._apexY = 0;
-    }
+    name = "Mantle";
+    priority = 30;
+
+    // -- per-instance scripted-path state --
+    /** @private Elapsed fraction of duration. */
+    _t = 0;
+
+    /** @private Captured at activation. */
+    _duration = 0.5;
+
+    _startX = 0;
+    _startY = 0;
+    _startZ = 0;
+    _endX = 0;
+    _endY = 0;
+    _endZ = 0;
+
+    /** @private "mantle" = climb ONTO a standable top (lands grounded);
+     *  "vault" = pull up and OVER a too-thin top (releases airborne on the
+     *  far side). Chosen in onActivate from the ledge-pull-up request. */
+    _kind = "mantle";
+
+    /** @private Apex height of the vault hump. */
+    _apexY = 0;
 
     canActivate(controller, runtime, sensors) {
         const cfg = controller.config.mantle;

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

@@ -1 +1 @@
-{"version":3,"file":"ScrambleUp.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/control/first-person/abilities/ScrambleUp.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH;IAMQ,4EAA4E;IAC5E,YAAY;IACZ,YAAY;IACZ,yCAAyC;IACzC,iBAAiB;IAGrB,kEAiBC;IAED,gDAgCC;IAED,wBAIC;IAED,uFAwDC;CACJ;wBAnLuB,cAAc"}
+{"version":3,"file":"ScrambleUp.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/control/first-person/abilities/ScrambleUp.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH;IAII,4EAA4E;IAC5E,YAAQ;IAER,YAAQ;IAER,yCAAyC;IACzC,iBAAa;IAEb,kEAiBC;IAED,gDAgCC;IAED,wBAIC;IAED,uFAwDC;CACJ;wBAlLuB,cAAc"}

package/src/engine/control/first-person/abilities/ScrambleUp.js

@@ -1,182 +1,181 @@
-import { launchVelocityForForce } from "../math/jumpDynamics.js";
-import { FirstPersonPosture } from "../pose/FirstPersonPosture.js";
-import { Ability } from "./Ability.js";
-
-/**
- * Scramble-up ability — a short vertical wall-run up a wall the player JUMPS
- * at while facing it, à la Assassin's Creed. A deliberate jump (not just
- * walking into the wall) launches a brief upward climb; a running start gives
- * higher purchase, so the player can reach a high ledge to grab, or kick off.
- *
- * Activation:
- *   - A fresh JUMP press (rising edge). A scramble is a deliberate jump at the
- *     wall — and the edge means it can't auto-loop scramble→fall→land→scramble:
- *     each one needs its own press.
- *   - Grounded — a ground-initiated move: run or stand AT the wall and jump.
- *   - `sensors.wallFront.hit` + `!sensors.ledgeAhead.hit` — facing a wall whose
- *     top is OUT of mantle/grab reach (a reachable top is Mantle's job; this
- *     makes the two mutually exclusive).
- *   - Forward intent (`intent.move.y > 0.5`) — committed into the wall, so a
- *     plain jump near a wall (no forward) is still just a jump.
- *
- * Behaviour:
- *   - Launches upward off a physical PUSH-OFF FORCE: `baseJumpForce` + the
- *     horizontal approach speed × `momentumForcePerSpeed` (capped at
- *     `maxJumpForce`), converted to a launch velocity through the body's mass +
- *     push-off distance (see {@link jumpDynamics}). A running start climbs high,
- *     a standstill gives a small hop, and a heavier character scrambles lower
- *     for the same force — just like a jump. Horizontal velocity is replaced by
- *     a small into-wall "hug" so the body climbs the face (the mover clips the
- *     penetration). The climb DECELERATES (`decel`): a short burst, roughly
- *     `launchVy²/(2·decel)` m high over `launchVy/decel` s.
- *   - Motion routes through the shared mover, so the climb is collision-checked
- *     and the ledge sensors update as the body rises.
- *
- * Exit:
- *   - Apex (`velocityY <= 0`) → release. If a ledge is now within reach,
- *     LedgeGrab (which needs a descent) catches on the way down; otherwise the
- *     player falls back.
- *   - A SECOND jump press (released then re-pressed during the climb) → WALL-
- *     KICK off the front wall: impulse out along the normal, plus an upward
- *     launch off the body's full jump push-off force (`runtime.jumpForce`) — so
- *     the kick rises like a max-height jump. The front-wall counterpart of
- *     wall-run → wall-jump.
- *   - Lost the wall (`!wallFront.hit`) → reached the top (or it ended); release.
- *   - Timer (`maxDuration`) or re-grounded → release.
- *
- * Priority 55 — above wall-run (50, an ALONG-wall move) and below wall-jump
- * (60). It hands off to LedgeGrab (40) via the apex→descent.
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export class ScrambleUp extends Ability {
-    constructor() {
-        super();
-        this.name = "ScrambleUp";
-        this.priority = 55;
-
-        /** @private Captured wall outward normal (x,z) — for the hug + the kick. */
-        this._nx = 0;
-        this._nz = 0;
-        /** @private Seconds since activation. */
-        this._elapsed = 0;
-    }
-
-    canActivate(controller, runtime, sensors) {
-        const cfg = controller.config.scrambleUp;
-        if (!cfg) return false;
-        if (sensors === undefined || sensors === null) return false;
-
-        // A deliberate JUMP at the wall starts a scramble — walking into it is
-        // not enough. The fresh-press edge is also what prevents an automatic
-        // scramble→fall→land→scramble loop: each one needs its own press.
-        if (!controller.intent.jump || runtime.prevJumpHeld) return false;
-        // Ground-initiated: run or stand AT the wall and jump.
-        if (!controller.state.grounded) return false;
-        // Facing a wall whose top is out of reach, committed forward into it.
-        if (!sensors.wallFront.hit) return false;
-        if (sensors.ledgeAhead.hit) return false;
-        if (controller.intent.move.y <= 0.5) return false;
-
-        return true;
-    }
-
-    onActivate(controller, runtime) {
-        const cfg = controller.config.scrambleUp;
-        const sensors = runtime.sensors;
-        this._elapsed = 0;
-        this._nx = sensors.wallFront.normal.x;
-        this._nz = sensors.wallFront.normal.z;
-
-        // Reward forward momentum: the leg PUSH-OFF FORCE scales with the
-        // horizontal approach speed at the jump — a standstill gives the base
-        // force, a full sprint run-up the capped maximum. The force becomes a
-        // launch velocity through the body's mass + push-off distance, so a
-        // heavier character scrambles lower for the same effort (like a jump).
-        const body = controller.config.body;
-        const approach = Math.hypot(runtime.velocityX, runtime.velocityZ);
-        const force = Math.min(cfg.baseJumpForce + approach * cfg.momentumForcePerSpeed, cfg.maxJumpForce);
-        const launchVy = launchVelocityForForce(force, body.mass, body.jumpPushoffDistance);
-
-        runtime.velocityY = launchVy;
-        runtime.velocityX = -this._nx * cfg.hugSpeed;
-        runtime.velocityZ = -this._nz * cfg.hugSpeed;
-
-        // Climbing — airborne; clear any in-progress jump state.
-        controller.state.grounded = false;
-        runtime.midJump = false;
-        runtime.apexFired = false;
-        controller.state.isVariableJumpCut = false;
-        controller.state.isAscending = true;
-        // Consume the launch press so the first tick's wall-kick edge doesn't
-        // fire on it — the kick is a SEPARATE press during the climb.
-        runtime.prevJumpHeld = true;
-
-        controller.signals.onLeaveGround.send1({ reason: "scramble" });
-    }
-
-    canInterrupt() {
-        // Wall-jump (60) is the only higher-priority ability; the scramble's own
-        // jump-kick consumes the press first, so a preempt never lands.
-        return true;
-    }
-
-    tick(controller, runtime, bodyTransform, dt, system) {
-        const cfg = controller.config.scrambleUp;
-        const sensors = runtime.sensors;
-        const intent = controller.intent;
-        this._elapsed += dt;
-
-        // Climbing upright; body pinned to the wall — no lean.
-        controller.state.posture = FirstPersonPosture.Stand;
-        runtime.leanTargetRad = 0;
-
-        // -- Exit: timer (safety; the apex normally releases first).
-        if (this._elapsed >= cfg.maxDuration) return false;
-
-        // -- Exit: a FRESH jump press (released then re-pressed since the launch)
-        //    → WALL-KICK off the front wall (out along the normal + up).
-        if (intent.jump && !runtime.prevJumpHeld) {
-            const body = controller.config.body;
-            runtime.velocityX += this._nx * cfg.kickOutwardImpulse;
-            runtime.velocityZ += this._nz * cfg.kickOutwardImpulse;
-            // Up off the wall with the SAME push-off force as a max-height jump
-            // (runtime.jumpForce), converted through this body — so the kick's
-            // vertical launch equals a full jump's, not a reduced fraction.
-            runtime.velocityY = launchVelocityForForce(runtime.jumpForce, body.mass, body.jumpPushoffDistance);
-            runtime.prevJumpHeld = true;
-            runtime.midJump = true;
-            controller.state.isVariableJumpCut = false;
-            controller.state.isAscending = true;
-            controller.signals.onJumpStart.send1({ peakHeight: controller.config.jump.peakHeight });
-            controller.signals.onLeaveGround.send1({ reason: "scramble-kick" });
-            return false;
-        }
-        // Track the jump button so a release→re-press reads as a fresh edge next
-        // tick (base, which normally owns this, isn't running while we do).
-        runtime.prevJumpHeld = intent.jump;
-
-        // -- Exit: lost the wall — reached the top (or it ended).
-        if (!sensors.wallFront.hit) return false;
-
-        // -- Decelerate the climb; release at the apex. On the way down LedgeGrab
-        //    catches if a ledge is now in reach, else the player falls back.
-        runtime.velocityY -= cfg.decel * dt;
-        if (runtime.velocityY <= 0) return false;
-
-        // Hug the wall while climbing (re-assert each tick; the mover clips it).
-        runtime.velocityX = -this._nx * cfg.hugSpeed;
-        runtime.velocityZ = -this._nz * cfg.hugSpeed;
-
-        // Resolve the climb through the shared mover (sweep-and-slide + ground/
-        // ledge categorize). Gravity is NOT re-applied — the scramble owns the
-        // vertical model, like wall-run.
-        system._resolveMotion(controller, runtime, bodyTransform, dt);
-
-        // -- Exit: the mover caught a floor (shouldn't happen rising, but safe).
-        if (controller.state.grounded) return false;
-
-        return true;
-    }
-}
+import { launchVelocityForForce } from "../math/jumpDynamics.js";
+import { FirstPersonPosture } from "../pose/FirstPersonPosture.js";
+import { Ability } from "./Ability.js";
+
+/**
+ * Scramble-up ability — a short vertical wall-run up a wall the player JUMPS
+ * at while facing it, à la Assassin's Creed. A deliberate jump (not just
+ * walking into the wall) launches a brief upward climb; a running start gives
+ * higher purchase, so the player can reach a high ledge to grab, or kick off.
+ *
+ * Activation:
+ *   - A fresh JUMP press (rising edge). A scramble is a deliberate jump at the
+ *     wall — and the edge means it can't auto-loop scramble→fall→land→scramble:
+ *     each one needs its own press.
+ *   - Grounded — a ground-initiated move: run or stand AT the wall and jump.
+ *   - `sensors.wallFront.hit` + `!sensors.ledgeAhead.hit` — facing a wall whose
+ *     top is OUT of mantle/grab reach (a reachable top is Mantle's job; this
+ *     makes the two mutually exclusive).
+ *   - Forward intent (`intent.move.y > 0.5`) — committed into the wall, so a
+ *     plain jump near a wall (no forward) is still just a jump.
+ *
+ * Behaviour:
+ *   - Launches upward off a physical PUSH-OFF FORCE: `baseJumpForce` + the
+ *     horizontal approach speed × `momentumForcePerSpeed` (capped at
+ *     `maxJumpForce`), converted to a launch velocity through the body's mass +
+ *     push-off distance (see {@link jumpDynamics}). A running start climbs high,
+ *     a standstill gives a small hop, and a heavier character scrambles lower
+ *     for the same force — just like a jump. Horizontal velocity is replaced by
+ *     a small into-wall "hug" so the body climbs the face (the mover clips the
+ *     penetration). The climb DECELERATES (`decel`): a short burst, roughly
+ *     `launchVy²/(2·decel)` m high over `launchVy/decel` s.
+ *   - Motion routes through the shared mover, so the climb is collision-checked
+ *     and the ledge sensors update as the body rises.
+ *
+ * Exit:
+ *   - Apex (`velocityY <= 0`) → release. If a ledge is now within reach,
+ *     LedgeGrab (which needs a descent) catches on the way down; otherwise the
+ *     player falls back.
+ *   - A SECOND jump press (released then re-pressed during the climb) → WALL-
+ *     KICK off the front wall: impulse out along the normal, plus an upward
+ *     launch off the body's full jump push-off force (`runtime.jumpForce`) — so
+ *     the kick rises like a max-height jump. The front-wall counterpart of
+ *     wall-run → wall-jump.
+ *   - Lost the wall (`!wallFront.hit`) → reached the top (or it ended); release.
+ *   - Timer (`maxDuration`) or re-grounded → release.
+ *
+ * Priority 55 — above wall-run (50, an ALONG-wall move) and below wall-jump
+ * (60). It hands off to LedgeGrab (40) via the apex→descent.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class ScrambleUp extends Ability {
+    name = "ScrambleUp";
+    priority = 55;
+
+    /** @private Captured wall outward normal (x,z) — for the hug + the kick. */
+    _nx = 0;
+
+    _nz = 0;
+
+    /** @private Seconds since activation. */
+    _elapsed = 0;
+
+    canActivate(controller, runtime, sensors) {
+        const cfg = controller.config.scrambleUp;
+        if (!cfg) return false;
+        if (sensors === undefined || sensors === null) return false;
+
+        // A deliberate JUMP at the wall starts a scramble — walking into it is
+        // not enough. The fresh-press edge is also what prevents an automatic
+        // scramble→fall→land→scramble loop: each one needs its own press.
+        if (!controller.intent.jump || runtime.prevJumpHeld) return false;
+        // Ground-initiated: run or stand AT the wall and jump.
+        if (!controller.state.grounded) return false;
+        // Facing a wall whose top is out of reach, committed forward into it.
+        if (!sensors.wallFront.hit) return false;
+        if (sensors.ledgeAhead.hit) return false;
+        if (controller.intent.move.y <= 0.5) return false;
+
+        return true;
+    }
+
+    onActivate(controller, runtime) {
+        const cfg = controller.config.scrambleUp;
+        const sensors = runtime.sensors;
+        this._elapsed = 0;
+        this._nx = sensors.wallFront.normal.x;
+        this._nz = sensors.wallFront.normal.z;
+
+        // Reward forward momentum: the leg PUSH-OFF FORCE scales with the
+        // horizontal approach speed at the jump — a standstill gives the base
+        // force, a full sprint run-up the capped maximum. The force becomes a
+        // launch velocity through the body's mass + push-off distance, so a
+        // heavier character scrambles lower for the same effort (like a jump).
+        const body = controller.config.body;
+        const approach = Math.hypot(runtime.velocityX, runtime.velocityZ);
+        const force = Math.min(cfg.baseJumpForce + approach * cfg.momentumForcePerSpeed, cfg.maxJumpForce);
+        const launchVy = launchVelocityForForce(force, body.mass, body.jumpPushoffDistance);
+
+        runtime.velocityY = launchVy;
+        runtime.velocityX = -this._nx * cfg.hugSpeed;
+        runtime.velocityZ = -this._nz * cfg.hugSpeed;
+
+        // Climbing — airborne; clear any in-progress jump state.
+        controller.state.grounded = false;
+        runtime.midJump = false;
+        runtime.apexFired = false;
+        controller.state.isVariableJumpCut = false;
+        controller.state.isAscending = true;
+        // Consume the launch press so the first tick's wall-kick edge doesn't
+        // fire on it — the kick is a SEPARATE press during the climb.
+        runtime.prevJumpHeld = true;
+
+        controller.signals.onLeaveGround.send1({ reason: "scramble" });
+    }
+
+    canInterrupt() {
+        // Wall-jump (60) is the only higher-priority ability; the scramble's own
+        // jump-kick consumes the press first, so a preempt never lands.
+        return true;
+    }
+
+    tick(controller, runtime, bodyTransform, dt, system) {
+        const cfg = controller.config.scrambleUp;
+        const sensors = runtime.sensors;
+        const intent = controller.intent;
+        this._elapsed += dt;
+
+        // Climbing upright; body pinned to the wall — no lean.
+        controller.state.posture = FirstPersonPosture.Stand;
+        runtime.leanTargetRad = 0;
+
+        // -- Exit: timer (safety; the apex normally releases first).
+        if (this._elapsed >= cfg.maxDuration) return false;
+
+        // -- Exit: a FRESH jump press (released then re-pressed since the launch)
+        //    → WALL-KICK off the front wall (out along the normal + up).
+        if (intent.jump && !runtime.prevJumpHeld) {
+            const body = controller.config.body;
+            runtime.velocityX += this._nx * cfg.kickOutwardImpulse;
+            runtime.velocityZ += this._nz * cfg.kickOutwardImpulse;
+            // Up off the wall with the SAME push-off force as a max-height jump
+            // (runtime.jumpForce), converted through this body — so the kick's
+            // vertical launch equals a full jump's, not a reduced fraction.
+            runtime.velocityY = launchVelocityForForce(runtime.jumpForce, body.mass, body.jumpPushoffDistance);
+            runtime.prevJumpHeld = true;
+            runtime.midJump = true;
+            controller.state.isVariableJumpCut = false;
+            controller.state.isAscending = true;
+            controller.signals.onJumpStart.send1({ peakHeight: controller.config.jump.peakHeight });
+            controller.signals.onLeaveGround.send1({ reason: "scramble-kick" });
+            return false;
+        }
+        // Track the jump button so a release→re-press reads as a fresh edge next
+        // tick (base, which normally owns this, isn't running while we do).
+        runtime.prevJumpHeld = intent.jump;
+
+        // -- Exit: lost the wall — reached the top (or it ended).
+        if (!sensors.wallFront.hit) return false;
+
+        // -- Decelerate the climb; release at the apex. On the way down LedgeGrab
+        //    catches if a ledge is now in reach, else the player falls back.
+        runtime.velocityY -= cfg.decel * dt;
+        if (runtime.velocityY <= 0) return false;
+
+        // Hug the wall while climbing (re-assert each tick; the mover clips it).
+        runtime.velocityX = -this._nx * cfg.hugSpeed;
+        runtime.velocityZ = -this._nz * cfg.hugSpeed;
+
+        // Resolve the climb through the shared mover (sweep-and-slide + ground/
+        // ledge categorize). Gravity is NOT re-applied — the scramble owns the
+        // vertical model, like wall-run.
+        system._resolveMotion(controller, runtime, bodyTransform, dt);
+
+        // -- Exit: the mover caught a floor (shouldn't happen rising, but safe).
+        if (controller.state.grounded) return false;
+
+        return true;
+    }
+}

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

@@ -1 +1 @@
-{"version":3,"file":"Slide.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/control/first-person/abilities/Slide.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IAOQ,gEAAgE;IAChE,0BAA0B;IAG9B,mEAuBC;IAED,gDAuBC;IAED,uDAGC;IAED,uFAmEC;IAED,oDAEC;CACJ;wBAlKuB,cAAc"}
+{"version":3,"file":"Slide.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/control/first-person/abilities/Slide.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IAMI,gEAAgE;IAChE,0BAAsB;IAEtB,mEAuBC;IAED,gDAuBC;IAED,uDAGC;IAED,uFAmEC;IAED,oDAEC;CACJ;wBAhKuB,cAAc"}