@waica/behaviors 0.11.0 → 0.13.0

package/dist/click-to-move.js

@@ -1,5 +1,5 @@
 import { Component, Sprite, screenInputToLogical, } from '@waica/engine';
-import { INTERACTABLE_UI_PIECE, Interactable } from './interactable.js';
+import { fireInteract, INTERACTABLE_UI_PIECE, Interactable } from './interactable.js';
 import { Health } from './health.js';
 import { MeleeAttack } from './melee-attack.js';
 import { buildNavigationGrid } from './navigation-grid.js';
@@ -199,7 +199,9 @@ function driveNpcOrder(clickToMove, entity, game, order) {
     }
     if (distance(pointOf(entity), pointOf(target)) <= interactable.radius) {
         game.stats.set('npcLine', interactable.line);
-        game.ui.show(INTERACTABLE_UI_PIECE);
+        // Scene-scoped, same reason as interactUpdate's prompt (grill decision 8).
+        game.ui.show(INTERACTABLE_UI_PIECE, { scope: 'scene' });
+        fireInteract(target, entity);
         clickToMove.cancel(); // CA-5: one trigger per arrival, no key simulated
         return null;
     }

package/dist/health.d.ts

@@ -45,6 +45,10 @@ export declare class Health extends Component {
             label: string;
             ref: 'stat';
         };
+        hurtSound: {
+            label: string;
+            ref: 'sound';
+        };
     };
     static transient: string[];
     max: number;
