@woosh/meep-engine 3.40.0 → 3.42.0

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

@@ -797,6 +797,32 @@ export class FirstPersonPlayerControllerConfig {
              *  is allowed (when not already wall-running). */
             nearWallMaxDistance: number;
         };
+        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;
+        };
         slide: {
             /**
              * Required horizontal speed to start a slide. Below this,

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

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

@@ -617,6 +617,7 @@ export class FirstPersonPlayerControllerConfig {
             mantle: { ...this.mantle },
             wallRun: { ...this.wallRun },
             wallJump: { ...this.wallJump },
+            scrambleUp: { ...this.scrambleUp },
             slide: { ...this.slide },
             bob: { ...this.bob },
             breath: { ...this.breath },
@@ -651,6 +652,7 @@ export class FirstPersonPlayerControllerConfig {
         if (json.mantle) Object.assign(this.mantle, json.mantle);
         if (json.wallRun) Object.assign(this.wallRun, json.wallRun);
         if (json.wallJump) Object.assign(this.wallJump, json.wallJump);
+        if (json.scrambleUp) Object.assign(this.scrambleUp, json.scrambleUp);
         if (json.slide) Object.assign(this.slide, json.slide);
         if (json.bob) Object.assign(this.bob, json.bob);
         if (json.breath) Object.assign(this.breath, json.breath);

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

@@ -1 +1 @@
-{"version":3,"file":"AbilitySet.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/control/first-person/abilities/AbilitySet.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH;IACI;;;;;OAKG;IACH,WAFU,SAAS,CAEJ;IAEf;;;OAGG;IACH,QAFU,UAAQ,IAAI,CAER;IAEd;;;;;OAKG;IACH,QAFU,UAAQ,IAAI,CAER;IAEd;;;OAGG;IACH,4BAEC;IAED;;;;OAIG;IACH,+BAQC;IAED;;;;;;;;;;;;;OAaG;IACH,0EANW,MAAM,iBAIJ,OAAO,CA4DnB;IAED;;OAEG;IACH,wCAcC;IAED;;OAEG;IACH,kBAGC;IAED;;OAEG;IACH,oBAKC;CACJ"}
+{"version":3,"file":"AbilitySet.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/control/first-person/abilities/AbilitySet.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH;IACI;;;;;OAKG;IACH,WAFU,SAAS,CAEJ;IAEf;;;OAGG;IACH,QAFU,UAAQ,IAAI,CAER;IAEd;;;;;OAKG;IACH,QAFU,UAAQ,IAAI,CAER;IAEd;;;OAGG;IACH,4BAEC;IAED;;;;OAIG;IACH,+BAQC;IAED;;;;;;;;;;;;;OAaG;IACH,0EANW,MAAM,iBAIJ,OAAO,CAqEnB;IAED;;OAEG;IACH,wCAcC;IAED;;OAEG;IACH,kBAGC;IAED;;OAEG;IACH,oBAKC;CACJ"}

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

@@ -85,11 +85,13 @@ export class AbilitySet {
      * @returns {boolean} true = run base locomotion; false = ability owned
      */
     tick(controller, runtime, bodyTransform, sensors, dt, system) {
+        let yielded = false;
         // Step 1: tick the active ability if any. May release control.
         if (this.active !== null) {
             const stillActive = this.active.tick(controller, runtime, bodyTransform, dt, system);
             if (!stillActive) {
                 this._deactivate(controller, runtime);
+                yielded = true;
             }
         }
 
@@ -141,6 +143,13 @@ export class AbilitySet {
             }
         }
 
+        // A yielded step belongs to its successor, just as it would to base locomotion.
+        if (yielded && this.active !== null) {
+            if (!this.active.tick(controller, runtime, bodyTransform, dt, system)) {
+                this._deactivate(controller, runtime);
+            }
+        }
+
         return this.active === null;
     }
 

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

@@ -1 +1 @@
-{"version":3,"file":"LedgeGrab.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/control/first-person/abilities/LedgeGrab.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH;IAII;;;;iCAI6B;IAC7B,iBAAa;IAEb,iBAAa;IACb,YAAQ;IACR,YAAQ;IACR,eAAW;IAEX;mEAC+D;IAC/D,aAAkB;IAElB,0BAAiC;IAEjC,kEAiCC;IAED,gDAuDC;IAED,wBAIC;IAED,kDAOC;IAED,wFAiHC;IAED;;;;;;OAMG;IACH,sBASC;IAED;;;;;;;OAOG;IACH,yBAgBC;IAED;;;;;;;;;;;;;;OAcG;IACH,mBA8CC;CACJ;wBAjZuB,cAAc;oCAFF,iDAAiD"}
+{"version":3,"file":"LedgeGrab.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/control/first-person/abilities/LedgeGrab.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH;IAII;;;;iCAI6B;IAC7B,iBAAa;IAEb,iBAAa;IACb,YAAQ;IACR,YAAQ;IACR,eAAW;IAEX;mEAC+D;IAC/D,aAAkB;IAElB,0BAAiC;IAEjC,kEAiCC;IAED,gDAuDC;IAED,wBAIC;IAED,kDAOC;IAED,wFAuHC;IAED;;;;;;OAMG;IACH,sBASC;IAED;;;;;;;OAOG;IACH,yBAgBC;IAED;;;;;;;;;;;;;;OAcG;IACH,mBA8CC;CACJ;wBAvZuB,cAAc;oCAFF,iDAAiD"}

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

