@waica/behaviors 0.5.0 → 0.6.1

package/dist/health.d.ts

@@ -14,7 +14,7 @@ export declare function deathTargets(states: Record<string, StateJson>, current:
  * Declaring an edge is not the same as taking it: nextTransition returns the
  * FIRST firing edge, so a death edge listed after another edge that also
  * fires loses the race and the signal is dropped. That is why signalling is
- * followed by the deferred check in Health.onUpdate rather than trusted.
+ * followed by a check on Health's first eligible update after StateMachine.
  */
 export declare function declaresDeathHandling(states: Record<string, StateJson>, current: string): boolean;
 /**
@@ -27,6 +27,7 @@ export declare function declaresDeathHandling(states: Record<string, StateJson>,
  */
 export declare class Health extends Component {
     static componentName: string;
+    static updateAfter: readonly string[];
     static params: {
         max: {
             label: string;
@@ -49,8 +50,8 @@ export declare class Health extends Component {
     current: number;
     /** Seconds left in the invulnerability window. */
     private invulnerable;
-    /** Frames left before the signalled death is checked; 0 when not waiting. */
-    private deathGrace;
+    /** Whether the signalled death must be checked on this component's next update. */
+    private deathPending;
     /** States the death signal was supposed to reach. */
     private expectedStates;
     onReady(): void;

package/dist/health.js

@@ -25,18 +25,11 @@ export function deathTargets(states, current) {
  * Declaring an edge is not the same as taking it: nextTransition returns the
  * FIRST firing edge, so a death edge listed after another edge that also
  * fires loses the race and the signal is dropped. That is why signalling is
- * followed by the deferred check in Health.onUpdate rather than trusted.
+ * followed by a check on Health's first eligible update after StateMachine.
  */
 export function declaresDeathHandling(states, current) {
     return deathTargets(states, current).length > 0;
 }
-/**
- * Frames to wait before deciding the graph ignored the death signal. Two,
- * not one, because component update order is prefab-authored: with Health
- * listed before its StateMachine, one frame would check before the machine
- * ever ran. Two guarantees the machine got a full tick either way.
- */
-const DEATH_GRACE_FRAMES = 2;
 /**
  * How much punishment an entity takes before it dies. Deliberately separate
  * from Hazard's "hurts on touch": an enemy is both, a spike is only the
@@ -47,11 +40,12 @@ const DEATH_GRACE_FRAMES = 2;
  */
 export class Health extends Component {
     static componentName = 'Health';
+    static updateAfter = ['StateMachine'];
     static params = {
         max: { label: 'Max health', min: 1, max: 20, step: 1 },
         invulnerability: { label: 'Invulnerability', min: 0, max: 5, step: 0.1 },
     };
-    static transient = ['current', 'invulnerable', 'deathGrace', 'expectedStates'];
+    static transient = ['current', 'invulnerable', 'deathPending', 'expectedStates'];
     max = 3;
     /** Seconds of immunity granted by taking a hit. 0 disables i-frames. */
     invulnerability = 0;
@@ -59,8 +53,8 @@ export class Health extends Component {
     current = 0;
     /** Seconds left in the invulnerability window. */
     invulnerable = 0;
-    /** Frames left before the signalled death is checked; 0 when not waiting. */
-    deathGrace = 0;
+    /** Whether the signalled death must be checked on this component's next update. */
+    deathPending = false;
     /** States the death signal was supposed to reach. */
     expectedStates = [];
     onReady() {
@@ -76,8 +70,10 @@ export class Health extends Component {
     onUpdate(dt) {
         if (this.invulnerable > 0)
             this.invulnerable = Math.max(0, this.invulnerable - dt);
-        if (this.deathGrace > 0 && --this.deathGrace === 0)
+        if (this.deathPending) {
+            this.deathPending = false;
             this.settleDeath();
+        }
     }
     /**
      * Makes good on a death the graph said it would handle. Signalling is
@@ -139,10 +135,11 @@ export class Health extends Component {
         const targets = machine ? deathTargets(machine.states, machine.current) : [];
         if (machine && targets.length > 0) {
             machine.signal('death');
-            // Trust, then verify: settleDeath falls back to destroying if the
-            // signal never actually moved the machine anywhere it said it would.
+            // Trust, then verify: the deterministic schedule puts Health after the
+            // machine, so its first eligible update can settle this without an
+            // authored-order grace period.
             this.expectedStates = targets;
-            this.deathGrace = DEATH_GRACE_FRAMES;
+            this.deathPending = true;
             return;
         }
         this.entity.destroy();

package/dist/out-of-bounds.d.ts

@@ -14,6 +14,7 @@ import { Component } from '@waica/engine';
  */
 export declare class OutOfBounds extends Component {
     static componentName: string;
+    static updateAfter: readonly string[];
     static displayName: string;
     static params: {
         minY: {

package/dist/out-of-bounds.js

@@ -15,6 +15,7 @@ import { Health } from './health.js';
  */
 export class OutOfBounds extends Component {
     static componentName = 'OutOfBounds';
+    static updateAfter = ['DynamicBody', 'Health', 'StateMachine'];
     static displayName = 'Out of bounds';
     static params = {
         minY: { label: 'Floor height', min: -50, max: 0, step: 1 },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@waica/behaviors",
-  "version": "0.5.0",
+  "version": "0.6.1",
   "description": "Waica built-in behaviors — the curated game-feel library",
   "license": "MIT",
   "type": "module",
@@ -19,6 +19,6 @@
     }
   },
   "dependencies": {
-    "@waica/engine": "^0.5.0"
+    "@waica/engine": "^0.6.1"
   }
 }