@woosh/meep-engine 3.41.0 → 3.43.0

package/src/core/math/noise/curl_noise_3dt.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"curl_noise_3dt.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/noise/curl_noise_3dt.js"],"names":[],"mappings":"AAMA;;;;;;;GAOG;AACH,uCANW,MAAM,EAAE,KACR,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,QAehB"}
+{"version":3,"file":"curl_noise_3dt.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/noise/curl_noise_3dt.js"],"names":[],"mappings":"AAOA;;;;;;;GAOG;AACH,uCANW,MAAM,EAAE,KACR,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,QAwBhB"}

package/src/core/math/noise/curl_noise_3dt.js

@@ -1,8 +1,9 @@
-import { sdnoise3 } from "./sdnoise.js";
+import { sdnoise3_array } from "./sdnoise.js";
 
-const p_x0 = [];
-const p_y0 = [];
-const p_z0 = [];
+const p_x0 = new Float64Array(4);
+const p_y0 = new Float64Array(4);
+const p_z0 = new Float64Array(4);
+const sample_position = new Float64Array(3);
 
 /**
  *
@@ -14,13 +15,22 @@ const p_z0 = [];
  */
 export function curl_noise_3dt(result, x, y, z, w) {
 
-    sdnoise3(p_x0, x + w, y, z);
-    sdnoise3(p_y0, x + 31.341, y - 43.23 + w, z + 12.34);
-    sdnoise3(p_z0, x - 231.141, y + 124.123, z - 54.4341 + w);
+    sample_position[0] = x + w;
+    sample_position[1] = y;
+    sample_position[2] = z;
+    sdnoise3_array(p_x0, 0, sample_position, 0);
+    sample_position[0] = x + 31.341;
+    sample_position[1] = y - 43.23 + w;
+    sample_position[2] = z + 12.34;
+    sdnoise3_array(p_y0, 0, sample_position, 0);
+    sample_position[0] = x - 231.141;
+    sample_position[1] = y + 124.123;
+    sample_position[2] = z - 54.4341 + w;
+    sdnoise3_array(p_z0, 0, sample_position, 0);
 
-    const _x = p_z0[1] - p_y0[2];
-    const _y = p_x0[2] - p_z0[0];
-    const _z = p_y0[0] - p_x0[1];
+    const _x = p_z0[2] - p_y0[3];
+    const _y = p_x0[3] - p_z0[1];
+    const _z = p_y0[1] - p_x0[2];
 
     result[0] = _x;
     result[1] = _y;

package/src/core/math/noise/sdnoise.d.ts

@@ -17,17 +17,28 @@ export function sdnoise1(derivatives: number[], x: number): number;
  * @returns {number}
  */
 export function sdnoise2(derivatives: number[], x: number, y: number): number;
-/** 3D simplex noise with derivatives.
- * If the last tthree arguments are not null, the analytic derivative
- * (the 3D gradient of the scalar noise field) is also calculated.
+/** 3D simplex noise with its analytic gradient, written into derivatives[0..2].
+ * Scalar facade over {@link sdnoise3_array}; returns the noise value.
  *
+ * @param {number[]|Float32Array|Float64Array} derivatives
  * @param {number} x
  * @param {number} y
  * @param {number} z
- * @param {number[]} derivatives
  * @returns {number}
  */
-export function sdnoise3(derivatives: number[], x: number, y: number, z: number): number;
+export function sdnoise3(derivatives: number[] | Float32Array | Float64Array, x: number, y: number, z: number): number;
+/**
+ * 3D simplex noise and its analytic gradient, with packed coordinates.
+ * Writes [noise, dx, dy, dz] at out_offset and returns nothing. Coordinates
+ * are read before output stores, so input and output may overlap.
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset
+ * @param {ArrayLike<number>} position
+ * @param {number} position_offset
+ * @returns {void}
+ */
+export function sdnoise3_array(out: number[] | Float32Array | Float64Array, out_offset: number, position: ArrayLike<number>, position_offset: number): void;
 /**
  * 4D simplex noise with derivatives.
  * If the last four arguments are not null, the analytic derivative

package/src/core/math/noise/sdnoise.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sdnoise.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/noise/sdnoise.js"],"names":[],"mappings":"AA6LA;;;;;;;GAOG;AACH,sCAHW,MAAM,EAAE,KADR,MAAM,GAEJ,MAAM,CAsDlB;AAUD;;;;;;;;GAQG;AACH,sCAHW,MAAM,EAAE,KAFR,MAAM,KACN,MAAM,GAEJ,MAAM,CAmIlB;AAUD;;;;;;;;;GASG;AACH,sCAHW,MAAM,EAAE,KAHR,MAAM,KACN,MAAM,KACN,MAAM,GAEJ,MAAM,CAgPlB;AAMD;;;;;;;;;;GAUG;AACH,sCAPW,MAAM,EAAE,KACR,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAgSlB"}
+{"version":3,"file":"sdnoise.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/noise/sdnoise.js"],"names":[],"mappings":"AA6LA;;;;;;;GAOG;AACH,sCAHW,MAAM,EAAE,KADR,MAAM,GAEJ,MAAM,CAsDlB;AAUD;;;;;;;;GAQG;AACH,sCAHW,MAAM,EAAE,KAFR,MAAM,KACN,MAAM,GAEJ,MAAM,CAmIlB;AAaD;;;;;;;;GAQG;AACH,sCANW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,KAClC,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAmBlB;AAED;;;;;;;;;;GAUG;AACH,oCANW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,YACN,UAAU,MAAM,CAAC,mBACjB,MAAM,GACJ,IAAI,CAkPhB;AAMD;;;;;;;;;;GAUG;AACH,sCAPW,MAAM,EAAE,KACR,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAgSlB"}

package/src/core/math/noise/sdnoise.js

@@ -404,18 +404,53 @@ export function sdnoise2(derivatives, x, y) {
 const F3 = 0.3333333333333333;
 const G3 = 0.16666666666666666;
 
+const scalar_position = new Float64Array(3);
+const scalar_noise_gradient = new Float64Array(4);
 
-/** 3D simplex noise with derivatives.
- * If the last tthree arguments are not null, the analytic derivative
- * (the 3D gradient of the scalar noise field) is also calculated.
+
+/** 3D simplex noise with its analytic gradient, written into derivatives[0..2].
+ * Scalar facade over {@link sdnoise3_array}; returns the noise value.
  *
+ * @param {number[]|Float32Array|Float64Array} derivatives
  * @param {number} x
  * @param {number} y
  * @param {number} z
- * @param {number[]} derivatives
  * @returns {number}
  */
 export function sdnoise3(derivatives, x, y, z) {
+    scalar_position[0] = x;
+    scalar_position[1] = y;
+    scalar_position[2] = z;
+    sdnoise3_array(scalar_noise_gradient, 0, scalar_position, 0);
+
+    // A destination setter may start another sample and overwrite our scratch.
+    // Capture every lane before the first externally observable store.
+    const noise = scalar_noise_gradient[0];
+    const dx = scalar_noise_gradient[1];
+    const dy = scalar_noise_gradient[2];
+    const dz = scalar_noise_gradient[3];
+
+    derivatives[0] = dx;
+    derivatives[1] = dy;
+    derivatives[2] = dz;
+    return noise;
+}
+
+/**
+ * 3D simplex noise and its analytic gradient, with packed coordinates.
+ * Writes [noise, dx, dy, dz] at out_offset and returns nothing. Coordinates
+ * are read before output stores, so input and output may overlap.
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset
+ * @param {ArrayLike<number>} position
+ * @param {number} position_offset
+ * @returns {void}
+ */
+export function sdnoise3_array(out, out_offset, position, position_offset) {
+    const x = position[position_offset];
+    const y = position[position_offset + 1];
+    const z = position[position_offset + 2];
     let n0, n1, n2, n3; /* Noise contributions from the four simplex corners */
     let gx0, gy0, gz0, gx1, gy1, gz1; /* Gradients at simplex corners */
     let gx2, gy2, gz2, gx3, gy3, gz3;
@@ -648,11 +683,10 @@ export function sdnoise3(derivatives, x, y, z) {
     dnoise_dy *= 28.0;
     dnoise_dz *= 28.0;
 
-    derivatives[0] = dnoise_dx;
-    derivatives[1] = dnoise_dy;
-    derivatives[2] = dnoise_dz;
-
-    return noise;
+    out[out_offset] = noise;
+    out[out_offset + 1] = dnoise_dx;
+    out[out_offset + 2] = dnoise_dy;
+    out[out_offset + 3] = dnoise_dz;
 }
 
 // The skewing and unskewing factors are hairy again for the 4D case

package/src/core/math/spline/spline3_hermite_nearest_point.d.ts

@@ -1,7 +1,7 @@
 /**
  * Finds the parameter 't' of the nearest point on a 1D Hermite spline
  * function graph to a reference point. The curve is defined by (t, p(t)).
- * This version is optimized to avoid allocations.
+ * Scalar facade over {@link spline3_hermite_nearest_point_array}.
  *
  * @param {number} ref_t - The 't' coordinate of the reference point.
  * @param {number} ref_p - The 'p' coordinate of the reference point.
@@ -12,4 +12,19 @@
  * @returns {number} The parameter 't' of the nearest point. This value is always in [0..1] range
  */
 export function spline3_hermite_nearest_point(ref_t: number, ref_p: number, p0: number, p1: number, m0: number, m1: number): number;
+/**
+ * Finds the nearest parameter on a 1D Hermite spline using packed inputs and
+ * writes it into `out[out_offset]`. The reference is `[ref_t, ref_p]` and the
+ * spline is `[p0, p1, m0, m1]`. All inputs are read before the output store,
+ * so the destination may overlap either input.
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset
+ * @param {ArrayLike<number>} reference
+ * @param {number} reference_offset
+ * @param {ArrayLike<number>} spline
+ * @param {number} spline_offset
+ * @returns {void}
+ */
+export function spline3_hermite_nearest_point_array(out: number[] | Float32Array | Float64Array, out_offset: number, reference: ArrayLike<number>, reference_offset: number, spline: ArrayLike<number>, spline_offset: number): void;
 //# sourceMappingURL=spline3_hermite_nearest_point.d.ts.map

package/src/core/math/spline/spline3_hermite_nearest_point.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spline3_hermite_nearest_point.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/spline/spline3_hermite_nearest_point.js"],"names":[],"mappings":"AAyBA;;;;;;;;;;;;GAYG;AACH,qDARW,MAAM,SACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CAyFlB"}
+{"version":3,"file":"spline3_hermite_nearest_point.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/spline/spline3_hermite_nearest_point.js"],"names":[],"mappings":"AA6BA;;;;;;;;;;;;GAYG;AACH,qDARW,MAAM,SACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CAgBlB;AAED;;;;;;;;;;;;;GAaG;AACH,yDARW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,aACN,UAAU,MAAM,CAAC,oBACjB,MAAM,UACN,UAAU,MAAM,CAAC,iBACjB,MAAM,GACJ,IAAI,CAgGhB"}

package/src/core/math/spline/spline3_hermite_nearest_point.js

@@ -20,13 +20,17 @@ function polyval(p, t, size) {
 const quintic_coeffs = new Float32Array(6);
 const quartic_coeffs = new Float32Array(5);
 
+const scalar_reference = new Float64Array(2);
+const scalar_spline = new Float64Array(4);
+const scalar_result = new Float64Array(1);
+
 const NEWTON_STEPS = 3;
 const START_ROOT_COUNT = 5;
 
 /**
  * Finds the parameter 't' of the nearest point on a 1D Hermite spline
  * function graph to a reference point. The curve is defined by (t, p(t)).
- * This version is optimized to avoid allocations.
+ * Scalar facade over {@link spline3_hermite_nearest_point_array}.
  *
  * @param {number} ref_t - The 't' coordinate of the reference point.
  * @param {number} ref_p - The 'p' coordinate of the reference point.
@@ -40,6 +44,43 @@ export function spline3_hermite_nearest_point(
     ref_t, ref_p,
     p0, p1, m0, m1
 ) {
+    scalar_reference[0] = ref_t;
+    scalar_reference[1] = ref_p;
+    scalar_spline[0] = p0;
+    scalar_spline[1] = p1;
+    scalar_spline[2] = m0;
+    scalar_spline[3] = m1;
+
+    spline3_hermite_nearest_point_array(scalar_result, 0, scalar_reference, 0, scalar_spline, 0);
+
+    return scalar_result[0];
+}
+
+/**
+ * Finds the nearest parameter on a 1D Hermite spline using packed inputs and
+ * writes it into `out[out_offset]`. The reference is `[ref_t, ref_p]` and the
+ * spline is `[p0, p1, m0, m1]`. All inputs are read before the output store,
+ * so the destination may overlap either input.
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset
+ * @param {ArrayLike<number>} reference
+ * @param {number} reference_offset
+ * @param {ArrayLike<number>} spline
+ * @param {number} spline_offset
+ * @returns {void}
+ */
+export function spline3_hermite_nearest_point_array(
+    out, out_offset,
+    reference, reference_offset,
+    spline, spline_offset
+) {
+    const ref_t = reference[reference_offset];
+    const ref_p = reference[reference_offset + 1];
+    const p0 = spline[spline_offset];
+    const p1 = spline[spline_offset + 1];
+    const m0 = spline[spline_offset + 2];
+    const m1 = spline[spline_offset + 3];
 
     // 1. Calculate polynomial coefficients A, B, C for p(t)
     const A = 2 * p0 - 2 * p1 + m0 + m1;
@@ -122,5 +163,5 @@ export function spline3_hermite_nearest_point(
         }
     }
 
-    return best_t;
-}
+    out[out_offset] = best_t;
+}

