@woosh/meep-engine 2.146.0 → 2.148.0

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

@@ -1,175 +1,183 @@
-import { DEG_TO_RAD } from "../../../../core/math/DEG_TO_RAD.js";
-import { Ability } from "./Ability.js";
-
-/**
- * Wall-run ability. Activates when the player is airborne with momentum
- * and a wall is detected to their left or right. While active:
- *
- *   - Gravity is reduced to `cfg.wallRun.gravityFactor × base` (typically
- *     25%), letting the player hang on the wall for longer than a normal
- *     jump arc.
- *   - Horizontal velocity is projected onto the wall's tangent each tick,
- *     so the body sticks to the wall and slides along it. Forward
- *     momentum is preserved; into-wall and out-of-wall velocity
- *     components are zeroed.
- *   - Camera tilts into the wall via the shared lean spring (writes the
- *     wall-tilt to `runtime.leanTargetRad` each tick — same channel
- *     base writes its lat-accel-derived lean to, so transitions in and
- *     out share the spring's smoothing).
- *
- * Exits on:
- *   - Timer (`cfg.wallRun.maxDuration`)
- *   - Lost wall contact (sensor's hit flag becomes false)
- *   - Re-grounded (we walked onto a floor at the wall's end)
- *   - Wall-jump preempts (higher priority — WallJump declares priority 60)
- *
- * Priority 50 — above Mantle (30), Slide (10), below Wall-jump (60).
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export class WallRun extends Ability {
-    constructor() {
-        super();
-        this.name = "WallRun";
-        this.priority = 50;
-
-        /** @private Seconds since this ability activated. */
-        this._elapsed = 0;
-        /** @private "L" or "R" — which wall we're running on. */
-        this._side = "L";
-    }
-
-    canActivate(controller, runtime, sensors) {
-        const cfg = controller.config.wallRun;
-        if (!cfg) return false;
-        if (sensors === undefined || sensors === null) return false;
-        if (controller.state.grounded) return false;
-        if (controller.state.airborneTime < cfg.minAirborneTime) return false;
-
-        const speed = Math.hypot(runtime.velocityX, runtime.velocityZ);
-        if (speed < cfg.minSpeed) return false;
-
-        // Need a wall on left OR right (not front — that's a wall to bump into).
-        if (!sensors.wallLeft.hit && !sensors.wallRight.hit) return false;
-
-        // Forward intent required — wall-run is a committed action.
-        if (controller.intent.move.y < 0.1) return false;
-
-        // Don't (re)grab a wall you're moving AWAY from. The wall normal
-        // points off the wall toward the player, so velocity·normal > 0 means
-        // leaving it — most importantly right after a wall-JUMP pushed you off
-        // (else the run would re-attach next tick and the tangent projection
-        // would cancel the kick). Approaching (dot < 0) or running along it
-        // (dot ≈ 0) is fine.
-        const hit = sensors.wallLeft.hit
-            && (!sensors.wallRight.hit || sensors.wallLeft.distance <= sensors.wallRight.distance)
-            ? sensors.wallLeft : sensors.wallRight;
-        const awaySpeed = runtime.velocityX * hit.normal.x + runtime.velocityZ * hit.normal.z;
-        if (awaySpeed > cfg.minSpeed * 0.5) return false;
-
-        return true;
-    }
-
-    onActivate(controller, runtime) {
-        const sensors = runtime.sensors;
-        this._elapsed = 0;
-
-        // Pick the closer wall if both detected.
-        if (sensors.wallLeft.hit
-            && (!sensors.wallRight.hit
-                || sensors.wallLeft.distance <= sensors.wallRight.distance)) {
-            this._side = "L";
-        } else {
-            this._side = "R";
-        }
-
-        // Clear any in-progress jump state — the wall-run takes over the
-        // vertical model.
-        runtime.midJump = false;
-        runtime.apexFired = false;
-        controller.state.isVariableJumpCut = false;
-        controller.state.isAscending = false;
-
-        controller.signals.onLeaveGround.send1({ reason: "wallrun" });
-    }
-
-    /**
-     * Wall-jump (priority 60) should be allowed to preempt freely; that's
-     * the canonical chain (wall-run → wall-jump). Any other higher-priority
-     * ability is also fine — wall-run is a transient state.
-     */
-    canInterrupt() {
-        return true;
-    }
-
-    tick(controller, runtime, bodyTransform, dt, system) {
-        const cfg = controller.config.wallRun;
-        this._elapsed += dt;
-
-        // -- Exit: timer.
-        if (this._elapsed >= cfg.maxDuration) {
-            return false;
-        }
-        // -- Exit: re-grounded (we ran onto a floor).
-        if (controller.state.grounded) {
-            return false;
-        }
-
-        const sensors = runtime.sensors;
-        const sensorHit = this._side === "L" ? sensors.wallLeft : sensors.wallRight;
-
-        // -- Exit: lost the wall.
-        if (!sensorHit.hit) {
-            return false;
-        }
-
-        // -- Project velocity onto the wall's tangent.
-        // The wall's normal is in the XZ plane (vertical wall). Zero the
-        // component of velocity along that normal. Forward momentum
-        // (along the wall's tangent direction) is preserved.
-        const nx = sensorHit.normal.x;
-        const nz = sensorHit.normal.z;
-        const dotN = runtime.velocityX * nx + runtime.velocityZ * nz;
-        runtime.velocityX -= dotN * nx;
-        runtime.velocityZ -= dotN * nz;
-
-        // -- Camera roll: write directly to the shared lean target.
-        // Sign convention: positive engine roll = head tilts RIGHT. Wall
-        // on LEFT → tilt LEFT → negative roll. Wall on RIGHT → tilt
-        // RIGHT → positive roll. L2.f spring-steps from this value each
-        // tick; base will overwrite once the ability releases, and the
-        // spring smooths the transition.
-        const rollSign = this._side === "L" ? -1 : 1;
-        runtime.leanTargetRad = rollSign * cfg.cameraRollDeg * DEG_TO_RAD;
-
-        // -- Reduced gravity. This is wall-run's OWN vertical model (a
-        // fraction of base gravity, no fall multiplier), applied here rather
-        // than via the system's standard gravity step.
-        runtime.velocityY -= runtime.gravity * cfg.gravityFactor * dt;
-
-        // -- Resolve the move through the shared motor. With the reduced-
-        // gravity velocity set above, route it through the same sweep-and-
-        // slide + ground-categorize the base locomotion uses (the mover when
-        // physics is present, else the flat-ground fallback). _resolveMotion
-        // does NOT re-apply gravity. This replaces a raw `position._add` plus
-        // a hand-rolled groundResolver catch: the wall-runner now (a) can't
-        // drift INTO geometry (the sweep clips it) nor sail OFF a ledge the
-        // mover would have caught, and (b) gets the motor's anti-tunnel
-        // ground catch for free — the same reason base no longer free-falls
-        // past a floor. The motor sets `state.grounded` and fires land/leave.
-        system._resolveMotion(controller, runtime, bodyTransform, dt);
-
-        // -- Exit: the motor caught a floor at the wall's foot (we ran out
-        // onto the ground). Release; base resumes next tick.
-        if (controller.state.grounded) {
-            return false;
-        }
-
-        return true;
-    }
-
-    // No onDeactivate cleanup needed: on the tick we release, base runs
-    // and overwrites runtime.leanTargetRad with the natural value. The
-    // lean spring smooths the transition.
-}
+import { DEG_TO_RAD } from "../../../../core/math/DEG_TO_RAD.js";
+import { Ability } from "./Ability.js";
+
+/**
+ * Wall-run ability. Activates when the player is airborne with momentum
+ * and a wall is detected to their left or right. While active:
+ *
+ *   - Gravity is reduced to `cfg.wallRun.gravityFactor × base` (typically
+ *     25%), letting the player hang on the wall for longer than a normal
+ *     jump arc.
+ *   - Horizontal velocity is projected onto the wall's tangent each tick,
+ *     so the body sticks to the wall and slides along it. Forward
+ *     momentum is preserved; into-wall and out-of-wall velocity
+ *     components are zeroed.
+ *   - Camera tilts into the wall via the shared lean spring (writes the
+ *     wall-tilt to `runtime.leanTargetRad` each tick — same channel
+ *     base writes its lat-accel-derived lean to, so transitions in and
+ *     out share the spring's smoothing).
+ *
+ * Exits on:
+ *   - Timer (`cfg.wallRun.maxDuration`)
+ *   - Lost wall contact (sensor's hit flag becomes false)
+ *   - Re-grounded (we walked onto a floor at the wall's end)
+ *   - Wall-jump preempts (higher priority — WallJump declares priority 60)
+ *
+ * Priority 50 — above Mantle (30), Slide (10), below Wall-jump (60).
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class WallRun extends Ability {
+    constructor() {
+        super();
+        this.name = "WallRun";
+        this.priority = 50;
+
+        /** @private Seconds since this ability activated. */
+        this._elapsed = 0;
+        /** @private "L" or "R" — which wall we're running on. */
+        this._side = "L";
+    }
+
+    canActivate(controller, runtime, sensors) {
+        const cfg = controller.config.wallRun;
+        if (!cfg) return false;
+        if (sensors === undefined || sensors === null) return false;
+        if (controller.state.grounded) return false;
+        if (controller.state.airborneTime < cfg.minAirborneTime) return false;
+
+        const speed = Math.hypot(runtime.velocityX, runtime.velocityZ);
+        if (speed < cfg.minSpeed) return false;
+
+        // Need a wall on left OR right (not front — that's a wall to bump into).
+        if (!sensors.wallLeft.hit && !sensors.wallRight.hit) return false;
+
+        // Don't (re)grab the wall when a grabbable ledge is right ahead: you've
+        // reached its top, so ledge-grab/mantle should take over (hang or
+        // vault) instead of the run re-attaching and riding you back DOWN the
+        // wall you just climbed. Only bites when facing INTO the wall (the
+        // forward probe has to hit for a ledge ahead), so a normal run ALONG
+        // the wall — facing down its length — is unaffected.
+        if (sensors.ledgeAhead.hit) return false;
+
+        // Forward intent required — wall-run is a committed action.
+        if (controller.intent.move.y < 0.1) return false;
+
+        // Don't (re)grab a wall you're moving AWAY from. The wall normal
+        // points off the wall toward the player, so velocity·normal > 0 means
+        // leaving it — most importantly right after a wall-JUMP pushed you off
+        // (else the run would re-attach next tick and the tangent projection
+        // would cancel the kick). Approaching (dot < 0) or running along it
+        // (dot ≈ 0) is fine.
+        const hit = sensors.wallLeft.hit
+            && (!sensors.wallRight.hit || sensors.wallLeft.distance <= sensors.wallRight.distance)
+            ? sensors.wallLeft : sensors.wallRight;
+        const awaySpeed = runtime.velocityX * hit.normal.x + runtime.velocityZ * hit.normal.z;
+        if (awaySpeed > cfg.minSpeed * 0.5) return false;
+
+        return true;
+    }
+
+    onActivate(controller, runtime) {
+        const sensors = runtime.sensors;
+        this._elapsed = 0;
+
+        // Pick the closer wall if both detected.
+        if (sensors.wallLeft.hit
+            && (!sensors.wallRight.hit
+                || sensors.wallLeft.distance <= sensors.wallRight.distance)) {
+            this._side = "L";
+        } else {
+            this._side = "R";
+        }
+
+        // Clear any in-progress jump state — the wall-run takes over the
+        // vertical model.
+        runtime.midJump = false;
+        runtime.apexFired = false;
+        controller.state.isVariableJumpCut = false;
+        controller.state.isAscending = false;
+
+        controller.signals.onLeaveGround.send1({ reason: "wallrun" });
+    }
+
+    /**
+     * Wall-jump (priority 60) should be allowed to preempt freely; that's
+     * the canonical chain (wall-run → wall-jump). Any other higher-priority
+     * ability is also fine — wall-run is a transient state.
+     */
+    canInterrupt() {
+        return true;
+    }
+
+    tick(controller, runtime, bodyTransform, dt, system) {
+        const cfg = controller.config.wallRun;
+        this._elapsed += dt;
+
+        // -- Exit: timer.
+        if (this._elapsed >= cfg.maxDuration) {
+            return false;
+        }
+        // -- Exit: re-grounded (we ran onto a floor).
+        if (controller.state.grounded) {
+            return false;
+        }
+
+        const sensors = runtime.sensors;
+        const sensorHit = this._side === "L" ? sensors.wallLeft : sensors.wallRight;
+
+        // -- Exit: lost the wall.
+        if (!sensorHit.hit) {
+            return false;
+        }
+
+        // -- Project velocity onto the wall's tangent.
+        // The wall's normal is in the XZ plane (vertical wall). Zero the
+        // component of velocity along that normal. Forward momentum
+        // (along the wall's tangent direction) is preserved.
+        const nx = sensorHit.normal.x;
+        const nz = sensorHit.normal.z;
+        const dotN = runtime.velocityX * nx + runtime.velocityZ * nz;
+        runtime.velocityX -= dotN * nx;
+        runtime.velocityZ -= dotN * nz;
+
+        // -- Camera roll: write directly to the shared lean target.
+        // Sign convention: positive engine roll = head tilts RIGHT. Wall
+        // on LEFT → tilt LEFT → negative roll. Wall on RIGHT → tilt
+        // RIGHT → positive roll. L2.f spring-steps from this value each
+        // tick; base will overwrite once the ability releases, and the
+        // spring smooths the transition.
+        const rollSign = this._side === "L" ? -1 : 1;
+        runtime.leanTargetRad = rollSign * cfg.cameraRollDeg * DEG_TO_RAD;
+
+        // -- Reduced gravity. This is wall-run's OWN vertical model (a
+        // fraction of base gravity, no fall multiplier), applied here rather
+        // than via the system's standard gravity step.
+        runtime.velocityY -= runtime.gravity * cfg.gravityFactor * dt;
+
+        // -- Resolve the move through the shared motor. With the reduced-
+        // gravity velocity set above, route it through the same sweep-and-
+        // slide + ground-categorize the base locomotion uses (the mover when
+        // physics is present, else the flat-ground fallback). _resolveMotion
+        // does NOT re-apply gravity. This replaces a raw `position._add` plus
+        // a hand-rolled groundResolver catch: the wall-runner now (a) can't
+        // drift INTO geometry (the sweep clips it) nor sail OFF a ledge the
+        // mover would have caught, and (b) gets the motor's anti-tunnel
+        // ground catch for free — the same reason base no longer free-falls
+        // past a floor. The motor sets `state.grounded` and fires land/leave.
+        system._resolveMotion(controller, runtime, bodyTransform, dt);
+
+        // -- Exit: the motor caught a floor at the wall's foot (we ran out
+        // onto the ground). Release; base resumes next tick.
+        if (controller.state.grounded) {
+            return false;
+        }
+
+        return true;
+    }
+
+    // No onDeactivate cleanup needed: on the tick we release, base runs
+    // and overwrites runtime.leanTargetRad with the natural value. The
+    // lean spring smooths the transition.
+}