@@ -296,6 +296,12 @@ export class LedgeGrab extends Ability {
             0, 1,
         );
 
+        // Release at saturation before the controller's later recovery step lowers exertion.
+        if (controller.state.exertion >= 1.0) {
+            controller.signals.onLedgeRelease.send1({ reason: "slip" });
+            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;IAMI,gEAAgE;IAChE,0BAAsB;IAEtB,mEAuBC;IAED,gDAuBC;IAED,uDAGC;IAED,uFAmEC;IAED,oDAEC;CACJ;wBAhKuB,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,uFAoEC;IAED,oDAEC;CACJ;wBAjKuB,cAAc"}

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

@@ -127,6 +127,7 @@ export class Slide extends Ability {
             runtime.midJump = true;
             runtime.apexFired = false;
             runtime.peakAltitude = runtime.bodyPosition[1];
+            controller.state.grounded = false;
             controller.state.isVariableJumpCut = false;
             controller.state.isAscending = true;
             // Mastery: scale the impulse via JumpImpulse evaluators if any.

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

@@ -15,7 +15,8 @@
  *     out share the spring's smoothing).
  *
  * Exits on:
- *   - Timer (`cfg.wallRun.maxDuration`)
+ *   - Timer (`cfg.wallRun.maxDuration`); expiry requires landing before
+ *     another run. Other exits allow reacquisition during the same flight.
  *   - 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)
@@ -30,6 +31,8 @@ export class WallRun extends Ability {
     private _elapsed;
     /** @private "L" or "R" — which wall we're running on. */
     private _side;
+    /** @private A duration-expired run must land before starting another. */
+    private _durationState;
     canActivate(controller: any, runtime: any, sensors: any): boolean;
     onActivate(controller: any, runtime: any): void;
     /**

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

@@ -1 +1 @@
-{"version":3,"file":"WallRun.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/control/first-person/abilities/WallRun.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH;IAII,qDAAqD;IACrD,iBAAa;IAEb,yDAAyD;IACzD,cAAY;IAEZ,kEAqCC;IAED,gDAqBC;IAED;;;;OAIG;IACH,wBAEC;IAED,uFAgEC;CAKJ;wBAnLuB,cAAc"}
+{"version":3,"file":"WallRun.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/control/first-person/abilities/WallRun.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH;IAII,qDAAqD;IACrD,iBAAa;IAEb,yDAAyD;IACzD,cAAY;IAEZ,yEAAyE;IACzE,uBAAsC;IAEtC,kEAsCC;IAED,gDAqBC;IAED;;;;OAIG;IACH,wBAEC;IAED,uFAmEC;CAKJ;wBA/LuB,cAAc"}

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

@@ -1,6 +1,10 @@
 import { DEG_TO_RAD } from "../../../../core/math/DEG_TO_RAD.js";
 import { Ability } from "./Ability.js";
 
+function resetDurationOnLand() {
+    this.exhausted = false;
+}
+
 /**
  * Wall-run ability. Activates when the player is airborne with momentum
  * and a wall is detected to their left or right. While active:
@@ -18,7 +22,8 @@ import { Ability } from "./Ability.js";
  *     out share the spring's smoothing).
  *
  * Exits on:
- *   - Timer (`cfg.wallRun.maxDuration`)
+ *   - Timer (`cfg.wallRun.maxDuration`); expiry requires landing before
+ *     another run. Other exits allow reacquisition during the same flight.
  *   - 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)
@@ -38,9 +43,13 @@ export class WallRun extends Ability {
     /** @private "L" or "R" — which wall we're running on. */
     _side = "L";
 
+    /** @private A duration-expired run must land before starting another. */
+    _durationState = { exhausted: false };
+
     canActivate(controller, runtime, sensors) {
         const cfg = controller.config.wallRun;
         if (!cfg) return false;
+        if (this._durationState.exhausted) return false;
         if (sensors === undefined || sensors === null) return false;
         if (controller.state.grounded) return false;
         if (controller.state.airborneTime < cfg.minAirborneTime) return false;
@@ -115,6 +124,9 @@ export class WallRun extends Ability {
 
         // -- Exit: timer.
         if (this._elapsed >= cfg.maxDuration) {
+            this._durationState.exhausted = true;
+            // The pending listener owns only the state cell, never the ability.
+            controller.signals.onLand.addOne(resetDurationOnLand, this._durationState);
             return false;
         }
         // -- Exit: re-grounded (we ran onto a floor).

package/src/engine/control/first-person/mastery/SlideInitiationTimingEvaluator.d.ts

@@ -1,6 +1,6 @@
 /**
  * Default symmetric stride-timing curve for slide entry. Peaks at the
- * midstance phases (≈0.25 R-mid, ≈0.75 L-mid) — committing to the slide
+ * midstance phases (≈0.25, ≈0.75) — committing to the slide
  * at midstance lets you convert your push-off momentum into the slide's
  * forward velocity cleanly. Troughs near footfall transitions (≈0, ≈0.5)
  * where the leg's loading-response decelerates the body and a slide

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

@@ -1 +1 @@
-{"version":3,"file":"SlideInitiationTimingEvaluator.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/control/first-person/mastery/SlideInitiationTimingEvaluator.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;GAcG;AACH,yDAFa,cAAc,CAS1B;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IAGI;;;;;OAKG;IACH,OAFU,cAAc,CAEwB;IAEhD;;;;;;OAMG;IACH,WAFU,MAAM,CAEA;IAEhB,qEAQC;CACJ;+BA/E8B,4CAA4C;iCAG1C,uBAAuB"}
+{"version":3,"file":"SlideInitiationTimingEvaluator.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/control/first-person/mastery/SlideInitiationTimingEvaluator.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;GAcG;AACH,yDAFa,cAAc,CAU1B;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IAGI;;;;;OAKG;IACH,OAFU,cAAc,CAEwB;IAEhD;;;;;;OAMG;IACH,WAFU,MAAM,CAEA;IAEhB,qEAQC;CACJ;+BAhF8B,4CAA4C;iCAG1C,uBAAuB"}

package/src/engine/control/first-person/mastery/SlideInitiationTimingEvaluator.js

@@ -5,7 +5,7 @@ import { MasteryEvaluator } from "./MasteryEvaluator.js";
 
 /**
  * Default symmetric stride-timing curve for slide entry. Peaks at the
- * midstance phases (≈0.25 R-mid, ≈0.75 L-mid) — committing to the slide
+ * midstance phases (≈0.25, ≈0.75) — committing to the slide
  * at midstance lets you convert your push-off momentum into the slide's
  * forward velocity cleanly. Troughs near footfall transitions (≈0, ≈0.5)
  * where the leg's loading-response decelerates the body and a slide
@@ -20,10 +20,11 @@ import { MasteryEvaluator } from "./MasteryEvaluator.js";
  */
 export function makeDefaultSlideInitiationTimingCurve() {
     return AnimationCurve.from([
-        Keyframe.from(0.00, 0.97), // R-foot footfall — slight penalty
-        Keyframe.from(0.25, 1.06), // R-foot midstance — peak commitment
-        Keyframe.from(0.50, 0.97), // L-foot footfall — slight penalty
-        Keyframe.from(0.75, 1.06), // L-foot midstance — peak commitment
+        Keyframe.from(0.00, 0.97), // footfall — slight penalty
+        Keyframe.from(0.25, 1.06), // midstance — peak commitment
+        Keyframe.from(0.50, 0.97), // footfall — slight penalty
+        Keyframe.from(0.75, 1.06), // midstance — peak commitment
+        Keyframe.from(1.00, 0.97), // next footfall closes the stride cycle
     ]);
 }
 

package/src/engine/control/first-person/mastery/StrideTimingJumpEvaluator.d.ts

@@ -1,12 +1,12 @@
 /**
  * Default symmetric stride-timing curve for the jump-impulse decision
- * point. Peaks at the midstance phases (≈0.25 R-mid, ≈0.75 L-mid) and
+ * point. Peaks at the midstance phases (≈0.25, ≈0.75) and
  * troughs near the footfall transitions (≈0, ≈0.5).
  *
  * Curve is asymmetric in magnitude per the project rule: bonus side is
  * larger than penalty side. Default peak = +12%, default trough = −4%.
- * The curve is keyed at the four phase critical points; the engine's
- * tangent-interpolation gives smooth motion between them.
+ * The curve closes at the next footfall; tangent interpolation gives
+ * smooth motion between the critical phases.
  *
  * @returns {AnimationCurve}
  */

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

@@ -1 +1 @@
-{"version":3,"file":"StrideTimingJumpEvaluator.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/control/first-person/mastery/StrideTimingJumpEvaluator.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;GAWG;AACH,oDAFa,cAAc,CAS1B;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAGI;;;;;;OAMG;IACH,OAFU,cAAc,CAEmB;IAE3C;;;;;;;OAOG;IACH,WAFU,MAAM,CAEA;IAEhB;;;;;OAKG;IACH,cAFU,GAAG,GAAC,GAAG,GAAC,IAAI,CAEF;IAEpB;;;;OAIG;IACH,mBAFU,MAAM,CAES;IAEzB,oEAqBC;CACJ;+BAzG8B,4CAA4C;iCAG1C,uBAAuB"}
+{"version":3,"file":"StrideTimingJumpEvaluator.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/control/first-person/mastery/StrideTimingJumpEvaluator.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;GAWG;AACH,oDAFa,cAAc,CAU1B;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAGI;;;;;;OAMG;IACH,OAFU,cAAc,CAEmB;IAE3C;;;;;;;OAOG;IACH,WAFU,MAAM,CAEA;IAEhB;;;;;OAKG;IACH,cAFU,GAAG,GAAC,GAAG,GAAC,IAAI,CAEF;IAEpB;;;;OAIG;IACH,mBAFU,MAAM,CAES;IAEzB,oEAqBC;CACJ;+BA1G8B,4CAA4C;iCAG1C,uBAAuB"}

package/src/engine/control/first-person/mastery/StrideTimingJumpEvaluator.js

@@ -5,22 +5,23 @@ import { MasteryEvaluator } from "./MasteryEvaluator.js";
 
 /**
  * Default symmetric stride-timing curve for the jump-impulse decision
- * point. Peaks at the midstance phases (≈0.25 R-mid, ≈0.75 L-mid) and
+ * point. Peaks at the midstance phases (≈0.25, ≈0.75) and
  * troughs near the footfall transitions (≈0, ≈0.5).
  *
  * Curve is asymmetric in magnitude per the project rule: bonus side is
  * larger than penalty side. Default peak = +12%, default trough = −4%.
- * The curve is keyed at the four phase critical points; the engine's
- * tangent-interpolation gives smooth motion between them.
+ * The curve closes at the next footfall; tangent interpolation gives
+ * smooth motion between the critical phases.
  *
  * @returns {AnimationCurve}
  */
 export function makeDefaultStrideTimingJumpCurve() {
     return AnimationCurve.from([
-        Keyframe.from(0.00, 0.96),  // R-foot footfall — slight penalty (just touched down)
-        Keyframe.from(0.25, 1.12),  // R-foot midstance — peak push-off power
-        Keyframe.from(0.50, 0.96),  // L-foot footfall — slight penalty
-        Keyframe.from(0.75, 1.12),  // L-foot midstance — peak push-off power
+        Keyframe.from(0.00, 0.96),  // footfall — slight penalty (just touched down)
+        Keyframe.from(0.25, 1.12),  // midstance — peak push-off power
+        Keyframe.from(0.50, 0.96),  // footfall — slight penalty
+        Keyframe.from(0.75, 1.12),  // midstance — peak push-off power
+        Keyframe.from(1.00, 0.96),  // next footfall closes the stride cycle
     ]);
 }
 
@@ -98,7 +99,7 @@ export class StrideTimingJumpEvaluator extends MasteryEvaluator {
         if (this.dominantFoot !== null
             && runtime.standingFoot === this.dominantFoot
             && raw > 1.0) {
-            multiplier *= 1.0 + this.dominantFootBonus;
+            multiplier += this.dominantFootBonus;
         }
 
         return multiplier;

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":"AAUA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;;IACI,0EAA0D;IAE1D;;;;;OAKG;IACH,kBAFU,iCAAiC,GAAC,IAAI,CAExB;IAExB;;;;;OAKG;IACH,eAFU,aAAa,GAAC,IAAI,CAEP;IAErB;;;;;;OAMG;IACH,mBAAwB;IAExB;;;;;;OAMG;IACH,mBAAuC;IAEvC,2CAaC;IAED,2BAIC;IAED;;OAEG;IACH,2BA0FC;IAED;;;;;;;;;;OAUG;IACH,wBAQC;IAED;;;;;;;;;;;;OAYG;IACH,kBAgBC;CACJ;uBAtOsB,wBAAwB;4BACnB,uCAAuC;4CACvB,mCAAmC;kDAC7B,yCAAyC;8BAL7D,uCAAuC"}
+{"version":3,"file":"FirstPersonSensorsSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/control/first-person/sensors/FirstPersonSensorsSystem.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;;IACI,0EAA0D;IAE1D;;;;;OAKG;IACH,kBAFU,iCAAiC,GAAC,IAAI,CAExB;IAExB;;;;;OAKG;IACH,eAFU,aAAa,GAAC,IAAI,CAEP;IAErB;;;;;;OAMG;IACH,mBAAwB;IAExB;;;;;;OAMG;IACH,mBAAuC;IAEvC,2CAaC;IAED,2BAIC;IAED;;OAEG;IACH,2BAmGC;IAED;;;;;;;;;;OAUG;IACH,wBAQC;IAED;;;;;;;;;;;;OAYG;IACH,kBAgBC;CACJ;uBA/OsB,wBAAwB;4BACnB,uCAAuC;4CACvB,mCAAmC;kDAC7B,yCAAyC;8BAL7D,uCAAuC"}

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

@@ -150,9 +150,18 @@ export class FirstPersonSensorsSystem extends System {
         // the body height to decide vault vs. mantle vs. neither.
         this._probeRay(sensors.obstacleAhead, ox, oy, oz, fx, 0, fz, obstacleProbeDist, notSelf);
 
-        // Ledge ahead — only meaningful if obstacleAhead hit something
-        // around chest height: probe down from just past the top of the
-        // obstacle, look for ground.
+        let ledgeProbeDist = cfg.body.height * 0.5;
+        if (!sensors.obstacleAhead.hit && controller.state.grounded && cfg.mantle) {
+            // Grounded mantles can reach lower tops that the chest ray passes over.
+            const minimumHeight = cfg.mantle.minHeight;
+            this._probeRay(sensors.obstacleAhead, ox, transform.translation_y + minimumHeight, oz,
+                fx, 0, fz, obstacleProbeDist, notSelf);
+            if (sensors.obstacleAhead.hit) {
+                ledgeProbeDist = cfg.body.height + 0.1 - minimumHeight;
+            }
+        }
+
+        // Ledge ahead: probe downward from above the body to a reachable top.
         if (sensors.obstacleAhead.hit) {
             const topY = transform.translation_y + cfg.body.height + 0.1;
             const px = sensors.obstacleAhead.point[0] + fx * 0.3;
@@ -161,7 +170,7 @@ export class FirstPersonSensorsSystem extends System {
                 sensors.ledgeAhead,
                 px, topY, pz,
                 0, -1, 0,
-                cfg.body.height * 0.5,
+                ledgeProbeDist,
                 notSelf,
             );
         }

package/src/engine/ecs/EntityManager.d.ts

@@ -143,7 +143,15 @@ export class EntityManager {
      */
     private __execution_order_needs_update;
     /**
-     * Rebuild execution order
+     * Rebuild execution order.
+     *
+     * Nobody writes the order down; it is derived from what each system declares it touches. A
+     * system that writes a component runs before every other system in the same pass that reads it
+     * (see {@link orderSystemsByDeclaredAccess}, which also says how a cycle is broken). Where those
+     * edges leave a choice, the score below decides, then registration order.
+     *
+     * An explicit `runs_before` / `runs_after` was considered and rejected: it couples systems to
+     * each other by name, which is what deriving the order exists to avoid.
      * @private
      */
     private updateExecutionOrder;

package/src/engine/ecs/EntityManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EntityManager.d.ts","sourceRoot":"","sources":["../../../../src/engine/ecs/EntityManager.js"],"names":[],"mappings":"iCAqBU,MAAM;;;;;;;;;AAoBhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;IAEI;;;;OAIG;IACH,kBAFU,aAAQ,CAEL;IAEb;;;;;;OAMG;IACH,uCAA2B;IAE3B;;;;;OAKG;IACH,iCAA4B;IAE5B;;OAEG;IACH;;;QAGI;;WAEG;;;MAGL;IAEF;;;OAGG;IACH,OAFU,kBAAkB,CAEO;IAEnC;;;;;;;;;OASG;IACH,qBAFU,MAAM,CAEY;IAE5B;;;;;;;;OAQG;IACH,wCAFU,MAAM,CAE4B;IAE5C;;;;;;;;OAQG;IACH,eAFU,MAAM,CAEE;IAElB;;;;;OAKG;IACH,+BAA2B;IAE3B;;;;;;;;;;;;;;OAcG;IACH,oBAFU,MAAM,CAEO;IAEvB;;;;OAIG;IACH,SAFU,sBAAsB,CAEjB;IA8Bf;;;;;OAKG;IACH,uCAAsC;IAEtC;;;OAGG;IACH,6BA4GC;IAED;;;;OAIG;IACH,4BAHW;QAAC,WAAW,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAA;KAAC,QAavD;IAED;;;OAGG;IACH,8BAHW;QAAC,WAAW,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAA;KAAC,GAC3C,OAAO,CAYnB;IAoBD;;;OAGG;IACH,uBAFa,KAAK,EAAE,CAuBnB;IAED;;;;;OAKG;IACH,uBAJW,sBAAsB,QA4ChC;IAGD;;;OAGG;IACH,sBA2BC;IAED;;;;OAIG;IACH,qCAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,6CAgBC;IAED;;;;;OAKG;IACH,wCAHW,MAAM,cAkBhB;IAGD;;;OAGG;IACH,2BAFW,MAAM,QA6HhB;IAED;;;;;;;;;OASG;IACH,qBAFa,MAAM,CAKlB;IAED;;;;;OAKG;IACH,6CA6DC;IAED;;;;OAIG;IACH,mCAFa,QAAQ,OAAO,CAAC,CA2C5B;IAED;;;;;OAKG;IACH,mBAsDC;IAED;;;;;OAKG;IACH,oBA4FC;IAED;;;;;OAKG;IACH,kEAyEC;IAED;;;;OAIG;IACH,2BAHW,KAAK,GACH,oBAAgB,CA0B5B;IAED;;;;OAIG;IACH,kCAJW,KAAK,SACL,WAAW,GACT,oBAAgB,CA0B5B;IAED;;;;;OAKG;IACH,mEAmEC;IAGL;;OAEG;IACH,yBA7wBe,sBAAsB,UA6wBA;IACrC;;OAEG;IACH,0BAAqC;IAErC;;OAEG;IACH,+BA5oBe,MAAM,UA4oBW;;CAd/B;6BAnpCY,OAAO,gCAAgC,EAAE,KAAK,CAAC,CAAC,CAAC;uBAN1B,aAAa;mBAR9B,oCAAoC;uCAMhB,6BAA6B;4BAEhC,aAAa"}
+{"version":3,"file":"EntityManager.d.ts","sourceRoot":"","sources":["../../../../src/engine/ecs/EntityManager.js"],"names":[],"mappings":"iCAsBU,MAAM;;;;;;;;;AAoBhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;IAEI;;;;OAIG;IACH,kBAFU,aAAQ,CAEL;IAEb;;;;;;OAMG;IACH,uCAA2B;IAE3B;;;;;OAKG;IACH,iCAA4B;IAE5B;;OAEG;IACH;;;QAGI;;WAEG;;;MAGL;IAEF;;;OAGG;IACH,OAFU,kBAAkB,CAEO;IAEnC;;;;;;;;;OASG;IACH,qBAFU,MAAM,CAEY;IAE5B;;;;;;;;OAQG;IACH,wCAFU,MAAM,CAE4B;IAE5C;;;;;;;;OAQG;IACH,eAFU,MAAM,CAEE;IAElB;;;;;OAKG;IACH,+BAA2B;IAE3B;;;;;;;;;;;;;;OAcG;IACH,oBAFU,MAAM,CAEO;IAEvB;;;;OAIG;IACH,SAFU,sBAAsB,CAEjB;IA8Bf;;;;;OAKG;IACH,uCAAsC;IAEtC;;;;;;;;;;;OAWG;IACH,6BAkGC;IAED;;;;OAIG;IACH,4BAHW;QAAC,WAAW,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAA;KAAC,QAavD;IAED;;;OAGG;IACH,8BAHW;QAAC,WAAW,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAA;KAAC,GAC3C,OAAO,CAYnB;IAoBD;;;OAGG;IACH,uBAFa,KAAK,EAAE,CAuBnB;IAED;;;;;OAKG;IACH,uBAJW,sBAAsB,QA4ChC;IAGD;;;OAGG;IACH,sBA2BC;IAED;;;;OAIG;IACH,qCAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,6CAgBC;IAED;;;;;OAKG;IACH,wCAHW,MAAM,cAkBhB;IAGD;;;OAGG;IACH,2BAFW,MAAM,QA6HhB;IAED;;;;;;;;;OASG;IACH,qBAFa,MAAM,CAKlB;IAED;;;;;OAKG;IACH,6CA6DC;IAED;;;;OAIG;IACH,mCAFa,QAAQ,OAAO,CAAC,CA2C5B;IAED;;;;;OAKG;IACH,mBAsDC;IAED;;;;;OAKG;IACH,oBA4FC;IAED;;;;;OAKG;IACH,kEA4EC;IAED;;;;OAIG;IACH,2BAHW,KAAK,GACH,oBAAgB,CA0B5B;IAED;;;;OAIG;IACH,kCAJW,KAAK,SACL,WAAW,GACT,oBAAgB,CA0B5B;IAED;;;;;OAKG;IACH,mEAmEC;IAGL;;OAEG;IACH,yBAhxBe,sBAAsB,UAgxBA;IACrC;;OAEG;IACH,0BAAqC;IAErC;;OAEG;IACH,+BA/oBe,MAAM,UA+oBW;;CAd/B;6BAppCY,OAAO,gCAAgC,EAAE,KAAK,CAAC,CAAC,CAAC;uBAP1B,aAAa;mBAR9B,oCAAoC;uCAMhB,6BAA6B;4BAEhC,aAAa"}

package/src/engine/ecs/EntityManager.js

@@ -10,6 +10,7 @@ import { EntityComponentDataset } from "./EntityComponentDataset.js";
 import { EntityObserver } from "./EntityObserver.js";
 import { System, SystemState } from "./System.js";
 import { computeSystemComponentDependencyGraph } from "./system/computeSystemComponentDependencyGraph.js";
+import { orderSystemsByDeclaredAccess } from "./system/orderSystemsByDeclaredAccess.js";
 import { system_validate_class } from "./system_validate_class.js";
 
 /**
@@ -216,7 +217,15 @@ export class EntityManager {
     __execution_order_needs_update = true;
 
     /**
-     * Rebuild execution order
+     * Rebuild execution order.
+     *
+     * Nobody writes the order down; it is derived from what each system declares it touches. A
+     * system that writes a component runs before every other system in the same pass that reads it
+     * (see {@link orderSystemsByDeclaredAccess}, which also says how a cycle is broken). Where those
+     * edges leave a choice, the score below decides, then registration order.
+     *
+     * An explicit `runs_before` / `runs_after` was considered and rejected: it couples systems to
+     * each other by name, which is what deriving the order exists to avoid.
      * @private
      */
     updateExecutionOrder() {
@@ -253,6 +262,11 @@ export class EntityManager {
 
 
         /**
+         * Ranks the systems the write→read edges leave free to run in either order, and decides
+         * which system of a cycle runs first. It decides nothing an edge decides, and could not:
+         * it is a SUM over the components a system references, so a system that reads X and
+         * writes Y outscores the plain writer of X it depends on, and sorting by it alone ran that
+         * reader first.
          *
          * @param {System} system
          * @returns {number} higher values means it should be scheduled before others
@@ -275,24 +289,13 @@ export class EntityManager {
                 /*
                  The component itself, plus whatever depends on it.
 
-                 The `+ 1` is the whole of the fix, and the bug it closes is that the multipliers
-                 below were applied to a number the declaring system could not raise.
-                 `computeSystemComponentDependencyGraph` draws its edges from each component a
-                 system WRITES to each one it READS, so a component this system writes collects
-                 OUTgoing edges here and, from this system's own declaration, an in-degree of zero.
-                 Twice zero is zero: `Write` — the lever the whole design rests on — contributed
-                 nothing, a writer scored exactly what a reader scored, and `Array.prototype.sort`'s
-                 stability handed the decision back to registration order.
-
-                 Worse than a wrong answer, it was an answer that depended on OTHER systems'
-                 declarations. A port found its camera pose one frame late (GAP-037) only after
-                 reducing to a two-system rig; in the full application `PhysicsSystem` writing
-                 `RigidBody` and reading `Transform` lent `Transform` the incoming edge the camera
-                 system's own declaration did not, so a correct order was resting on a system it has
-                 nothing to do with, and would have inverted silently the day that system moved.
-
-                 An explicit `runs_before` / `runs_after` was considered and rejected: it couples
-                 systems to each other by name, which is what deriving the order exists to avoid.
+                 Without the `+ 1` the multipliers below apply to a number the declaring system
+                 cannot raise. `computeSystemComponentDependencyGraph` draws its edges from each
+                 component a system WRITES to each one it READS, so a component this system writes
+                 collects OUTgoing edges here and, from this system's own declaration, an in-degree
+                 of zero. Twice zero is zero, and Create, Write and Read stop ranking: a creator and
+                 a plain writer of one component, which no write→read edge orders, would tie and
+                 fall to registration order.
                 */
                 const weight = 1 + attached_edge_count;
 
@@ -311,18 +314,14 @@ export class EntityManager {
             return result;
         }
 
-        // pre-score systems for faster sorting
-        const scores = new Map();
+        // `order` is still in registration order here, which is what breaks a tie between scores
+        const scores = new Float64Array(executable_system_count);
 
         for (let i = 0; i < executable_system_count; i++) {
-            const system = order[i];
-
-            scores.set(system, scoreSystem(system));
+            scores[i] = scoreSystem(order[i]);
         }
 
-        order.sort((a, b) => {
-            return scores.get(b) - scores.get(a);
-        });
+        orderSystemsByDeclaredAccess(order, executable_system_count, scores);
 
         // clear update flag
         this.__execution_order_needs_update = false;
@@ -993,12 +992,19 @@ export class EntityManager {
 
         const self = this;
         const systems = this.systems;
-        let readyCount = 0;
+        let settledCount = 0;
         const expectedReadyCount = systems.length;
+        let failed = false;
+        let startupError;
 
         // console.log(`EntityManager startup initialized, starting ${expectedReadyCount} systems.`);
 
         function finalizeStartup() {
+            if (failed) {
+                self.state = EntityManagerState.Failed;
+                errorCallback(startupError);
+                return;
+            }
             self.state = EntityManagerState.Running;
 
             // console.log(`EntityManager startup finished, all systems started`);
@@ -1010,26 +1016,22 @@ export class EntityManager {
         }
 
         function systemReady() {
-            //startup all systems
-            readyCount++;
+            settledCount++;
 
-            if (readyCount === expectedReadyCount) {
+            if (settledCount === expectedReadyCount) {
                 finalizeStartup();
             }
         }
 
-        let firstFailure = true;
-
         function systemError(system, error) {
             console.error("Failed to start system", system, 'Error:', error);
 
-            if (firstFailure) {
-                firstFailure = false;
-
-                self.state = EntityManagerState.Failed;
-
-                errorCallback(error);
+            if (!failed) {
+                failed = true;
+                startupError = error;
             }
+            // A successful sibling must finish acquiring resources before rollback releases them.
+            systemReady();
         }
 
         if (expectedReadyCount === 0) {
@@ -1118,8 +1120,8 @@ export class EntityManager {
      * @param {function} [errorCallback] Called when an error occurs during the shutdown process. defaults to console error output
      */
     shutdown(readyCallback = noop, errorCallback = console.error) {
-        if (this.state !== EntityManagerState.Running) {
-            throw new IllegalStateException(`System is wrong state, expected '${EntityManagerState.Running}'`);
+        if (this.state !== EntityManagerState.Running && this.state !== EntityManagerState.Failed) {
+            throw new IllegalStateException(`System is wrong state, expected Running or Failed`);
         }
 
         assert.isFunction(readyCallback, 'readyCallback');
@@ -1199,4 +1201,4 @@ EntityManager.prototype.detachDataSet = EntityManager.prototype.detachDataset;
 /**
  * @deprecated renamed to `update`
  */
-EntityManager.prototype.simulate = EntityManager.prototype.update
+EntityManager.prototype.simulate = EntityManager.prototype.update

package/src/engine/ecs/dynamic_actions/rules/DynamicRuleDescription.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DynamicRuleDescription.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/dynamic_actions/rules/DynamicRuleDescription.js"],"names":[],"mappings":"AAUA;IACI;;;OAGG;IACH,IAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,8BAAiB;IACjB;;;OAGG;IACH,kCAAc;IACd;;;OAGG;IACH,YAFU,mBAAmB,CAEb;IAChB;;;OAGG;IACH,UAFU,MAAM,CAEH;IACb;;;OAGG;IACH,6BAAyB;IACzB;;;OAGG;IACH,kBAFU,8BAA8B,EAAE,CAEpB;IAEtB;;;;OAIG;IACH,cAHW,sBAAsB,GACpB,OAAO,CAInB;IAED;;;OAGG;IACH,0BAFa,MAAM,CAIlB;IAED,yCAEC;IAED,cA+BC;IAED;;;;;;aA2BC;CACJ;+CA1H8C,qCAAqC"}
+{"version":3,"file":"DynamicRuleDescription.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/dynamic_actions/rules/DynamicRuleDescription.js"],"names":[],"mappings":"AAUA;IACI;;;OAGG;IACH,IAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,8BAAiB;IACjB;;;OAGG;IACH,kCAAc;IACd;;;OAGG;IACH,YAFU,mBAAmB,CAEb;IAChB;;;OAGG;IACH,UAFU,MAAM,CAEH;IACb;;;OAGG;IACH,6BAAyB;IACzB;;;OAGG;IACH,kBAFU,8BAA8B,EAAE,CAEpB;IAEtB;;;;OAIG;IACH,cAHW,sBAAsB,GACpB,OAAO,CAInB;IAED;;;OAGG;IACH,0BAFa,MAAM,CAIlB;IAED,yCAEC;IAED,cAgCC;IAED;;;;;;aA2BC;CACJ;+CA3H8C,qCAAqC"}

package/src/engine/ecs/dynamic_actions/rules/DynamicRuleDescription.js

@@ -52,7 +52,7 @@ export class DynamicRuleDescription {
      * @returns {boolean}
      */
     equals(other) {
-        return this.id.equals(other.id);
+        return this.id === other.id;
     }
 
     /**
@@ -68,6 +68,7 @@ export class DynamicRuleDescription {
     }
 
     build() {
+        this.predicate_complexity = 0;
 
         //infer types
         inferReactiveExpressionTypes(this.condition);

package/src/engine/ecs/dynamic_actions/rules/DynamicRuleDescriptionTable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DynamicRuleDescriptionTable.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/dynamic_actions/rules/DynamicRuleDescriptionTable.js"],"names":[],"mappings":"AAMA;;IAEI;;;;OAIG;IACH,yCAAsC;IAEtC;;;;OAIG;IACH,iCAAyC;IAEzC;;;;OAIG;IACH,oDAFY,sBAAsB,EAAE,GAAC,SAAS,CAI7C;IAED;;;OAGG;IACH,kBAFY,uBAAuB,CAclC;IAED,mBA8BC;IAED;;;;OAIG;IACH,yBAFa,sBAAsB,GAAC,SAAS,CAmC5C;IAED;;;;OAIG;IACH,qBAFa,sBAAsB,EAAE,CAgCpC;IAED,oEAIC;IAED,yCAMC;CAEJ;yCA1KwC,yDAAyD;uCAC3D,6BAA6B;wCAF5B,uEAAuE"}
+{"version":3,"file":"DynamicRuleDescriptionTable.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/dynamic_actions/rules/DynamicRuleDescriptionTable.js"],"names":[],"mappings":"AAMA;;IAEI;;;;OAIG;IACH,yCAAsC;IAEtC;;;;OAIG;IACH,iCAAyC;IAEzC;;;;OAIG;IACH,oDAFY,sBAAsB,EAAE,GAAC,SAAS,CAI7C;IAED;;;OAGG;IACH,kBAFY,uBAAuB,CAclC;IAED,mBA+BC;IAED;;;;OAIG;IACH,yBAFa,sBAAsB,GAAC,SAAS,CAmC5C;IAED;;;;OAIG;IACH,qBAFa,sBAAsB,EAAE,CAgCpC;IAED,oEAIC;IAED,yCAMC;CAEJ;yCA3KwC,yDAAyD;uCAC3D,6BAA6B;wCAF5B,uEAAuE"}

package/src/engine/ecs/dynamic_actions/rules/DynamicRuleDescriptionTable.js

@@ -48,6 +48,7 @@ export class DynamicRuleDescriptionTable extends StaticKnowledgeDataTable {
     }
 
     buildIndex() {
+        this.__predicate_rule_mapping.clear();
 
         /**
          *

package/src/engine/ecs/fow/FogOfWarRevealerSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FogOfWarRevealerSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/fow/FogOfWarRevealerSystem.js"],"names":[],"mappings":"AAcA;IAOI;;;OAGG;IACH,kBAFW,MAAM,EAUhB;IAlBD,6EAAqD;IACrD,gEAEE;IACF,YAAU;IASN;;;OAGG;IACH,MAFU,MAAM,CAEA;IAGpB;;;;;;OAMG;IACH,eALW,gBAAgB,aAChB,WAAW,QACX,IAAI,qBAqFd;IAED,oBAmCC;IAED;;;;;;OAMG;IACH,iBALW,gBAAgB,aAChB,WAAW,QACX,IAAI,UACJ,MAAM,QAQhB;CACJ;uBAjLsB,cAAc;4BAKT,6BAA6B;iCAJxB,uBAAuB;iBAGvC,iBAAiB;yBADT,eAAe;4CAMI,oDAAoD"}
+{"version":3,"file":"FogOfWarRevealerSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/fow/FogOfWarRevealerSystem.js"],"names":[],"mappings":"AAcA;IAOI;;;OAGG;IACH,kBAFW,MAAM,EAUhB;IAlBD,6EAAqD;IACrD,gEAEE;IACF,YAAU;IASN;;;OAGG;IACH,MAFU,MAAM,CAEA;IAGpB;;;;;;OAMG;IACH,eALW,gBAAgB,aAChB,WAAW,QACX,IAAI,qBAwFd;IAED,oBAmCC;IAED;;;;;;OAMG;IACH,iBALW,gBAAgB,aAChB,WAAW,QACX,IAAI,UACJ,MAAM,QAQhB;CACJ;uBApLsB,cAAc;4BAKT,6BAA6B;iCAJxB,uBAAuB;iBAGvC,iBAAiB;yBADT,eAAe;4CAMI,oDAAoD"}

package/src/engine/ecs/fow/FogOfWarRevealerSystem.js

@@ -46,6 +46,9 @@ export class FogOfWarRevealerSystem extends System {
         const visibilityTeam = this.team;
 
         function update() {
+            if (team.getValue() !== visibilityTeam) {
+                return;
+            }
             const dataset = em.dataset;