package/src/engine/Engine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Engine.d.ts","sourceRoot":"","sources":["../../../src/engine/Engine.js"],"names":[],"mappings":";6BAqCa,OAAO,8BAA8B,EAAE,cAAc;AAwClE;IAiGI;;;;;;;;;OASG;IACH,sBARW,cAAc;QAEU,aAAa,GAArC,aAAa;QACK,cAAc,GAAhC,OAAO;QACW,WAAW,GAA7B,OAAO;QACW,KAAK,GAAvB,OAAO;OAiPjB;IAtSD;;;OAGG;IACH,UAFU,cAAc,GAAC,IAAI,CAEb;IAEhB;;;OAGG;IACH,OAFU,WAAW,GAAC,IAAI,CAEb;IAEb,qBAA4B;IAE5B;;;;;;;;;OASG;IACH,0BAFU,uBAAuB,CAEe;IAEhD;;;OAGG;IACH,kBAFU,mBAAmB,CAEO;IAEpC;;;;OAIG;IACH,iBAFU,MAAM,CAEM;IAEtB;;;;OAIG;IACH,mBAFU,kBAAkB,CAEa;IAoBrC;;;OAGG;IACH,UAFU,cAAc,CAEA;IAKxB;;;OAGG;IACH,aAFU,gBAAgB,CAEe;IAGzC,yCAAkE;IAK9D,6BAAkC;IAMtC;;;OAGG;IACH,cAFU,aAAa,MAAM,CAAC,CAK5B;IAEF,8CAiCE;IAgCF;;;OAGG;IACH,SAFU,WAAW,CAEoB;IAEzC;;;OAGG;IACH,oCAA0C;IAE1C;;;OAGG;IACH,sCAFU,2BAA2B,CAE+B;IAEpE,yBAAoC;IAGpC;;OAEG;IACH,aAAkB;IAElB;;;OAGG;IACH,SAFU,OAAO,CAEwB;IAGzC,2BAAsC;IAuCtC;;;OAGG;IACH,KAFU,SAAS,CAEO;IAE1B;;;OAGG;IACH,uBAFU,YAAY,CAEqD;IAI3E;;;;;MAKC;IA8BD;;;OAGG;IACH,kBAFU,OAAO,CAEW;IAwIhC,wBAgCC;IApBG,oBAAwB;IAsB5B,2BA8CC;IAED,oBAiBC;IAED;;;OAGG;IACH,+CAUC;IAED,eAkDC;IAED;;;OAGG;IACH,sBAuGC;IAqBD;;OAEG;IACH,sBAgEC;IAED,aAEC;IAED;;OAEG;IACH,4BAOC;IAIL;;;OAGG;IACH,mBAFU,OAAO,CAEQ;;CAPxB;+BAl5B8B,+BAA+B;wBAWtC,wBAAwB;0BArBtB,0CAA0C;wCAeN,iDAAiD;oCAG3E,iCAAiC;mBAElD,wBAAwB;+BAtBZ,gDAAgD;iCAO9C,+CAA+C;8BAGlD,wBAAwB;6BALzB,yBAAyB;uCAIf,6DAA6D;4BAUxE,0BAA0B;+BArBvB,iCAAiC;4CAapB,qDAAqD;AAgBjG;;GAEG;AAGH;IACI,gDAA2D;IAC3D,0BAAkC;IAClC,iCAAyC;CAC5C;6BAvC4B,sCAAsC;sBA4B7C,mBAAmB;yBAJhB,yBAAyB;8BALpB,kCAAkC;2BADrC,mCAAmC;8BAFhC,kCAAkC;8BAClC,kCAAkC;sBAb1C,+BAA+B;+BAKtB,qCAAqC;4BAPxC,kCAAkC;oBAH1C,yBAAyB"}
+{"version":3,"file":"Engine.d.ts","sourceRoot":"","sources":["../../../src/engine/Engine.js"],"names":[],"mappings":";6BAqCa,OAAO,8BAA8B,EAAE,cAAc;AAwClE;IAiGI;;;;;;;;;OASG;IACH,sBARW,cAAc;QAEU,aAAa,GAArC,aAAa;QACK,cAAc,GAAhC,OAAO;QACW,WAAW,GAA7B,OAAO;QACW,KAAK,GAAvB,OAAO;OAiPjB;IAtSD;;;OAGG;IACH,UAFU,cAAc,GAAC,IAAI,CAEb;IAEhB;;;OAGG;IACH,OAFU,WAAW,GAAC,IAAI,CAEb;IAEb,qBAA4B;IAE5B;;;;;;;;;OASG;IACH,0BAFU,uBAAuB,CAEe;IAEhD;;;OAGG;IACH,kBAFU,mBAAmB,CAEO;IAEpC;;;;OAIG;IACH,iBAFU,MAAM,CAEM;IAEtB;;;;OAIG;IACH,mBAFU,kBAAkB,CAEa;IAoBrC;;;OAGG;IACH,UAFU,cAAc,CAEA;IAKxB;;;OAGG;IACH,aAFU,gBAAgB,CAEe;IAGzC,yCAAkE;IAK9D,6BAAkC;IAMtC;;;OAGG;IACH,cAFU,aAAa,MAAM,CAAC,CAK5B;IAEF,8CAiCE;IAgCF;;;OAGG;IACH,SAFU,WAAW,CAEoB;IAEzC;;;OAGG;IACH,oCAA0C;IAE1C;;;OAGG;IACH,sCAFU,2BAA2B,CAE+B;IAEpE,yBAAoC;IAGpC;;OAEG;IACH,aAAkB;IAElB;;;OAGG;IACH,SAFU,OAAO,CAEwB;IAGzC,2BAAsC;IAuCtC;;;OAGG;IACH,KAFU,SAAS,CAEO;IAE1B;;;OAGG;IACH,uBAFU,YAAY,CAEqD;IAI3E;;;;;MAKC;IA8BD;;;OAGG;IACH,kBAFU,OAAO,CAEW;IAwIhC,wBAgCC;IApBG,oBAAwB;IAsB5B,2BA8CC;IAED,oBAiBC;IAED;;;OAGG;IACH,+CAUC;IAED,eAkDC;IAED;;;OAGG;IACH,sBA2GC;IAqBD;;OAEG;IACH,sBAgEC;IAED,aAEC;IAED;;OAEG;IACH,4BAOC;IAIL;;;OAGG;IACH,mBAFU,OAAO,CAEQ;;CAPxB;+BAt5B8B,+BAA+B;wBAWtC,wBAAwB;0BArBtB,0CAA0C;wCAeN,iDAAiD;oCAG3E,iCAAiC;mBAElD,wBAAwB;+BAtBZ,gDAAgD;iCAO9C,+CAA+C;8BAGlD,wBAAwB;6BALzB,yBAAyB;uCAIf,6DAA6D;4BAUxE,0BAA0B;+BArBvB,iCAAiC;4CAapB,qDAAqD;AAgBjG;;GAEG;AAGH;IACI,gDAA2D;IAC3D,0BAAkC;IAClC,iCAAyC;CAC5C;6BAvC4B,sCAAsC;sBA4B7C,mBAAmB;yBAJhB,yBAAyB;8BALpB,kCAAkC;2BADrC,mCAAmC;8BAFhC,kCAAkC;8BAClC,kCAAkC;sBAb1C,+BAA+B;+BAKtB,qCAAqC;4BAPxC,kCAAkC;oBAH1C,yBAAyB"}

