@woosh/meep-engine 3.30.0 → 3.32.0

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

@@ -147,6 +147,29 @@ export class System<C> {
      * @type {(time_delta_seconds: number) => void} time delta will always be the same value, controlled via {@link EntityManager.fixedUpdateStepSize}
      */
     fixedUpdate: (time_delta_seconds: number) => void;
+    /**
+     * Opens a fixed step: called for every system that defines it, in execution order, after
+     * {@link EntityManager.fixedStepTick} has advanced and before any system's {@link fixedUpdate} for
+     * the step. The counterpart of {@link closeFixedStep}, which the same system gets after every
+     * {@link fixedUpdate} of the step, in reverse execution order — so steps nest: the first to open is
+     * the last to close.
+     *
+     * This is for work that frames a step as a unit rather than takes part in it: opening and closing
+     * a network frame the whole step's simulation is recorded into, or putting render-only values back
+     * before anything simulates from them. It runs outside the derived execution order on purpose, so
+     * it must not simulate: simulation belongs in {@link fixedUpdate}, where the data a system touches
+     * is declared and ordered.
+     *
+     * {@link closeFixedStep} is called only for systems whose open returned normally.
+     *
+     * @type {() => void}
+     */
+    openFixedStep: () => void;
+    /**
+     * Closes a fixed step. See {@link openFixedStep}.
+     * @type {() => void}
+     */
+    closeFixedStep: () => void;
     /**
      * This update is generally synchronized with the render loop.
      * Note that this time step can vary depending on system conditions and hardware we are running on.

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

@@ -1 +1 @@
-{"version":3,"file":"System.d.ts","sourceRoot":"","sources":["../../../../src/engine/ecs/System.js"],"names":[],"mappings":"AAMA;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH;IAEI;;;;;OAKG;IACH,yBAFU,aAAa,CAEF;IAErB;;;;OAIG;IACH,gBAFU,cAAe,WAAW,CAAC,CAEU;IAE/C;;;;;;;;;OASG;IACH,6BAAkB;IAElB;;;;;;;;;;OAUG;IACH,0BAFU,4FAA6B,CAElB;IAGrB;;OAEG;IACH,mCAcC;IAED;;;;;OAKG;IACH,oCAFY,MAAM,CA8BjB;IAED;;;;;;OAMG;IACH,uBAJW,aAAa,GACX,QAAQ,IAAI,CAAC,CAKzB;IAED;;;;;;;OAOG;IACH,wBAJW,aAAa,GACX,QAAQ,IAAI,CAAC,CAKzB;IAGD;;;;;OAKG;IACH,wCAEC;IAED;;;;;OAKG;IACH,0CAEC;IAED;;;;;;;;;;OAUG;IACH,+BAFW,sBAAsB,QAIhC;IAED;;;;;;;;;;OAUG;IACH,+BAFW,sBAAsB,QAIhC;IAIL;;;OAGG;IACH,mBAFU,OAAO,CAEQ;IAEzB;;;;OAIG;IACH,aAFU,CAAC,kBAAkB,EAAE,MAAM,KAAK,IAAI,CAElB;IAG5B;;;;;;OAMG;IACH,QAFU,CAAC,kBAAkB,EAAE,MAAM,KAAK,IAAI,CAEvB;CAvBtB;0BA2BS,MAAM;;;;;;;;;qCAzOH,OAAO,6BAA6B,EAAE,sBAAsB;4BAC5D,OAAO,oBAAoB,EAAE,aAAa;0BAN7B,mCAAmC"}
+{"version":3,"file":"System.d.ts","sourceRoot":"","sources":["../../../../src/engine/ecs/System.js"],"names":[],"mappings":"AAMA;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH;IAEI;;;;;OAKG;IACH,yBAFU,aAAa,CAEF;IAErB;;;;OAIG;IACH,gBAFU,cAAe,WAAW,CAAC,CAEU;IAE/C;;;;;;;;;OASG;IACH,6BAAkB;IAElB;;;;;;;;;;OAUG;IACH,0BAFU,4FAA6B,CAElB;IAGrB;;OAEG;IACH,mCAcC;IAED;;;;;OAKG;IACH,oCAFY,MAAM,CA8BjB;IAED;;;;;;OAMG;IACH,uBAJW,aAAa,GACX,QAAQ,IAAI,CAAC,CAKzB;IAED;;;;;;;OAOG;IACH,wBAJW,aAAa,GACX,QAAQ,IAAI,CAAC,CAKzB;IAGD;;;;;OAKG;IACH,wCAEC;IAED;;;;;OAKG;IACH,0CAEC;IAED;;;;;;;;;;OAUG;IACH,+BAFW,sBAAsB,QAIhC;IAED;;;;;;;;;;OAUG;IACH,+BAFW,sBAAsB,QAIhC;IAIL;;;OAGG;IACH,mBAFU,OAAO,CAEQ;IAEzB;;;;OAIG;IACH,aAFU,CAAC,kBAAkB,EAAE,MAAM,KAAK,IAAI,CAElB;IAG5B;;;;;;;;;;;;;;;;OAgBG;IACH,eAFU,MAAM,IAAI,CAEU;IAE9B;;;OAGG;IACH,gBAFU,MAAM,IAAI,CAEW;IAE/B;;;;;;OAMG;IACH,QAFU,CAAC,kBAAkB,EAAE,MAAM,KAAK,IAAI,CAEvB;CAhDtB;0BAoDS,MAAM;;;;;;;;;qCAlQH,OAAO,6BAA6B,EAAE,sBAAsB;4BAC5D,OAAO,oBAAoB,EAAE,aAAa;0BAN7B,mCAAmC"}

package/src/engine/ecs/System.js

@@ -228,6 +228,31 @@ System.prototype.isSystem = true;
 System.prototype.fixedUpdate = noop; // by assigning NO-OP we enable a simple check, whether running the update would be useful
 
 
+/**
+ * Opens a fixed step: called for every system that defines it, in execution order, after
+ * {@link EntityManager.fixedStepTick} has advanced and before any system's {@link fixedUpdate} for
+ * the step. The counterpart of {@link closeFixedStep}, which the same system gets after every
+ * {@link fixedUpdate} of the step, in reverse execution order — so steps nest: the first to open is
+ * the last to close.
+ *
+ * This is for work that frames a step as a unit rather than takes part in it: opening and closing
+ * a network frame the whole step's simulation is recorded into, or putting render-only values back
+ * before anything simulates from them. It runs outside the derived execution order on purpose, so
+ * it must not simulate: simulation belongs in {@link fixedUpdate}, where the data a system touches
+ * is declared and ordered.
+ *
+ * {@link closeFixedStep} is called only for systems whose open returned normally.
+ *
+ * @type {() => void}
+ */
+System.prototype.openFixedStep = noop;
+
+/**
+ * Closes a fixed step. See {@link openFixedStep}.
+ * @type {() => void}
+ */
+System.prototype.closeFixedStep = noop;
+
 /**
  * This update is generally synchronized with the render loop.
  * Note that this time step can vary depending on system conditions and hardware we are running on.

package/src/engine/ecs/components/Tag.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Tag.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/components/Tag.js"],"names":[],"mappings":"AAIA;;GAEG;AACH;IAsNI;;;;;OAKG;IACH,kBAJW,MAAM,EAAE,gCAEN,MAAM,EAAE,CAsBpB;IAED;;;;OAIG;IACH,oBAHW,MAAM,GACJ,GAAG,CAQf;IAGD;;;;OAIG;IACH,4BAFa,GAAG,CAQf;IAED;;;;OAIG;IACH,sBAHW,MAAM,GACL,GAAG,CAUd;IAzRD;;;OAGG;IACH,eAAY;IAEZ;;;OAGG;IACH,oBAEC;IAED;;;;OAIG;IACH,OAHW,MAAM,GACJ,MAAM,CAMlB;IAED,cAEC;IAED;;;;OAIG;IACH,WAHW,MAAM,GACJ,OAAO,CAYnB;IAED;;;OAGG;IACH,eAFW,MAAM,EAAE,QAWlB;IAED;;;OAGG;IACH,YAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GACJ,OAAO,CAMnB;IAED;;;OAGG;IACH,oBAFW,MAAM,EAAE,WA4BlB;IAED;;;;OAIG;IACH,sBAHW,MAAM,EAAE,GACN,OAAO,CAsBnB;IAED;;;OAGG;IACH,aAFa,MAAM,EAAE,CAIpB;IAED;;;;OAIG;IACH,yBAHoB,MAAM,+BAKzB;IAED;;;OAGG;IACH,QAFY,MAAM,CAmBjB;IAED;;;;OAIG;IACH,cAHW,GAAG,GACF,OAAO,CAIlB;IAED,mBAEC;IAED;;;OAGG;IACH,eAFW,MAAM,EAAE,GAAC,MAAM,QAiBzB;CAuEJ;;kBAIS,MAAM"}
+{"version":3,"file":"Tag.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/components/Tag.js"],"names":[],"mappings":"AAIA;;GAEG;AACH;IAyNI;;;;;OAKG;IACH,kBAJW,MAAM,EAAE,gCAEN,MAAM,EAAE,CAsBpB;IAED;;;;OAIG;IACH,oBAHW,MAAM,GACJ,GAAG,CAQf;IAGD;;;;OAIG;IACH,4BAFa,GAAG,CAQf;IAED;;;;OAIG;IACH,sBAHW,MAAM,GACL,GAAG,CAUd;IA5RD;;;OAGG;IACH,eAAY;IAEZ;;;OAGG;IACH,oBAEC;IAED;;;;OAIG;IACH,OAHW,MAAM,GACJ,MAAM,CAMlB;IAED,cAEC;IAED;;;;OAIG;IACH,WAHW,MAAM,GACJ,OAAO,CAYnB;IAED;;;OAGG;IACH,eAFW,MAAM,EAAE,QAWlB;IAED;;;OAGG;IACH,YAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GACJ,OAAO,CAMnB;IAED;;;OAGG;IACH,oBAFW,MAAM,EAAE,WA4BlB;IAED;;;;OAIG;IACH,sBAHW,MAAM,EAAE,GACN,OAAO,CAsBnB;IAED;;;OAGG;IACH,aAFa,MAAM,EAAE,CAIpB;IAED;;;;OAIG;IACH,yBAHoB,MAAM,+BAKzB;IAED;;;OAGG;IACH,QAFY,MAAM,CAmBjB;IAED;;;;OAIG;IACH,cAHW,GAAG,GACF,OAAO,CAIlB;IAED,mBAKC;IAED;;;OAGG;IACH,eAFW,MAAM,EAAE,GAAC,MAAM,QAiBzB;CAuEJ;;kBAIS,MAAM"}

package/src/engine/ecs/components/Tag.js

@@ -195,7 +195,10 @@ export class Tag {
     }
 
     toJSON() {
-        return this.values;
+        // a copy: `values` is private, and `EntityBlueprint.add` keeps whatever comes back here as
+        // its template, so handing out the live array let a later `tag.add` change every entity the
+        // blueprint had yet to build
+        return this.values.slice();
     }
 
     /**

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

@@ -1,2 +1,14 @@
-declare function computeComponentClassName(klass: any): any;
+/**
+ * Best available human-readable name for a component class, for diagnostics.
+ *
+ * NOTE: exported. It was declared without the keyword, so the module had an empty export list and
+ * nothing could import it - which is why the one consumer referenced it as a free variable and got
+ * a ReferenceError instead of the message it was building.
+ *
+ * @param {Function|{type: string}} klass
+ * @returns {string}
+ */
+export function computeComponentClassName(klass: Function | {
+    type: string;
+}): string;
 //# sourceMappingURL=computeComponentClassName.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"computeComponentClassName.d.ts","sourceRoot":"","sources":["../../../../src/engine/ecs/computeComponentClassName.js"],"names":[],"mappings":"AAAA,4DAYC"}
+{"version":3,"file":"computeComponentClassName.d.ts","sourceRoot":"","sources":["../../../../src/engine/ecs/computeComponentClassName.js"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,iDAHW,WAAS;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,GACrB,MAAM,CAclB"}

package/src/engine/ecs/computeComponentClassName.js

@@ -1,4 +1,14 @@
-function computeComponentClassName(klass) {
+/**
+ * Best available human-readable name for a component class, for diagnostics.
+ *
+ * NOTE: exported. It was declared without the keyword, so the module had an empty export list and
+ * nothing could import it - which is why the one consumer referenced it as a free variable and got
+ * a ReferenceError instead of the message it was building.
+ *
+ * @param {Function|{type: string}} klass
+ * @returns {string}
+ */
+export function computeComponentClassName(klass) {
     if (klass === undefined) {
         return "undefined";
     } else if (klass === null) {

package/src/engine/ecs/dynamic_actions/DynamicActorSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DynamicActorSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/dynamic_actions/DynamicActorSystem.js"],"names":[],"mappings":"AA6FA;IA4DI;;;OAGG;IACH,4BASC;IAxED,sCAA8B;IAE9B,kEAEE;IAEF;;;OAGG;IACH,sCAAgB;IAEhB;;;OAGG;IACH,OAFU,SAAS,CAEK;IAExB;;;;OAIG;IACH,iCAOG;IAEH;;;;OAIG;IACH,gCAAoC;IAEpC;;;OAGG;IACH,mCAAiB;IAEjB;;;;OAIG;IACH,uBAAmB;IAEnB;;;;OAIG;IACH,gBAAgB;IASZ;;;OAGG;IACH,eAAoB;IAIxB;;;OAGG;IACH,kBAFY,MAAM,CAIjB;IAED;;;;;OAKG;IACH,6BAJW,MAAM,uDAyBhB;IAED;;;OAGG;IACH,iCAFW,MAAM,QAehB;IAED;;;;;OAKG;IACH,oBAJW,MAAM,oDA4DhB;IAED;;;;OAIG;IACH,4BAHW,MAAM,SACN,SAAS,QAsDnB;IAED;;;;OAIG;IACH,yBAFY,yBAAuB,SAAS,CA6E3C;IAED;;;;;;;;;OASG;IACH,yCALW,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,wBAAwB,KAAK,IAAI,+BAEzD,MAAM,GACJ;QAAC,MAAM,EAAC,MAAM,CAAC;QAAA,IAAI,yBAAwB;QAAC,KAAK,EAAE,SAAS,CAAA;KAAC,EAAE,CA4E3E;IAED;;;;;;OAMG;IACH,cALW,MAAM,SACN,MAAM,iBAEJ,yBAAuB,SAAS,CAiC5C;IAED,2CAQC;IAED;;;;;OAKG;IACH,mCAiBC;IAED,6BAYC;CACJ;sCAtkBqC,oCAAoC;6BAG7C,mBAAmB;2BATrB,6CAA6C;4CAP5B,oDAAoD;0BAetE,gBAAgB"}
+{"version":3,"file":"DynamicActorSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/dynamic_actions/DynamicActorSystem.js"],"names":[],"mappings":"AAwGA;IA4DI;;;OAGG;IACH,4BASC;IAxED,sCAA8B;IAE9B,kEAEE;IAEF;;;OAGG;IACH,sCAAgB;IAEhB;;;OAGG;IACH,OAFU,SAAS,CAEK;IAExB;;;;OAIG;IACH,iCAOG;IAEH;;;;OAIG;IACH,gCAAoC;IAEpC;;;OAGG;IACH,mCAAiB;IAEjB;;;;OAIG;IACH,uBAAmB;IAEnB;;;;OAIG;IACH,gBAAgB;IASZ;;;OAGG;IACH,eAAoB;IAIxB;;;OAGG;IACH,kBAFY,MAAM,CAIjB;IAED;;;;;OAKG;IACH,6BAJW,MAAM,uDAyBhB;IAED;;;OAGG;IACH,iCAFW,MAAM,QAehB;IAED;;;;;OAKG;IACH,oBAJW,MAAM,oDA4DhB;IAED;;;;OAIG;IACH,4BAHW,MAAM,SACN,SAAS,QAsDnB;IAED;;;;OAIG;IACH,yBAFY,yBAAuB,SAAS,CA6E3C;IAED;;;;;;;;;OASG;IACH,yCALW,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,wBAAwB,KAAK,IAAI,+BAEzD,MAAM,GACJ;QAAC,MAAM,EAAC,MAAM,CAAC;QAAA,IAAI,yBAAwB;QAAC,KAAK,EAAE,SAAS,CAAA;KAAC,EAAE,CA4E3E;IAED;;;;;;OAMG;IACH,cALW,MAAM,SACN,MAAM,iBAEJ,yBAAuB,SAAS,CAiC5C;IAED,2CAQC;IAED;;;;;OAKG;IACH,mCAiBC;IAED,6BAYC;CACJ;sCAjlBqC,oCAAoC;6BAG7C,mBAAmB;2BATrB,6CAA6C;4CAP5B,oDAAoD;0BAetE,gBAAgB"}

package/src/engine/ecs/dynamic_actions/DynamicActorSystem.js

@@ -48,6 +48,17 @@ class Context extends SystemEntityContext {
      */
     next_idle_event_time = 0;
 
+    reset() {
+        super.reset();
+
+        // the context is pooled: anything set outside link() survives into the next entity that
+        // draws this object unless it is cleared here
+        this.execution.rule = null;
+        this.execution.executor = null;
+
+        this.next_idle_event_time = 0;
+    }
+
     /**
      *
      * @param {string} event

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

@@ -1 +1 @@
-{"version":3,"file":"FogOfWar.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/fow/FogOfWar.js"],"names":[],"mappings":"AA8CA;;GAEG;AACH;IAEI;;;OAGG;IACH,oBAFU,OAAO,CAES;IAC1B;;;OAGG;IACH,0BAFU,OAAO,CAEgB;IAEjC;;;OAGG;IACH,OAFU,OAAO,CAEM;IAEvB;;;OAGG;IACH,MAFU,OAAO,CAEQ;IAEzB,eAAsC;IAEtC;;;;;;;;;;OAUG;IACH,WAFU,gBAAgB,CAEW;IAErC;;;OAGG;IACH,UAFU,aAAa,CAE2B;IAWlD;;MAEE;IAEF;;;OAGG;IACH,SAFU,SAAS,CAEgB;IAEnC;;;OAGG;IACH,iBAFU,SAAS,CAEwB;IAE3C;;;OAGG;IACH,sBAFW,MAAM,QA6EhB;IA4DD;;;;OAIG;IACH,eAHW,MAAM,KACN,MAAM,QAUhB;IAED,cAQC;IAED,kBAQC;IAED,mBAEC;IAED;;;;;OAKG;IACH,UAJW,MAAM,KACN,MAAM,UACN,MAAM,QAmChB;IAED;;;;;OAKG;IACH,WAJW,MAAM,KACN,MAAM,UACN,MAAM,QAmChB;IAED;;;;;;OAMG;IACH,yBAcC;IAmDD,sBAWC;IAED;;;OAGG;IACH,kBAFW,MAAM,QAYhB;IAED;;;OAGG;IACH,0DA+BC;IAED;;;;;OAKG;IACH,yBAJW,MAAM,KACN,MAAM,UACN,MAAM,EAAE,QAelB;IAED;;;;;OAKG;IACH,yEAFW,MAAM,WA+EhB;IAED;;;;;OAKG;IACH,qBAJW,MAAM,KACN,MAAM,GACJ,MAAM,CASlB;IAED,6BAKC;IAED,+BASC;IAED,uBAyBC;IAGD;;;;;OAKG;IACH,UAJW,MAAM,KACN,MAAM,oBAahB;;CACJ;;;;oBAzrBmB,+BAA+B;oBAC/B,+BAA+B;oBAC/B,+BAA+B;iCAMlB,uBAAuB;8BAX1B,iDAAiD;mBAE5D,uCAAuC;0BAQhC,6CAA6C"}
+{"version":3,"file":"FogOfWar.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/fow/FogOfWar.js"],"names":[],"mappings":"AA8CA;;GAEG;AACH;IAEI;;;OAGG;IACH,oBAFU,OAAO,CAES;IAC1B;;;OAGG;IACH,0BAFU,OAAO,CAEgB;IAEjC;;;OAGG;IACH,OAFU,OAAO,CAEM;IAEvB;;;OAGG;IACH,MAFU,OAAO,CAEQ;IAEzB,eAAsC;IAEtC;;;;;;;;;;OAUG;IACH,WAFU,gBAAgB,CAEW;IAErC;;;OAGG;IACH,UAFU,aAAa,CAE2B;IAWlD;;MAEE;IAEF;;;OAGG;IACH,SAFU,SAAS,CAEgB;IAEnC;;;OAGG;IACH,iBAFU,SAAS,CAEwB;IAE3C;;;OAGG;IACH,sBAFW,MAAM,QA6EhB;IA4DD;;;;OAIG;IACH,eAHW,MAAM,KACN,MAAM,QAUhB;IAED,cAQC;IAED,kBAQC;IAED,mBAEC;IAED;;;;;OAKG;IACH,UAJW,MAAM,KACN,MAAM,UACN,MAAM,QAmChB;IAED;;;;;OAKG;IACH,WAJW,MAAM,KACN,MAAM,UACN,MAAM,QAmChB;IAED;;;;;;OAMG;IACH,yBAcC;IAmDD,sBAWC;IAED;;;OAGG;IACH,kBAFW,MAAM,QAYhB;IAED;;;OAGG;IACH,0DA+BC;IAED;;;;;OAKG;IACH,yBAJW,MAAM,KACN,MAAM,UACN,MAAM,EAAE,QAelB;IAED;;;;;OAKG;IACH,yEAFW,MAAM,WA4FhB;IAED;;;;;OAKG;IACH,qBAJW,MAAM,KACN,MAAM,GACJ,MAAM,CAsBlB;IAED,6BAKC;IAED,+BASC;IAED,uBAyBC;IAGD;;;;;OAKG;IACH,UAJW,MAAM,KACN,MAAM,oBAahB;;CACJ;;;;oBAntBmB,+BAA+B;oBAC/B,+BAA+B;oBAC/B,+BAA+B;iCAMlB,uBAAuB;8BAX1B,iDAAiD;mBAE5D,uCAAuC;0BAQhC,6CAA6C"}

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

@@ -546,8 +546,23 @@ export class FogOfWar {
     computeAABBVisibility(aabb, cameraFocalPoint, clearance) {
         assert.isNumber(clearance, 'clearance');
 
-        let sx0 = this.size.x - 1;
-        let sy0 = this.size.y - 1;
+        const distanceSampler = this.distanceSampler;
+
+        /*
+         worldToSamplePosition returns coordinates in the PADDED sampler's space — it adds the +1
+         guard border offset, and the sampler is size + 2 on each axis. The clamp here was to
+         size - 1, two indices short of the padded maximum, so the last world cell and everything
+         beyond it was tested against a cell two rows and columns back inside the map. The guard
+         border exists precisely so a lookup just outside the fogged area has something correct to
+         read.
+        */
+        const sampler_max_x = distanceSampler.width - 1;
+        const sampler_max_y = distanceSampler.height - 1;
+
+        // the sample-space bounding box is seeded from the sampler's extent for the same reason: a
+        // box lying wholly out in the border must not pick up size - 1 as its lower bound
+        let sx0 = sampler_max_x;
+        let sy0 = sampler_max_y;
         let sx1 = 0;
         let sy1 = 0;
 
@@ -566,8 +581,6 @@ export class FogOfWar {
         corners2d[6] = aabb.x1;
         corners2d[7] = aabb.z1;
 
-        const distanceSampler = this.distanceSampler;
-
         //check corners, this is fast compared to checking each cell of fog overlapping bounding box
         for (i = 0; i < 8; i += 2) {
 
@@ -579,10 +592,10 @@ export class FogOfWar {
             const sampleX = samplePosition[0];
             const sampleY = samplePosition[1];
 
-            const sX = clamp(sampleX, 0, this.size.x - 1);
-            const sY = clamp(sampleY, 0, this.size.y - 1);
+            const sX = clamp(sampleX, 0, sampler_max_x);
+            const sY = clamp(sampleY, 0, sampler_max_y);
 
-            const distance = distanceSampler.readChannel(sX | 0, sY | 0, 0);
+            const distance = distanceSampler.readChannel(Math.floor(sX), Math.floor(sY), 0);
 
             //Check if cell is visible
             if (distance <= clearance) {
@@ -608,7 +621,7 @@ export class FogOfWar {
         const sMidX = sx0 + shExtX;
         const sMidY = sy0 + shExtY;
 
-        const centerOcclusionDistance = distanceSampler.readChannel(sMidX | 0, sMidY | 0, 0);
+        const centerOcclusionDistance = distanceSampler.readChannel(Math.floor(sMidX), Math.floor(sMidY), 0);
 
         const maxDistanceFromCenter = max2(shExtX, shExtY);
 
@@ -631,10 +644,23 @@ export class FogOfWar {
     getWorldClearance(x, y) {
         this.worldToSamplePosition(x, y, samplePosition);
 
-        const sampleX = samplePosition[0];
-        const sampleY = samplePosition[1];
+        const distanceSampler = this.distanceSampler;
 
-        return this.distanceSampler.readChannel(sampleX | 0, sampleY | 0, 0);
+        /*
+         Clamped into the PADDED sampler, which is size + 2 on each axis.
+
+         This used to read whatever the raw sample coordinate indexed. A world position past the
+         +X edge ran off the end of its row and wrapped into the next one — on a 4x4 fog, world
+         (8, 0) is padded sample (7, 1), and 1 * 6 + 7 is the cell at (1, 2), so a point twice the
+         map's width away reported that cell's clearance — and a negative one indexed off the front
+         of the buffer entirely, where the undefined that came back compared false against every
+         threshold. Math.floor rather than | 0 because | 0 truncates toward zero, which folds a
+         negative coordinate onto row 0 rather than off the map.
+        */
+        const sampleX = clamp(samplePosition[0], 0, distanceSampler.width - 1);
+        const sampleY = clamp(samplePosition[1], 0, distanceSampler.height - 1);
+
+        return distanceSampler.readChannel(Math.floor(sampleX), Math.floor(sampleY), 0);
     }
 
     rebuildDistanceField() {

package/src/engine/ecs/parent/EntityNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EntityNode.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/parent/EntityNode.js"],"names":[],"mappings":"AAcA;;;GAGG;AACH;IAyLI;;;;OAIG;IACH,2CAFY,UAAU,CAYrB;IAvKD;;;OAGG;IACH,qBAFW,MAAM,EAWhB;IA7CD;;;;OAIG;IACH,iBAAgB;IAEhB;;;;OAIG;IACH,mBAAgB;IAEhB;;;;OAIG;IACH,oBAAgC;IAEhC;;;MAGE;IAEF;;;OAGG;IACH,OAFU,MAAM,CAEM;IAQlB;;;;OAIG;IACH,iBAAsB;IAI1B;;;;OAIG;IACH,cAHW,MAAM,GAAC,eAAe,GACpB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,eAAe,GACpB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,eAAe,SACtB,OAAO,QAQjB;IAED;;;;OAIG;IACH,cAHW,MAAM,GAAC,eAAe,GACpB,OAAO,CAInB;IAED;;;;OAIG;IACH,kBAHW,CAAC,IAAI,EAAE,UAAU,QAAM,uBAcjC;IAED;;;;OAIG;IACH,0BAHW,CAAC,IAAI,EAAE,UAAU,QAAM,uBAKjC;IAED;;;OAGG;IACH,sCAEC;IAED;;;;;;;;OAQG;IACH,8BA4BC;IAED;;;;;;;;;;;;;OAaG;IACH,qBAFa,IAAI,CAShB;IAmBD;;;;OAIG;IACH,8BAaC;IAED;;OAEG;IACH,6BAEC;IAED;;;OAGG;IACH,uBAMC;IAUD;;;OAGG;IACH,6BAyCC;IArDD;;;OAGG;IACH,yBAEC;IAiDD;;;OAGG;IACH,qBAEC;IAED;;;;OAIG;IACH,eAHW,UAAU,GACR,OAAO,CAuBnB;IAED;;;;OAIG;IACH,kBAHW,UAAU,GACR,OAAO,CAenB;IAED,uBAEC;IAED;;;OAGG;IACH,yCA+CC;IAGD,gBAoBC;IAGL;;;OAGG;IACH,uBAFU,OAAO,CAEgB;CANhC;mBA9bkB,uCAAuC;gCAI1B,sBAAsB;4BAD1B,6BAA6B;mBAFtC,cAAc"}
+{"version":3,"file":"EntityNode.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/parent/EntityNode.js"],"names":[],"mappings":"AAcA;;;GAGG;AACH;IAyLI;;;;OAIG;IACH,2CAFY,UAAU,CAYrB;IAvKD;;;OAGG;IACH,qBAFW,MAAM,EAWhB;IA7CD;;;;OAIG;IACH,iBAAgB;IAEhB;;;;OAIG;IACH,mBAAgB;IAEhB;;;;OAIG;IACH,oBAAgC;IAEhC;;;MAGE;IAEF;;;OAGG;IACH,OAFU,MAAM,CAEM;IAQlB;;;;OAIG;IACH,iBAAsB;IAI1B;;;;OAIG;IACH,cAHW,MAAM,GAAC,eAAe,GACpB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,eAAe,GACpB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,eAAe,SACtB,OAAO,QAQjB;IAED;;;;OAIG;IACH,cAHW,MAAM,GAAC,eAAe,GACpB,OAAO,CAInB;IAED;;;;OAIG;IACH,kBAHW,CAAC,IAAI,EAAE,UAAU,QAAM,uBAcjC;IAED;;;;OAIG;IACH,0BAHW,CAAC,IAAI,EAAE,UAAU,QAAM,uBAKjC;IAED;;;OAGG;IACH,sCAEC;IAED;;;;;;;;OAQG;IACH,8BA4BC;IAED;;;;;;;;;;;;;OAaG;IACH,qBAFa,IAAI,CAShB;IAmBD;;;;OAIG;IACH,8BAaC;IAED;;OAEG;IACH,6BAEC;IAED;;;OAGG;IACH,uBAMC;IAUD;;;OAGG;IACH,6BAiDC;IA7DD;;;OAGG;IACH,yBAEC;IAyDD;;;OAGG;IACH,qBAEC;IAED;;;;OAIG;IACH,eAHW,UAAU,GACR,OAAO,CAuBnB;IAED;;;;OAIG;IACH,kBAHW,UAAU,GACR,OAAO,CAenB;IAED,uBAEC;IAED;;;OAGG;IACH,yCA+CC;IAGD,gBAoBC;IAGL;;;OAGG;IACH,uBAFU,OAAO,CAEgB;CANhC;mBAtckB,uCAAuC;gCAI1B,sBAAsB;4BAD1B,6BAA6B;mBAFtC,cAAc"}

package/src/engine/ecs/parent/EntityNode.js

@@ -304,8 +304,16 @@ export class EntityNode {
 
 
             // handle component TransformAttachment
+            //
+            // `attachment` is what `removeComponent` returned, so it is non-null exactly when the
+            // node HAD one. The guard used to be `=== null`, which is the inverse: an existing
+            // attachment was removed from the dataset and never put back, and the line below then
+            // wrote `parent` onto a detached instance. The node kept lifetime parentage with no
+            // transform attachment, so it rendered at its raw Transform64 in world space.
             if (attachment === null) {
                 attachment = this.__safe_get_attachment();
+            } else {
+                this_entity.add(attachment);
             }
 
             attachment.parent = parent_entity_id;

package/src/engine/ecs/speaker/VoiceSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VoiceSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/speaker/VoiceSystem.js"],"names":[],"mappings":"AAiKA;IA2CI;;;;OAIG;IACH;;;OA8CC;IA7FD,+BAAuB;IACvB,gZAQE;IAEF;;;OAGG;IACH,0BAAmB;IAEnB;;;OAGG;IACH,eAAW;IAEX;;;OAGG;IACH,4BAAa;IAEb;;;OAGG;IACH,8BAAY;IAEZ;;;;OAIG;IACH,iCAAqC;IAajC;;;OAGG;IACH,eAAoB;IAEpB;;;;OAIG;IACH,kBAAkC;IAGlC;;;;OAIG;IACH,eAAkB;IAElB;;;;OAIG;IACH,oBAAgC;IAEhC;;;OAGG;IACH,oBAAqC;IAErC;;;;OAIG;IACH,gBAAoB;IAGxB;;;OAGG;IACH,kBAFY,MAAM,CAIjB;IAEF,2CAqBE;IAED;;;;;OAKG;IACH,uBAJW,MAAM,UACN,MAAM,SACN,KAAK,QAsBf;IAED;;;;;;OAMG;IACH,wBAoBC;IAED;;;;;OAKG;IACH,gBAJW,MAAM,WACN,MAAM,SACN,KAAK,QAiIf;CACJ;sCAncqC,oCAAoC;sBAKpD,YAAY;4BAFN,6BAA6B;4CAxBb,oDAAoD;uBAkBzE,sBAAsB;6BAEhB,qCAAqC;2BADvC,8BAA8B;oCAIrB,gDAAgD;sCAR9C,wCAAwC;kCAP5C,sDAAsD"}
+{"version":3,"file":"VoiceSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/speaker/VoiceSystem.js"],"names":[],"mappings":"AA0KA;IA2CI;;;;OAIG;IACH;;;OA8CC;IA7FD,+BAAuB;IACvB,gZAQE;IAEF;;;OAGG;IACH,0BAAmB;IAEnB;;;OAGG;IACH,eAAW;IAEX;;;OAGG;IACH,4BAAa;IAEb;;;OAGG;IACH,8BAAY;IAEZ;;;;OAIG;IACH,iCAAqC;IAajC;;;OAGG;IACH,eAAoB;IAEpB;;;;OAIG;IACH,kBAAkC;IAGlC;;;;OAIG;IACH,eAAkB;IAElB;;;;OAIG;IACH,oBAAgC;IAEhC;;;OAGG;IACH,oBAAqC;IAErC;;;;OAIG;IACH,gBAAoB;IAGxB;;;OAGG;IACH,kBAFY,MAAM,CAIjB;IAEF,2CAqBE;IAED;;;;;OAKG;IACH,uBAJW,MAAM,UACN,MAAM,SACN,KAAK,QAsBf;IAED;;;;;;OAMG;IACH,wBAoBC;IAED;;;;;OAKG;IACH,gBAJW,MAAM,WACN,MAAM,SACN,KAAK,QAiIf;CACJ;sCA5cqC,oCAAoC;sBAKpD,YAAY;4BAFN,6BAA6B;4CAxBb,oDAAoD;uBAkBzE,sBAAsB;6BAEhB,qCAAqC;2BADvC,8BAA8B;oCAIrB,gDAAgD;sCAR9C,wCAAwC;kCAP5C,sDAAsD"}

package/src/engine/ecs/speaker/VoiceSystem.js

@@ -112,6 +112,15 @@ class Context extends SystemEntityContext {
      */
     active_executor = null;
 
+    reset() {
+        super.reset();
+
+        // the context is pooled: anything set outside link() survives into the next entity that
+        // draws this object unless it is cleared here
+        this.active_line = null;
+        this.active_executor = null;
+    }
+
     handleSpeakLineEvent({ id }) {
         this.system.sayLine(this.entity, id, this.components[0]);
     }

package/src/engine/ecs/storage/binary/BinaryClassSerializationAdapter.d.ts

@@ -5,6 +5,9 @@
 /**
  * @typedef {import("../../../../core/binary/BinaryBuffer.js").BinaryBuffer} BinaryBuffer
  */
+/**
+ * @typedef {import("../../EntityComponentDataset.js").EntityComponentDataset} EntityComponentDataset
+ */
 /**
  * Defines how to serialize and deserialize an instance of a given class.
  * This class is intended to be overridden.
@@ -68,6 +71,17 @@ export class BinaryClassSerializationAdapter<T> {
      *
      */
     finalize(): void;
+    /**
+     * Tell `dataset` that {@link deserialize} has just written `entity`'s component in place.
+     *
+     * Called by code that deserializes into a live component — the network applying replicated
+     * state — once the write is done. A component that raises its own signals when it changes needs
+     * nothing here; one that does not says here how a write to it is made visible to what follows it.
+     *
+     * @param {EntityComponentDataset} dataset
+     * @param {number} entity
+     */
+    announce(dataset: EntityComponentDataset, entity: number): void;
     /**
      * Serialize an instance into the passed buffer.
      * Will write at the current {@link BinaryBuffer.position}.
@@ -92,4 +106,5 @@ export class BinaryClassSerializationAdapter<T> {
 }
 export type Class<T = any> = import("../../../../core/primitives/Class.js").Class<T>;
 export type BinaryBuffer = import("../../../../core/binary/BinaryBuffer.js").BinaryBuffer;
+export type EntityComponentDataset = import("../../EntityComponentDataset.js").EntityComponentDataset;
 //# sourceMappingURL=BinaryClassSerializationAdapter.d.ts.map

package/src/engine/ecs/storage/binary/BinaryClassSerializationAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BinaryClassSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/storage/binary/BinaryClassSerializationAdapter.js"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;GAEG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH;IAEI;;;;;;;OAOG;IACH,iBAFU,MAAM,CAAC,CAAC,CAEL;IAEb;;;;;;OAMG;IACH,mBAFU,MAAM,CAEJ;IAEZ;;;;;OAKG;IACH,iCAEC;IAED;;;;;OAKG;IACH,iBAEC;IAED;;;;;;OAMG;IACH,kBAHW,YAAY,SACZ,CAAC,QAIX;IAED;;;;;;OAMG;IACH,oBAHW,YAAY,SACZ,CAAC,QAIX;IAGL;;;OAGG;IACH,4CAFU,OAAO,CAE0D;CAN1E;6BApGY,OAAO,sCAAsC,EAAE,KAAK,CAAC,CAAC,CAAC;2BAIvD,OAAO,yCAAyC,EAAE,YAAY"}
+{"version":3,"file":"BinaryClassSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/storage/binary/BinaryClassSerializationAdapter.js"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;GAEG;AAEH;;GAEG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH;IAEI;;;;;;;OAOG;IACH,iBAFU,MAAM,CAAC,CAAC,CAEL;IAEb;;;;;;OAMG;IACH,mBAFU,MAAM,CAEJ;IAEZ;;;;;OAKG;IACH,iCAEC;IAED;;;;;OAKG;IACH,iBAEC;IAED;;;;;;;;;OASG;IACH,kBAHW,sBAAsB,UACtB,MAAM,QAIhB;IAED;;;;;;OAMG;IACH,kBAHW,YAAY,SACZ,CAAC,QAIX;IAED;;;;;;OAMG;IACH,oBAHW,YAAY,SACZ,CAAC,QAIX;IAGL;;;OAGG;IACH,4CAFU,OAAO,CAE0D;CAN1E;6BAtHY,OAAO,sCAAsC,EAAE,KAAK,CAAC,CAAC,CAAC;2BAIvD,OAAO,yCAAyC,EAAE,YAAY;qCAI9D,OAAO,iCAAiC,EAAE,sBAAsB"}

package/src/engine/ecs/storage/binary/BinaryClassSerializationAdapter.js

@@ -7,6 +7,10 @@
  * @typedef {import("../../../../core/binary/BinaryBuffer.js").BinaryBuffer} BinaryBuffer
  */
 
+/**
+ * @typedef {import("../../EntityComponentDataset.js").EntityComponentDataset} EntityComponentDataset
+ */
+
 /**
  * Defines how to serialize and deserialize an instance of a given class.
  * This class is intended to be overridden.
@@ -79,6 +83,20 @@ export class BinaryClassSerializationAdapter {
         //override as need
     }
 
+    /**
+     * Tell `dataset` that {@link deserialize} has just written `entity`'s component in place.
+     *
+     * Called by code that deserializes into a live component — the network applying replicated
+     * state — once the write is done. A component that raises its own signals when it changes needs
+     * nothing here; one that does not says here how a write to it is made visible to what follows it.
+     *
+     * @param {EntityComponentDataset} dataset
+     * @param {number} entity
+     */
+    announce(dataset, entity) {
+        //override as needed
+    }
+
     /**
      * Serialize an instance into the passed buffer.
      * Will write at the current {@link BinaryBuffer.position}.

package/src/engine/ecs/system/AbstractContextSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AbstractContextSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/system/AbstractContextSystem.js"],"names":[],"mappings":"AAIA;;;GAGG;AACH;IAeI;;;OAGG;IACH,sDA8BC;IAhDD;;;;OAIG;IACH,wBAAqB;IAErB;;;;OAIG;IACH,gDAA+C;IAa3C;;;;OAIG;IACH,uBAAkC;IAElC;;;;OAIG;IACH,uBAUC;IAGL;;;;;OAKG;IACH,2CAHY,CAAC,GAAC,SAAS,CAOtB;IAED,2BAwBC;IAED,6BAoBC;CACJ;uBAtHsB,cAAc"}
+{"version":3,"file":"AbstractContextSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/system/AbstractContextSystem.js"],"names":[],"mappings":"AAIA;;;GAGG;AACH;IAeI;;;OAGG;IACH,sDAoCC;IAtDD;;;;OAIG;IACH,wBAAqB;IAErB;;;;OAIG;IACH,gDAA+C;IAa3C;;;;OAIG;IACH,uBAAkC;IAElC;;;;OAIG;IACH,uBAgBC;IAGL;;;;;OAKG;IACH,2CAHY,CAAC,GAAC,SAAS,CAOtB;IAED,2BA4BC;IAED,6BAoBC;CACJ;uBAhIsB,cAAc"}

package/src/engine/ecs/system/AbstractContextSystem.js

@@ -49,10 +49,16 @@ export class AbstractContextSystem extends System {
                 return new ContextClass();
             },
             (ctx) => {
-                // TODO
+                // destroyer: a context owns nothing beyond what `reset` clears, and the pool only
+                // calls this when it is shrinking
+                ctx.reset();
             },
             (ctx) => {
-                //ctx.unlink();
+                // Resetter, run on every `create()`. This used to be a commented-out `ctx.unlink()`,
+                // so a recycled context arrived with every field its subclass had added still
+                // holding the previous entity's values - `link()` only overwrites `entity`,
+                // `system` and the components.
+                ctx.reset();
             }
         );
     }
@@ -90,9 +96,13 @@ export class AbstractContextSystem extends System {
             ctx.components[i] = arguments[i];
         }
 
-        ctx.link();
-
+        // Recorded BEFORE `link()`, which is subclass code and can throw - ParentEntitySystem's
+        // does, for a ParentEntity naming a removed parent. With the record written afterwards the
+        // context was simply lost: the later `unlink` printed "No context found for entity" and
+        // returned, so whatever `link` had already done was never undone.
         this.__live_contexts[entity] = ctx;
+
+        ctx.link();
     }
 
     unlink() {

package/src/engine/ecs/system/SystemEntityContext.d.ts

@@ -27,5 +27,17 @@ export class SystemEntityContext {
     getDataset(): EntityComponentDataset;
     link(): void;
     unlink(): void;
+    /**
+     * Return the context to the state a freshly constructed one is in, so a pooled instance does
+     * not arrive carrying the previous entity's values.
+     *
+     * `AbstractContextSystem` recycles these through an `ObjectPoolFactory` whose resetter was a
+     * commented-out `unlink()`; `link()` only overwrites `entity`, `system` and the components it
+     * was handed, so anything a subclass assigns outside `link` survived into whichever entity
+     * drew the same object next.
+     *
+     * A subclass with fields of its own overrides this, clears them, and calls `super.reset()`.
+     */
+    reset(): void;
 }
 //# sourceMappingURL=SystemEntityContext.d.ts.map

package/src/engine/ecs/system/SystemEntityContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SystemEntityContext.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/system/SystemEntityContext.js"],"names":[],"mappings":"AAAA;IAEI;;;OAGG;IACH,QAFU,MAAM,CAEJ;IAEZ;;;OAGG;IACH,eAAc;IAEd;;;OAGG;IACH,YAFU,KAAG,CAEG;IAEhB;;;;OAIG;IACH,uBAHU,OAAO,CAGG;IAEpB;;;OAGG;IACH,qCAEC;IAED,aAMC;IAED,eAOC;CACJ"}
+{"version":3,"file":"SystemEntityContext.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/system/SystemEntityContext.js"],"names":[],"mappings":"AAAA;IAEI;;;OAGG;IACH,QAFU,MAAM,CAEJ;IAEZ;;;OAGG;IACH,eAAc;IAEd;;;OAGG;IACH,YAFU,KAAG,CAEG;IAEhB;;;;OAIG;IACH,uBAHU,OAAO,CAGG;IAEpB;;;OAGG;IACH,qCAEC;IAED,aAMC;IAED,eAOC;IAED;;;;;;;;;;OAUG;IACH,cAUC;CACJ"}

package/src/engine/ecs/system/SystemEntityContext.js

@@ -49,4 +49,27 @@ export class SystemEntityContext {
 
         this.__is_linked = false;
     }
+
+    /**
+     * Return the context to the state a freshly constructed one is in, so a pooled instance does
+     * not arrive carrying the previous entity's values.
+     *
+     * `AbstractContextSystem` recycles these through an `ObjectPoolFactory` whose resetter was a
+     * commented-out `unlink()`; `link()` only overwrites `entity`, `system` and the components it
+     * was handed, so anything a subclass assigns outside `link` survived into whichever entity
+     * drew the same object next.
+     *
+     * A subclass with fields of its own overrides this, clears them, and calls `super.reset()`.
+     */
+    reset() {
+        // NOTE: does NOT call `unlink()`. The pool only ever holds contexts that were unlinked
+        // before release, and calling it again would run the subclass's teardown a second time
+        // against a stale entity id.
+        this.__is_linked = false;
+
+        this.entity = -1;
+        this.system = null;
+
+        this.components.length = 0;
+    }
 }

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

@@ -1 +1 @@
-{"version":3,"file":"system_validate_class.d.ts","sourceRoot":"","sources":["../../../../src/engine/ecs/system_validate_class.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,iEAiGC;uBAxGsB,aAAa"}
+{"version":3,"file":"system_validate_class.d.ts","sourceRoot":"","sources":["../../../../src/engine/ecs/system_validate_class.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,iEAqGC;uBA5GsB,aAAa"}

package/src/engine/ecs/system_validate_class.js

@@ -45,8 +45,12 @@ export function system_validate_class(system) {
             throw new Error('No access modifiers specified, must have at least one (such as Read, Write, Create)');
         }
 
-        // backtrace to make sure there are no duplicates
-        for (let j = 0; j < i - 1; j++) {
+        // Backtrace to make sure there are no duplicates. `j < i`, not `j < i - 1`: the old bound
+        // never compared against the immediately preceding element, and ran zero iterations at
+        // i === 1, so any duplicate that happened to sit adjacent in the array went unreported.
+        // `[Read(T), Write(T)]` passed, and `getAccessForComponent` breaks on the first match, so
+        // the writer was scheduled as a reader. The dependency loop below already uses `j = i + 1`.
+        for (let j = 0; j < i; j++) {
             const spec_other = components_used[j];
 
             if (spec_other.resource === spec.resource) {

package/src/engine/ecs/terrain/ecs/cling/ClingToTerrainSystem.js

@@ -175,10 +175,10 @@ class ClingToTerrainSystem extends System {
                 continue;
             }
 
-            const position_updated = doCling(c, terrain, timeDelta);
+            const outcome = doCling(c, terrain, timeDelta);
 
-            if (!position_updated) {
-                // no change, move back to update candidates
+            if (outcome === CLING_RETRY) {
+                // no surface under the entity yet, look again next tick
                 this.requestUpdate(entity);
             }
         }
@@ -321,11 +321,34 @@ function processRaycastHit(point, t, normal, cling, timeDelta, el) {
 }
 
 /**
+ * The entity has settled and can leave the queue: either its cached pose already matched, or a
+ * surface was found and the pose is now what the terrain says it should be.
+ * @type {number}
+ */
+const CLING_SETTLED = 0;
+
+/**
+ * No surface was found under the entity, so there is nothing to settle against yet - it has to be
+ * looked at again.
+ * @type {number}
+ */
+const CLING_RETRY = 1;
+
+/**
+ * NOTE: the return value is whether the entity has SETTLED, not whether the position changed.
+ *
+ * The caller re-queues on "not settled", and this used to hand back `hit_found` - so the one
+ * outcome that means converged (the cached-pose early-out) returned the value that guarantees a
+ * re-queue, while the outcome that did nothing useful (a hit whose pose was already correct)
+ * returned the value that drops it. Every settled clinger therefore re-queued for ever, parking
+ * the queue at N entries and starving newly moved entities behind the 1024-per-tick batch limit.
+ * The note above `t64_announce_change` calls that shape "a spin that never settles"; this was the
+ * same spin one level up.
  *
  * @param {{component:ClingToTerrain,transform:Transform}} el
  * @param {Terrain} terrain
  * @param {number} timeDelta
- * @returns {boolean} whether position was updated or not
+ * @returns {number} CLING_SETTLED or CLING_RETRY
  */
 function doCling(el, terrain, timeDelta) {
     /**
@@ -349,18 +372,24 @@ function doCling(el, terrain, timeDelta) {
         && cling.__lastRotation.roughlyEquals(scratch_rotation, 0.0001)
     ) {
         //do nothing, cached position matches with existing position
-        return false;
+        return CLING_SETTLED;
     }
 
     const hit_found = terrain.raycastVerticalFirstSync(
         temp_sp, scratch_position.x, scratch_position.z
     );
 
-    if (hit_found) {
-        processRaycastHit(temp_sp.position, t, temp_sp.normal, cling, timeDelta, el);
+    if (!hit_found) {
+        // nothing under the entity, so there is nothing to settle against yet
+        return CLING_RETRY;
     }
 
-    return hit_found;
+    processRaycastHit(temp_sp.position, t, temp_sp.normal, cling, timeDelta, el);
+
+    // The pose now matches the terrain. If `processRaycastHit` moved anything it announced the
+    // change, and that announcement re-queues the entity through the system's own listener; if it
+    // did not, there is nothing left to do.
+    return CLING_SETTLED;
 }
 
 export default ClingToTerrainSystem;

package/src/engine/ecs/terrain/tiles/TerrainTile.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TerrainTile.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/terrain/tiles/TerrainTile.js"],"names":[],"mappings":";AAwBA;;GAEG;AACH;IACI,sBAA6B;IAC7B,eAA0B;IAC1B,cAAyB;IACzB,kBAAyB;IACzB,4BAAoC;IAUpC;;;;;;;;;;;OAWG;IACH,UAFU,YAAY,GAAC,IAAI,CAEX;IAEhB;;OAEG;IACH,SAFU,YAAY,GAAC,IAAI,CAEZ;IAEf;;OAEG;IACH,KAFU,YAAY,GAAC,IAAI,CAEhB;IAEX;;OAEG;IACH,SAFU,WAAW,GAAC,WAAW,GAAC,IAAI,CAEvB;IAEf;;;OAGG;IACH,WAFU,OAAO,CAEA;IAEjB;;;OAGG;IACH,cAFU,SAAS,CAEY;IAE/B;;;OAGG;IACH,KAFU,eAAe,CAEd;IAEX;;;OAGG;IACH,SAFU,OAAO,CAED;IAChB;;;OAGG;IACH,mBAFU,OAAO,CAES;IAC1B,uBAAmB;IAEnB;;;;;;;;;OASG;IACH,eAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,aAAuB;IACvB,oBAA2B;IAE3B;;;;OAIG;IACH,kBAWE;IAEF;;;;;OAKG;IACH,+BAAiG;IAEjG;;;OAGG;IACH,SAFU,MAAM,CAEJ;IAUZ;;;OAGG;IACH,gCAGC;IAfD;;;OAGG;IACH,8BAEC;IAWD;;;;;;;;;;OAUG;IACH,yBATW,aAAa,WACb,MAAM,WACN,MAAM,WACN,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,GACL,OAAO,CA8ClB;IAED,+CAKC;IAED,8CAOC;IAED;;;;;;;;;;OAUG;IACH,mBATW,WAAW,GAAC,SAAS,UACrB,WAAW,GAAC,SAAS,QACrB,WAAW,GAAC,SAAS,SACrB,WAAW,GAAC,SAAS,WACrB,WAAW,GAAC,SAAS,YACrB,WAAW,GAAC,SAAS,cACrB,WAAW,GAAC,SAAS,eACrB,WAAW,GAAC,SAAS,QAsM/B;IAED,2BAoDC;IAED;;;;OAIG;IACH,mCAHW,MAAM,cACN,MAAM,QAIhB;IAED,gBAcC;IAED;;;;;OAKG;IACH,gBAFW;QAAC,QAAQ,EAAE;YAAC,QAAQ,EAAE,YAAY,CAAC;YAAC,OAAO,EAAE,YAAY,CAAC;YAAC,GAAG,EAAE,YAAY,CAAC;YAAC,OAAO,EAAE,WAAW,GAAC,WAAW,CAAA;SAAC,CAAC;QAAC,GAAG,CAAC,EAAC;YAAC,UAAU,EAAC,MAAM,CAAC;YAAC,IAAI,EAAC,WAAW,CAAA;SAAC,CAAA;KAAC,QAuBtK;;CACJ;oBAniBmB,kCAAkC;4BAG1B,2CAA2C;0BAZ7C,yCAAyC;gCADnC,mDAAmD;mBAGhE,0CAA0C;8BAM/B,2CAA2C"}
+{"version":3,"file":"TerrainTile.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/terrain/tiles/TerrainTile.js"],"names":[],"mappings":";AAwBA;;GAEG;AACH;IACI,sBAA6B;IAC7B,eAA0B;IAC1B,cAAyB;IACzB,kBAAyB;IACzB,4BAAoC;IAUpC;;;;;;;;;;;OAWG;IACH,UAFU,YAAY,GAAC,IAAI,CAEX;IAEhB;;OAEG;IACH,SAFU,YAAY,GAAC,IAAI,CAEZ;IAEf;;OAEG;IACH,KAFU,YAAY,GAAC,IAAI,CAEhB;IAEX;;OAEG;IACH,SAFU,WAAW,GAAC,WAAW,GAAC,IAAI,CAEvB;IAEf;;;OAGG;IACH,WAFU,OAAO,CAEA;IAEjB;;;OAGG;IACH,cAFU,SAAS,CAEY;IAE/B;;;OAGG;IACH,KAFU,eAAe,CAEd;IAEX;;;OAGG;IACH,SAFU,OAAO,CAED;IAChB;;;OAGG;IACH,mBAFU,OAAO,CAES;IAC1B,uBAAmB;IAEnB;;;;;;;;;OASG;IACH,eAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,aAAuB;IACvB,oBAA2B;IAE3B;;;;OAIG;IACH,kBAWE;IAEF;;;;;OAKG;IACH,+BAAiG;IAEjG;;;OAGG;IACH,SAFU,MAAM,CAEJ;IAUZ;;;OAGG;IACH,gCAGC;IAfD;;;OAGG;IACH,8BAEC;IAWD;;;;;;;;;;OAUG;IACH,yBATW,aAAa,WACb,MAAM,WACN,MAAM,WACN,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,GACL,OAAO,CA8ClB;IAED,+CAKC;IAED,8CAOC;IAED;;;;;;;;;;OAUG;IACH,mBATW,WAAW,GAAC,SAAS,UACrB,WAAW,GAAC,SAAS,QACrB,WAAW,GAAC,SAAS,SACrB,WAAW,GAAC,SAAS,WACrB,WAAW,GAAC,SAAS,YACrB,WAAW,GAAC,SAAS,cACrB,WAAW,GAAC,SAAS,eACrB,WAAW,GAAC,SAAS,QA4M/B;IAED,2BAoDC;IAED;;;;OAIG;IACH,mCAHW,MAAM,cACN,MAAM,QAIhB;IAED,gBAoBC;IA6BD;;;;;OAKG;IACH,gBAFW;QAAC,QAAQ,EAAE;YAAC,QAAQ,EAAE,YAAY,CAAC;YAAC,OAAO,EAAE,YAAY,CAAC;YAAC,GAAG,EAAE,YAAY,CAAC;YAAC,OAAO,EAAE,WAAW,GAAC,WAAW,CAAA;SAAC,CAAC;QAAC,GAAG,CAAC,EAAC;YAAC,UAAU,EAAC,MAAM,CAAC;YAAC,IAAI,EAAC,WAAW,CAAA;SAAC,CAAA;KAAC,QA0BtK;;CACJ;oBA7kBmB,kCAAkC;4BAG1B,2CAA2C;0BAZ7C,yCAAyC;gCADnC,mDAAmD;mBAGhE,0CAA0C;8BAM/B,2CAA2C"}