@waica/behaviors 0.13.0 → 0.14.1

package/dist/health.js

@@ -1,4 +1,4 @@
-import { Component, StateMachine } from '@waica/engine';
+import { Component, SIMULATION_TIME_EPSILON, StateMachine, } from '@waica/engine';
 /**
  * Below this, current is treated as exactly zero. Repeated fractional
  * damage (e.g. ten hits of 0.1 against max: 1) can leave a floating-point
@@ -113,6 +113,12 @@ export class Health extends Component {
     onUpdate(dt) {
         if (this.invulnerable > 0) {
             this.invulnerable = Math.max(0, this.invulnerable - dt);
+            // this.invulnerable is a countdown of SIMULATION_STEP-sized dts, which
+            // float error can leave as a tiny positive residual instead of
+            // exactly 0 on the step that should close the window; without this,
+            // `> 0` above stays true for one whole extra step.
+            if (this.invulnerable <= SIMULATION_TIME_EPSILON)
+                this.invulnerable = 0;
             this.blink(dt);
         }
         if (this.deathPending) {

package/dist/interactable.js

@@ -56,26 +56,16 @@ export function fireInteract(target, initiator) {
  * radius hides it again. Nearest one wins when several are in range.
  */
 export function interactUpdate({ entity, game }) {
-    let nearest = null;
-    let nearestEntity = null;
-    let nearestDistance = Infinity;
-    for (const other of game.entities) {
-        if (other === entity)
-            continue;
-        const interactable = other.get(Interactable);
-        if (!interactable)
-            continue;
-        const distance = Math.hypot(other.position.x - entity.position.x, other.position.y - entity.position.y);
-        if (distance <= interactable.radius && distance < nearestDistance) {
-            nearest = interactable;
-            nearestEntity = other;
-            nearestDistance = distance;
-        }
-    }
-    if (!nearest || !nearestEntity) {
+    const nearestEntity = game.query.nearest(entity.position.x, entity.position.y, {
+        with: [Interactable],
+        exclude: entity,
+        where: (candidate, { distance }) => distance <= candidate.get(Interactable).radius,
+    });
+    if (!nearestEntity) {
         game.ui.hide(INTERACTABLE_UI_PIECE);
         return;
     }
+    const nearest = nearestEntity.get(Interactable);
     if (game.input.justPressed('interact') && !game.input.consumed('interact')) {
         // The press is spent: an input:interact edge needs a NEW press.
         game.input.consume('interact');

package/dist/lifetime.js

@@ -1,4 +1,4 @@
-import { Component } from '@waica/engine';
+import { Component, SIMULATION_TIME_EPSILON } from '@waica/engine';
 /** Destroys its entity after a configurable amount of simulated time. */
 export class Lifetime extends Component {
     static componentName = 'Lifetime';
@@ -14,7 +14,10 @@ export class Lifetime extends Component {
         if (!this.entity.alive)
             return;
         this.elapsed += dt;
-        if (this.elapsed >= this.seconds)
+        // this.elapsed is a sum of SIMULATION_STEP-sized dts, which float error
+        // can leave a hair under an exact multiple; the epsilon keeps a bare
+        // `>=` from waiting one whole step too long to destroy.
+        if (this.elapsed + SIMULATION_TIME_EPSILON >= this.seconds)
             this.entity.destroy();
     }
 }

package/dist/melee-attack.js

@@ -1,4 +1,4 @@
-import { Component, Hitbox, collisionOverlap, } from '@waica/engine';
+import { Component, Hitbox, } from '@waica/engine';
 import { logicalDirection } from './facing.js';
 import { Health } from './health.js';
 /**
@@ -43,25 +43,16 @@ export class MeleeAttack extends Component {
             this.game.audio.play(this.swingSound, { at: this.entity });
         const area = this.strikeArea(direction.x, direction.y);
         const struck = [];
-        // A copy: a target with no death-handling graph is destroyed on the spot,
-        // which splices it out of the live array mid-loop (Game does the same).
-        for (const other of [...this.game.entities]) {
-            if (other === this.entity || !other.alive)
+        const targets = this.game.query.area(area, {
+            with: [Health],
+            exclude: this.entity,
+        });
+        for (const other of targets) {
+            // Query results are eager live references: an earlier target can destroy
+            // a later one while this strike is still consuming its snapshot.
+            if (!other.alive)
                 continue;
-            const hitbox = other.get(Hitbox);
             const health = other.get(Health);
-            if (!hitbox || !health)
-                continue;
-            const body = {
-                x: other.position.x + hitbox.offsetX,
-                y: other.position.y + hitbox.offsetY,
-                width: hitbox.width,
-                height: hitbox.height,
-                shape: hitbox.shape,
-                points: hitbox.points,
-            };
-            if (!collisionOverlap(area, body))
-                continue;
             const before = health.current;
             health.damage(this.damage, this.entity);
             if (health.current < before)

package/dist/patrol.js

@@ -1,4 +1,4 @@
-import { Component, installedDirectionalAnimation, projectIsometric, } from '@waica/engine';
+import { Component, installedDirectionalAnimation, projectIsometric, SIMULATION_TIME_EPSILON, } from '@waica/engine';
 import { facingForInput } from './facing.js';
 /** Seconds a hit stops the rail. */
 const HURT_SECONDS = 0.25;
@@ -105,7 +105,10 @@ export const PATROLLER_ROLE = {
         // Holds the death pose for a beat, then the body goes away for good.
         dead: {
             onUpdate({ entity, fsm }) {
-                if (fsm.elapsed >= DEATH_SECONDS)
+                // fsm.elapsed is a sum of SIMULATION_STEP-sized dts, which float
+                // error can leave a hair under an exact multiple; the epsilon keeps
+                // a bare `>=` from waiting one whole step too long to destroy.
+                if (fsm.elapsed + SIMULATION_TIME_EPSILON >= DEATH_SECONDS)
                     entity.destroy();
             },
         },

package/package.json

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