package/src/engine/control/first-person/sensors/FirstPersonSensors.d.ts

@@ -51,6 +51,15 @@ export class FirstPersonSensors {
      * obstacle's top finds empty space, indicating a grabbable edge.
      */
     ledgeAhead: SensorHit;
+    /**
+     * True when `ledgeAhead`'s top surface is wide enough to STAND on
+     * (a standing capsule fits forward of the edge), false when it's a
+     * knife-edge / thin wall you could only hang from. Mantle reads this
+     * to refuse vaulting onto a top it would immediately fall off; ledge
+     * grab ignores it (you can hang from a thin edge). Default false so a
+     * mantle never fires on stale data.
+     */
+    ledgeStandable: boolean;
     /** Clear all sensor slots — call at the start of each tick. */
     clearAll(): void;
 }

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

@@ -1 +1 @@
-{"version":3,"file":"FirstPersonSensors.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/control/first-person/sensors/FirstPersonSensors.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH;IAEQ,aAAgB;IAChB,4DAA4D;IAC5D,iBAAiB;IACjB,iCAAiC;IACjC,eAA0B;IAC1B,yEAAyE;IACzE,gBAAkC;IAClC,6DAA6D;IAC7D,gBAAsB;IAG1B,mEAAmE;IACnE,cAMC;CACJ;AAED;;;;;;;;;;;;;;GAcG;AACH;IAEQ,2DAA2D;IAC3D,oBAA+B;IAC/B,4DAA4D;IAC5D,qBAAgC;IAChC,0CAA0C;IAC1C,qBAAgC;IAChC;;;;OAIG;IACH,yBAAoC;IACpC;;;;OAIG;IACH,sBAAiC;IAGrC,+DAA+D;IAC/D,iBAMC;CACJ;oBA5EmB,kCAAkC"}
+{"version":3,"file":"FirstPersonSensors.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/control/first-person/sensors/FirstPersonSensors.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH;IAEQ,aAAgB;IAChB,4DAA4D;IAC5D,iBAAiB;IACjB,iCAAiC;IACjC,eAA0B;IAC1B,yEAAyE;IACzE,gBAAkC;IAClC,6DAA6D;IAC7D,gBAAsB;IAG1B,mEAAmE;IACnE,cAMC;CACJ;AAED;;;;;;;;;;;;;;GAcG;AACH;IAEQ,2DAA2D;IAC3D,oBAA+B;IAC/B,4DAA4D;IAC5D,qBAAgC;IAChC,0CAA0C;IAC1C,qBAAgC;IAChC;;;;OAIG;IACH,yBAAoC;IACpC;;;;OAIG;IACH,sBAAiC;IACjC;;;;;;;OAOG;IACH,wBAA2B;IAG/B,+DAA+D;IAC/D,iBAOC;CACJ;oBAtFmB,kCAAkC"}