package/src/engine/Engine.js

@@ -770,12 +770,14 @@ class Engine {
             ? knowledge.load(this.assetManager, this.executor)
             : Promise.resolve();
 
-        return Promise.all([
+        const startupPromises = [
             soundStarted.then(promiseEntityManager),
             knowledgeLoaded,
             this.gui.startup(this),
             this.plugins.startup()
-        ]).then(async () => {
+        ];
+
+        return Promise.all(startupPromises).then(async () => {
 
             this.#last_frame_timestamp = performance.now();
 
@@ -804,6 +806,8 @@ class Engine {
             logger.info('engine started');
         }, async (e) => {
             logger.error(`Engine Failed to start: ${e}`);
+            // Each branch must settle before its resources can safely be released.
+            await Promise.allSettled(startupPromises);
 
             // Unwind what did come up. Before the Promise.all this method has already acquired the
             // GPU device, started the asset manager, subscribed the sound engine to pointer and

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

@@ -134,6 +134,15 @@ export class FirstPersonPlayerController {
                 upFactor: number;
                 nearWallMaxDistance: number;
             };
+            scrambleUp: {
+                baseJumpForce: number;
+                momentumForcePerSpeed: number;
+                maxJumpForce: number;
+                decel: number;
+                hugSpeed: number;
+                maxDuration: number;
+                kickOutwardImpulse: number;
+            };
             slide: {
                 minEntrySpeed: number;
                 endSpeed: number;

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

@@ -1 +1 @@
-{"version":3,"file":"FirstPersonPlayerController.d.ts","sourceRoot":"","sources":["../../../../../src/engine/control/first-person/FirstPersonPlayerController.js"],"names":[],"mappings":"AA8HA;;;;;;;;;;GAUG;AACH;IACI,wBAAgD;IAEhD,0CAAiD;IACjD,0BAAiC;IACjC,wBAA+B;IAC/B,sBAA6B;IAC7B,4BAAmC;IAEnC;;;;;;OAMG;IACH,SAFU,UAAU,CAEO;IAE3B;;;;;OAKG;IACH,WAFU,UAAU,CAES;IAE7B;;;;;;OAMG;IACH,WAFU,MAAM,CAED;IAEf;;;;;;;;;;;;;;;qCA7FA,+EAA+E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+F9E;IAED,0BAIC;IAED;;OAEG;IACH,YAFW,2BAA2B,QAKrC;IAED,qCAIC;IAED,4BAGC;IAED,eAGC;CACJ;;;;;kDAzMiD,wCAAwC;AAK1F;;;;;;;;GAQG;AACH;IACI,oEAAoE;IACpE,MADyD,OAAO,CACvC;IAEzB;;;;OAIG;IACH,MAFU,OAAO,CAEQ;IAEzB,mEAAmE;IACnE,MADwD,OAAO,CAClD;IAEb,0EAA0E;IAC1E,QAD+D,OAAO,CACvD;IAEf,qEAAqE;IACrE,QAD0D,OAAO,CAClD;CAClB;AAED;;;GAGG;AACH;IACI,kBAAgB;IAChB,0BAAsB;IAEtB,4EAA4E;IAC5E,sBAAoC;IACpC,gBAAkB;IAElB,cAAU;IACV,4DAA4D;IAC5D,wBAAoB;IACpB,yEAAyE;IACzE,uBAAgD;IAEhD,sBAAkB;IAClB,qBAAiB;IACjB,qBAAiB;IAEjB,4BAAwB;IACxB,4BAA2B;IAC3B,2BAA0B;IAC1B,2EAA2E;IAC3E,qBAAoB;IAEpB,iBAAa;IACb,oBAAgB;IAChB,qBAAiB;IACjB,yBAAqB;IAErB,oBAAgB;IAChB,kBAAc;IACd,kDAAkD;IAClD,iBAAa;IAEb,kBAAiB;IAEjB,+EAA+E;IAC/E,uBAAsB;IACtB,6EAA6E;IAC7E,sBAAqB;IAErB;;;;;;;OAOG;IACH,SAFU,MAAM,CAEmB;IAEnC,oBAAgB;CACnB;gCAzFkF,2BAA2B;AA2F9G;;;GAGG;AACH;IACI,uDAAuD;IACvD,mBAA0B;IAC1B,yEAAyE;IACzE,oBAA2B;IAC3B,kBAAkB;IAClB,mBAA0B;IAC1B,6BAA6B;IAC7B,sBAA6B;IAC7B,iDAAiD;IACjD,eAAsB;IACtB,sBAA6B;IAC7B,qBAA4B;IAC5B,sBAA6B;IAC7B,qBAA4B;IAC5B,2EAA2E;IAC3E,mBAA0B;IAC1B,2EAA2E;IAC3E,oBAA2B;IAC3B,6DAA6D;IAC7D,oBAA2B;IAC3B,+DAA+D;IAC/D,uBAA8B;CACjC;2BAvH0B,yBAAyB;2BAFzB,2BAA2B;uCAG6B,2BAA2B;0CAA3B,2BAA2B;oBAL1F,+BAA+B;oBAC/B,+BAA+B;mBAFhC,uCAAuC"}
+{"version":3,"file":"FirstPersonPlayerController.d.ts","sourceRoot":"","sources":["../../../../../src/engine/control/first-person/FirstPersonPlayerController.js"],"names":[],"mappings":"AA8HA;;;;;;;;;;GAUG;AACH;IACI,wBAAgD;IAEhD,0CAAiD;IACjD,0BAAiC;IACjC,wBAA+B;IAC/B,sBAA6B;IAC7B,4BAAmC;IAEnC;;;;;;OAMG;IACH,SAFU,UAAU,CAEO;IAE3B;;;;;OAKG;IACH,WAFU,UAAU,CAES;IAE7B;;;;;;OAMG;IACH,WAFU,MAAM,CAED;IAEf;;;;;;;;;;;;;;;qCA7FA,+EAA+E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+F9E;IAED,0BAIC;IAED;;OAEG;IACH,YAFW,2BAA2B,QAKrC;IAED,qCAIC;IAED,4BAGC;IAED,eAGC;CACJ;;;;;kDAzMiD,wCAAwC;AAK1F;;;;;;;;GAQG;AACH;IACI,oEAAoE;IACpE,MADyD,OAAO,CACvC;IAEzB;;;;OAIG;IACH,MAFU,OAAO,CAEQ;IAEzB,mEAAmE;IACnE,MADwD,OAAO,CAClD;IAEb,0EAA0E;IAC1E,QAD+D,OAAO,CACvD;IAEf,qEAAqE;IACrE,QAD0D,OAAO,CAClD;CAClB;AAED;;;GAGG;AACH;IACI,kBAAgB;IAChB,0BAAsB;IAEtB,4EAA4E;IAC5E,sBAAoC;IACpC,gBAAkB;IAElB,cAAU;IACV,4DAA4D;IAC5D,wBAAoB;IACpB,yEAAyE;IACzE,uBAAgD;IAEhD,sBAAkB;IAClB,qBAAiB;IACjB,qBAAiB;IAEjB,4BAAwB;IACxB,4BAA2B;IAC3B,2BAA0B;IAC1B,2EAA2E;IAC3E,qBAAoB;IAEpB,iBAAa;IACb,oBAAgB;IAChB,qBAAiB;IACjB,yBAAqB;IAErB,oBAAgB;IAChB,kBAAc;IACd,kDAAkD;IAClD,iBAAa;IAEb,kBAAiB;IAEjB,+EAA+E;IAC/E,uBAAsB;IACtB,6EAA6E;IAC7E,sBAAqB;IAErB;;;;;;;OAOG;IACH,SAFU,MAAM,CAEmB;IAEnC,oBAAgB;CACnB;gCAzFkF,2BAA2B;AA2F9G;;;GAGG;AACH;IACI,uDAAuD;IACvD,mBAA0B;IAC1B,yEAAyE;IACzE,oBAA2B;IAC3B,kBAAkB;IAClB,mBAA0B;IAC1B,6BAA6B;IAC7B,sBAA6B;IAC7B,iDAAiD;IACjD,eAAsB;IACtB,sBAA6B;IAC7B,qBAA4B;IAC5B,sBAA6B;IAC7B,qBAA4B;IAC5B,2EAA2E;IAC3E,mBAA0B;IAC1B,2EAA2E;IAC3E,oBAA2B;IAC3B,6DAA6D;IAC7D,oBAA2B;IAC3B,+DAA+D;IAC/D,uBAA8B;CACjC;2BAvH0B,yBAAyB;2BAFzB,2BAA2B;uCAG6B,2BAA2B;0CAA3B,2BAA2B;oBAL1F,+BAA+B;oBAC/B,+BAA+B;mBAFhC,uCAAuC"}

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