@@ -55,6 +59,8 @@ export declare class Health extends Component {
      * publishes nothing: the stat is the project's to declare.
      */
     stat: string;
+    /** Sound played at this entity's position on every accepted hit. Empty plays nothing (CA-12). */
+    hurtSound: string;
     /** Health left; 0 is dead. Filled in from max on ready. */
     current: number;
     /** Whoever dealt the last accepted hit, for the state that reacts to it. */

package/dist/health.js

@@ -47,6 +47,7 @@ export class Health extends Component {
         max: { label: 'Max health', min: 1, max: 20, step: 1 },
         invulnerability: { label: 'Invulnerability', min: 0, max: 5, step: 0.1 },
         stat: { label: 'Stat', ref: 'stat' },
+        hurtSound: { label: 'Hurt sound', ref: 'sound' },
     };
     static transient = [
         'current',
@@ -64,6 +65,8 @@ export class Health extends Component {
      * publishes nothing: the stat is the project's to declare.
      */
     stat = '';
+    /** Sound played at this entity's position on every accepted hit. Empty plays nothing (CA-12). */
+    hurtSound = '';
     /** Health left; 0 is dead. Filled in from max on ready. */
     current = 0;
     /** Whoever dealt the last accepted hit, for the state that reacts to it. */
@@ -158,6 +161,8 @@ export class Health extends Component {
             current: this.current,
             source,
         });
+        if (this.hurtSound)
+            this.game.audio.play(this.hurtSound, { at: this.entity });
         this.invulnerable = this.invulnerability;
         this.blinkClock = 0;
         if (this.current === 0) {

package/dist/index.d.ts

@@ -4,8 +4,9 @@ export { TopDownMotor, type TopDownFacing } from './topdown-motor.js';
 export { IsoMotor, type IsoFacing } from './iso-motor.js';
 export { TOPDOWN_PLAYER_ROLE, TOPDOWN_PLAYER_STATE_GRAPH, topdownPlayerUpdate, } from './topdown-player-states.js';
 export { ISO_PLAYER_ROLE, ISO_PLAYER_STATE_GRAPH, isoPlayerUpdate, } from './iso-player-states.js';
-export { INTERACTABLE_UI, INTERACTABLE_UI_PIECE, Interactable, interactUpdate, } from './interactable.js';
+export { fireInteract, INTERACTABLE_UI, INTERACTABLE_UI_PIECE, Interactable, interactUpdate, } from './interactable.js';
 export { Collectible } from './collectible.js';
+export { SceneTransition } from './scene-transition.js';
 export { Patrol, PATROLLER_ROLE, PATROLLER_STATE_GRAPH, type PatrolAxis } from './patrol.js';
 export { Chaser, CHASER_ROLE, CHASER_STATE_GRAPH, type ChaserMode } from './chaser.js';
 export { NPC_ROLE, NPC_STATE_GRAPH } from './npc.js';

package/dist/index.js

@@ -4,8 +4,9 @@ export { TopDownMotor } from './topdown-motor.js';
 export { IsoMotor } from './iso-motor.js';
 export { TOPDOWN_PLAYER_ROLE, TOPDOWN_PLAYER_STATE_GRAPH, topdownPlayerUpdate, } from './topdown-player-states.js';
 export { ISO_PLAYER_ROLE, ISO_PLAYER_STATE_GRAPH, isoPlayerUpdate, } from './iso-player-states.js';
-export { INTERACTABLE_UI, INTERACTABLE_UI_PIECE, Interactable, interactUpdate, } from './interactable.js';
+export { fireInteract, INTERACTABLE_UI, INTERACTABLE_UI_PIECE, Interactable, interactUpdate, } from './interactable.js';
 export { Collectible } from './collectible.js';
+export { SceneTransition } from './scene-transition.js';
 export { Patrol, PATROLLER_ROLE, PATROLLER_STATE_GRAPH } from './patrol.js';
 export { Chaser, CHASER_ROLE, CHASER_STATE_GRAPH } from './chaser.js';
 export { NPC_ROLE, NPC_STATE_GRAPH } from './npc.js';

package/dist/interactable.d.ts

@@ -1,4 +1,4 @@
-import { Component, type StateContext } from '@waica/engine';
+import { Component, type Entity, type StateContext } from '@waica/engine';
 /**
  * Something the player can talk to or examine: a dialogue line and the
  * radius it can be triggered from. The component is pure data — the
@@ -25,6 +25,14 @@ export declare class Interactable extends Component {
 export declare const INTERACTABLE_UI_PIECE = "npc-line";
 /** The UI fragment every archetype using Interactable must register. */
 export declare const INTERACTABLE_UI: Readonly<Record<string, string>>;
+/**
+ * Runs onInteract on every component of `target` — the winner of the
+ * nearest-Interactable scan. The two paths that win it (the interact key,
+ * via interactUpdate, and a click-to-move NPC order arrival) both call this,
+ * so a sibling component (e.g. SceneTransition with trigger:'interact')
+ * fires the same way from either input scheme.
+ */
+export declare function fireInteract(target: Entity, initiator: Entity): void;
 /**
  * The player role's interact lookup, run by its '*' hook in every state:
  * pressing interact near an Interactable publishes its line through the

package/dist/interactable.js

@@ -38,6 +38,17 @@ export const INTERACTABLE_UI = {
 <div class="npc-line">{{npcLine}}</div>
 `,
 };
+/**
+ * Runs onInteract on every component of `target` — the winner of the
+ * nearest-Interactable scan. The two paths that win it (the interact key,
+ * via interactUpdate, and a click-to-move NPC order arrival) both call this,
+ * so a sibling component (e.g. SceneTransition with trigger:'interact')
+ * fires the same way from either input scheme.
+ */
+export function fireInteract(target, initiator) {
+    for (const component of [...target.components])
+        component.onInteract?.(initiator);
+}
 /**
  * The player role's interact lookup, run by its '*' hook in every state:
  * pressing interact near an Interactable publishes its line through the
@@ -46,6 +57,7 @@ export const INTERACTABLE_UI = {
  */
 export function interactUpdate({ entity, game }) {
     let nearest = null;
+    let nearestEntity = null;
     let nearestDistance = Infinity;
     for (const other of game.entities) {
         if (other === entity)
@@ -56,10 +68,11 @@ export function interactUpdate({ entity, game }) {
         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) {
+    if (!nearest || !nearestEntity) {
         game.ui.hide(INTERACTABLE_UI_PIECE);
         return;
     }
@@ -67,6 +80,10 @@ export function interactUpdate({ entity, game }) {
         // The press is spent: an input:interact edge needs a NEW press.
         game.input.consume('interact');
         game.stats.set('npcLine', nearest.line);
-        game.ui.show(INTERACTABLE_UI_PIECE);
+        // Scene-scoped: the scan that hides this prompt dies with the scene, so
+        // without a scope the prompt would survive a swap into a map where
+        // nothing knows to hide it — stale line and all (grill decision 8).
+        game.ui.show(INTERACTABLE_UI_PIECE, { scope: 'scene' });
+        fireInteract(nearestEntity, entity);
     }
 }

package/dist/melee-attack.d.ts

@@ -29,12 +29,18 @@ export declare class MeleeAttack extends Component {
             max: number;
             step: number;
         };
+        swingSound: {
+            label: string;
+            ref: 'sound';
+        };
     };
     damage: number;
     /** How far in front of the attacker the blow reaches, in world units. */
     range: number;
     /** How wide the blow is, across the facing. */
     width: number;
+    /** Sound played on every swing. Empty plays nothing (CA-12). */
+    swingSound: string;
     /**
      * Lands one blow along `facing`: every other living entity with a Hitbox
      * and a Health inside the strike area takes `damage` once, with this

package/dist/melee-attack.js

@@ -16,12 +16,15 @@ export class MeleeAttack extends Component {
         damage: { label: 'Damage', min: 0, max: 20, step: 1 },
         range: { label: 'Range', min: 0.5, max: 5, step: 0.5 },
         width: { label: 'Width', min: 0.5, max: 5, step: 0.5 },
+        swingSound: { label: 'Swing sound', ref: 'sound' },
     };
     damage = 1;
     /** How far in front of the attacker the blow reaches, in world units. */
     range = 1;
     /** How wide the blow is, across the facing. */
     width = 1;
+    /** Sound played on every swing. Empty plays nothing (CA-12). */
+    swingSound = '';
     /**
      * Lands one blow along `facing`: every other living entity with a Hitbox
      * and a Health inside the strike area takes `damage` once, with this
@@ -33,6 +36,11 @@ export class MeleeAttack extends Component {
         const direction = logicalDirection(facing, this.game.projection);
         if (!direction)
             return [];
+        // Positional like Health's hurtSound (CA-8): an off-camera NPC's swing
+        // should attenuate and pan like the hit it causes, not play flat and
+        // dead-centre while the damage it lands sounds correctly placed.
+        if (this.swingSound)
+            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,

package/dist/scene-transition.d.ts

@@ -0,0 +1,34 @@
+import { Component, type Entity } from '@waica/engine';
+/**
+ * Replaces the live scene with `scene` (its file's stem, e.g.
+ * "cave.scene.json" -> "cave") when fired — a door, or any entity a player
+ * crosses or interacts with to leave the current map. Names only its
+ * destination: the incoming scene places its own Player wherever that
+ * scene authored it (no named entry points).
+ *
+ * With trigger:'overlap' (the default) it fires like Collectible/Hazard:
+ * the player's Hitbox overlapping its own — requires a sibling Hitbox.
+ * With trigger:'interact' it implements no radius or prompt of its own:
+ * it needs a sibling Interactable and fires from the shared nearest-wins
+ * interact scan (interactable.ts's fireInteract), so a door and an NPC in
+ * range arbitrate themselves with no new rule.
+ */
+export declare class SceneTransition extends Component {
+    static componentName: string;
+    static params: {
+        scene: {
+            label: string;
+        };
+        trigger: {
+            label: string;
+            options: string[];
+        };
+    };
+    /** Destination scene name. */
+    scene: string;
+    trigger: 'overlap' | 'interact';
+    onReady(): void;
+    onCollide(other: Entity): void;
+    onInteract(_initiator: Entity): void;
+    private fire;
+}

package/dist/scene-transition.js

@@ -0,0 +1,48 @@
+import { Component } from '@waica/engine';
+import { Interactable } from './interactable.js';
+import { isPlayer } from './player-identity.js';
+/**
+ * Replaces the live scene with `scene` (its file's stem, e.g.
+ * "cave.scene.json" -> "cave") when fired — a door, or any entity a player
+ * crosses or interacts with to leave the current map. Names only its
+ * destination: the incoming scene places its own Player wherever that
+ * scene authored it (no named entry points).
+ *
+ * With trigger:'overlap' (the default) it fires like Collectible/Hazard:
+ * the player's Hitbox overlapping its own — requires a sibling Hitbox.
+ * With trigger:'interact' it implements no radius or prompt of its own:
+ * it needs a sibling Interactable and fires from the shared nearest-wins
+ * interact scan (interactable.ts's fireInteract), so a door and an NPC in
+ * range arbitrate themselves with no new rule.
+ */
+export class SceneTransition extends Component {
+    static componentName = 'SceneTransition';
+    static params = {
+        scene: { label: 'Scene' },
+        trigger: { label: 'Trigger', options: ['overlap', 'interact'] },
+    };
+    /** Destination scene name. */
+    scene = '';
+    trigger = 'overlap';
+    onReady() {
+        if (this.trigger === 'interact' && !this.entity.has(Interactable)) {
+            console.warn(`[waica] SceneTransition on "${this.entity.name}" has trigger:"interact" but no ` +
+                'sibling Interactable; it will never fire.');
+        }
+    }
+    onCollide(other) {
+        if (this.trigger !== 'overlap')
+            return;
+        if (!isPlayer(other))
+            return;
+        this.fire();
+    }
+    onInteract(_initiator) {
+        if (this.trigger !== 'interact')
+            return;
+        this.fire();
+    }
+    fire() {
+        this.game.loadSceneByName(this.scene);
+    }
+}

package/package.json

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