package/src/engine/control/first-person/sensors/FirstPersonSensors.js

@@ -1,77 +1,87 @@
-import Vector3 from "../../../../core/geom/Vector3.js";
-
-/**
- * Single spatial-query result. Set fields when `hit` is true; ignore them
- * otherwise. `surfaceTag` is optional — populated by future surface-tag
- * systems (grass/wood/metal/etc.) so abilities and audio can react to the
- * material.
- */
-export class SensorHit {
-    constructor() {
-        this.hit = false;
-        /** Distance from query origin to contact point (meters). */
-        this.distance = 0;
-        /** World-space contact point. */
-        this.point = new Vector3();
-        /** Surface normal at contact (unit vector, points away from surface). */
-        this.normal = new Vector3(0, 1, 0);
-        /** Optional material/surface tag — e.g. "grass", "metal". */
-        this.surfaceTag = null;
-    }
-
-    /** Reset to "no hit" — call before re-using the slot each tick. */
-    clear() {
-        this.hit = false;
-        this.distance = 0;
-        this.point.set(0, 0, 0);
-        this.normal.set(0, 1, 0);
-        this.surfaceTag = null;
-    }
-}
-
-/**
- * Cached spatial-query results for one first-person controller. Populated
- * by {@link FirstPersonSensorsSystem} once per fixed step, read by
- * abilities and (where useful) by the base controller.
- *
- * The point of cacheing is dedup: mantle and ledge-grab both want a
- * "forward + up obstacle probe". Compute once, both read the cached hit.
- *
- * Sensor slots cleared each tick before population. Abilities should
- * treat any `hit === false` slot as "absent" — never read distance/point
- * when hit is false (they're stale or zero, depending on clear-mode).
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export class FirstPersonSensors {
-    constructor() {
-        /** Wall to the body-local left, probed at chest height. */
-        this.wallLeft = new SensorHit();
-        /** Wall to the body-local right, probed at chest height. */
-        this.wallRight = new SensorHit();
-        /** Wall directly in front of the body. */
-        this.wallFront = new SensorHit();
-        /**
-         * Obstacle ahead at chest/waist height — used by mantle/vault.
-         * Distance is along the body's forward direction; normal is the
-         * face of the obstacle the player is approaching.
-         */
-        this.obstacleAhead = new SensorHit();
-        /**
-         * Ledge edge ahead — for ledge grab. Populated when the forward
-         * obstacle probe hits and a downward probe just past the
-         * obstacle's top finds empty space, indicating a grabbable edge.
-         */
-        this.ledgeAhead = new SensorHit();
-    }
-
-    /** Clear all sensor slots — call at the start of each tick. */
-    clearAll() {
-        this.wallLeft.clear();
-        this.wallRight.clear();
-        this.wallFront.clear();
-        this.obstacleAhead.clear();
-        this.ledgeAhead.clear();
-    }
-}
+import Vector3 from "../../../../core/geom/Vector3.js";
+
+/**
+ * Single spatial-query result. Set fields when `hit` is true; ignore them
+ * otherwise. `surfaceTag` is optional — populated by future surface-tag
+ * systems (grass/wood/metal/etc.) so abilities and audio can react to the
+ * material.
+ */
+export class SensorHit {
+    constructor() {
+        this.hit = false;
+        /** Distance from query origin to contact point (meters). */
+        this.distance = 0;
+        /** World-space contact point. */
+        this.point = new Vector3();
+        /** Surface normal at contact (unit vector, points away from surface). */
+        this.normal = new Vector3(0, 1, 0);
+        /** Optional material/surface tag — e.g. "grass", "metal". */
+        this.surfaceTag = null;
+    }
+
+    /** Reset to "no hit" — call before re-using the slot each tick. */
+    clear() {
+        this.hit = false;
+        this.distance = 0;
+        this.point.set(0, 0, 0);
+        this.normal.set(0, 1, 0);
+        this.surfaceTag = null;
+    }
+}
+
+/**
+ * Cached spatial-query results for one first-person controller. Populated
+ * by {@link FirstPersonSensorsSystem} once per fixed step, read by
+ * abilities and (where useful) by the base controller.
+ *
+ * The point of cacheing is dedup: mantle and ledge-grab both want a
+ * "forward + up obstacle probe". Compute once, both read the cached hit.
+ *
+ * Sensor slots cleared each tick before population. Abilities should
+ * treat any `hit === false` slot as "absent" — never read distance/point
+ * when hit is false (they're stale or zero, depending on clear-mode).
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class FirstPersonSensors {
+    constructor() {
+        /** Wall to the body-local left, probed at chest height. */
+        this.wallLeft = new SensorHit();
+        /** Wall to the body-local right, probed at chest height. */
+        this.wallRight = new SensorHit();
+        /** Wall directly in front of the body. */
+        this.wallFront = new SensorHit();
+        /**
+         * Obstacle ahead at chest/waist height — used by mantle/vault.
+         * Distance is along the body's forward direction; normal is the
+         * face of the obstacle the player is approaching.
+         */
+        this.obstacleAhead = new SensorHit();
+        /**
+         * Ledge edge ahead — for ledge grab. Populated when the forward
+         * obstacle probe hits and a downward probe just past the
+         * obstacle's top finds empty space, indicating a grabbable edge.
+         */
+        this.ledgeAhead = new SensorHit();
+        /**
+         * True when `ledgeAhead`'s top surface is wide enough to STAND on
+         * (a standing capsule fits forward of the edge), false when it's a
+         * knife-edge / thin wall you could only hang from. Mantle reads this
+         * to refuse vaulting onto a top it would immediately fall off; ledge
+         * grab ignores it (you can hang from a thin edge). Default false so a
+         * mantle never fires on stale data.
+         */
+        this.ledgeStandable = false;
+    }
+
+    /** Clear all sensor slots — call at the start of each tick. */
+    clearAll() {
+        this.wallLeft.clear();
+        this.wallRight.clear();
+        this.wallFront.clear();
+        this.obstacleAhead.clear();
+        this.ledgeAhead.clear();
+        this.ledgeStandable = false;
+    }
+}

package/src/engine/control/first-person/sensors/FirstPersonSensorsSystem.d.ts

@@ -58,6 +58,14 @@ export class FirstPersonSensorsSystem extends System<any, any, any, any, any> {
      * @private
      */
     private _populateForEntity;
+    /**
+     * Down-probe a point on (or just past) a ledge top: returns true if a
+     * surface is still there near `edgeY` — i.e. the top is wide enough for a
+     * standing capsule. A miss (or a much-lower hit) means the surface dropped
+     * away: a thin wall / lip you can only hang from, not stand on.
+     * @private
+     */
+    private _probeStandable;
     /**
      * Raycast through {@link PhysicsSystem.raycast}, populating the slot
      * if anything is hit. Direction is assumed unit (the controller's

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

@@ -1 +1 @@
-{"version":3,"file":"FirstPersonSensorsSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/control/first-person/sensors/FirstPersonSensorsSystem.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IACI,cAsCC;IAnCG,wEAA4D;IAE5D;;;;;OAKG;IACH,kBAFU,iCAAiC,GAAC,IAAI,CAEpB;IAE5B;;;;;OAKG;IACH,eAFU,aAAa,GAAC,IAAI,CAEH;IAEzB;;;;;;OAMG;IACH,mBAA4B;IAE5B;;;;;;OAMG;IACH,mBAA2C;IAG/C,2CAaC;IAED,2BAIC;IAED;;OAEG;IACH,2BAoEC;IAED;;;;;;;;;;;OAWG;IACH,kBAiBC;CACJ;uBA/LsB,wBAAwB;0BACrB,qCAAqC;4CACnB,mCAAmC;kDAC7B,yCAAyC;8BAL7D,uCAAuC"}
+{"version":3,"file":"FirstPersonSensorsSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/control/first-person/sensors/FirstPersonSensorsSystem.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IACI,cAsCC;IAnCG,wEAA4D;IAE5D;;;;;OAKG;IACH,kBAFU,iCAAiC,GAAC,IAAI,CAEpB;IAE5B;;;;;OAKG;IACH,eAFU,aAAa,GAAC,IAAI,CAEH;IAEzB;;;;;;OAMG;IACH,mBAA4B;IAE5B;;;;;;OAMG;IACH,mBAA2C;IAG/C,2CAaC;IAED,2BAIC;IAED;;OAEG;IACH,2BAmFC;IAED;;;;;;OAMG;IACH,wBASC;IAED;;;;;;;;;;;OAWG;IACH,kBAiBC;CACJ;uBAhOsB,wBAAwB;0BACrB,qCAAqC;4CACnB,mCAAmC;kDAC7B,yCAAyC;8BAL7D,uCAAuC"}