@waica/behaviors 0.19.0 → 0.19.2

package/dist/click-to-move.js

@@ -75,7 +75,13 @@ function waypointsToward(game, mover, target) {
     const plan = planPath(grid, pointOf(mover), target);
     if (!plan)
         return [];
-    return plan.cells.map((cell) => grid.cellCenter(cell));
+    return plan.cells.map((cell) => {
+        const center = grid.cellCenter(cell);
+        // Invariant: planPath only returns cells of the grid it planned on.
+        if (!center)
+            throw new Error(`Planned cell (${cell.column}, ${cell.row}) is outside its navigation grid`);
+        return center;
+    });
 }
 function spawnMarker(clickToMove, game, mover, at) {
     const marker = game.spawn(`${mover.name}:click-marker`);
@@ -101,8 +107,7 @@ function spawnMarker(clickToMove, game, mover, at) {
 }
 /** Consumes the leading waypoints already reached; returns the direction to what's left. */
 function followWaypoints(clickToMove, mover, waypoints) {
-    while (waypoints.length > 0) {
-        const next = waypoints[0];
+    for (let next = waypoints[0]; next !== undefined; next = waypoints[0]) {
         const gap = distance(pointOf(mover), next);
         if (gap <= clickToMove.arrivalTolerance) {
             waypoints.shift();
@@ -168,7 +173,7 @@ function startOrder(clickToMove, entity, game, pick) {
         // An entity without Health/Interactable: fall through to a ground order.
     }
     const waypoints = waypointsToward(game, entity, pick.point);
-    const destination = waypoints.length > 0 ? waypoints[waypoints.length - 1] : pick.point;
+    const destination = waypoints.at(-1) ?? pick.point;
     clickToMove.order = { kind: 'ground', waypoints, destination };
     spawnMarker(clickToMove, game, entity, destination);
 }

package/dist/grid-motor.d.ts

@@ -1,6 +1,6 @@
 import { Component, type AnimationFacingProvider, type CameraVelocity, type CameraVelocityProvider } from '@waica/engine';
 /** Shared velocity, collision and provider behavior for square-grid motors. */
-export declare abstract class GridMotor<Facing extends string> extends Component implements CameraVelocityProvider, AnimationFacingProvider {
+export declare abstract class GridMotor extends Component implements CameraVelocityProvider, AnimationFacingProvider {
     static displayName: string;
     static params: {
         moveSpeed: {
@@ -47,7 +47,8 @@ export declare abstract class GridMotor<Facing extends string> extends Component
     hitboxHeight: number;
     vx: number;
     vy: number;
-    abstract facing: Facing;
+    /** Each motor narrows this to its own facing vocabulary. */
+    abstract facing: string;
     /** The scene camera reads follow velocity through this explicit seam. */
     getCameraVelocity(): CameraVelocity;
     /** The StateMachine resolves directional clips through this explicit seam. */

package/dist/grid-player-role.js

@@ -8,9 +8,9 @@ import { Respawnable } from './respawnable.js';
 /** Seconds the attack swing and the hurt stun each keep the body from the player. */
 const ATTACK_SECONDS = 0.3;
 const HURT_SECONDS = 0.3;
-/** Builds the common player graph and role around one genre-specific grid motor. */
-export function createGridPlayerRole(Motor, description) {
-    const graph = {
+/** The common player graph; fresh per role so no two roles share a mutable graph. */
+function gridPlayerGraph() {
+    return {
         initial: 'idle',
         states: {
             idle: {
@@ -50,7 +50,10 @@ export function createGridPlayerRole(Motor, description) {
             },
         },
     };
-    const update = (ctx, dt) => {
+}
+/** The body update: keyboard input, else a live Move Order, then the motor step and move/stop signal. */
+function gridPlayerUpdate(Motor) {
+    return (ctx, dt) => {
         const { entity, game, fsm } = ctx;
         const motor = entity.get(Motor);
         if (!motor)
@@ -78,6 +81,26 @@ export function createGridPlayerRole(Motor, description) {
         motor.step(dt);
         fsm.signal(motor.speed() > motor.walkThreshold ? 'move' : 'stop');
     };
+}
+/** Sets the motor's knockback velocity away from the last damage source, else back from its facing. */
+function knockBack({ entity, game }, motor) {
+    const source = entity.get(Health)?.lastDamageSource;
+    const dx = source ? entity.position.x - source.position.x : 0;
+    const dy = source ? entity.position.y - source.position.y : 0;
+    const distance = Math.hypot(dx, dy);
+    let away = distance > 0 ? { x: dx / distance, y: dy / distance } : undefined;
+    if (!away) {
+        // No source (or one standing on top of us): recoil from the facing.
+        const forward = logicalDirection(motor.facing, game.projection);
+        away = forward ? { x: -forward.x, y: -forward.y } : { x: 0, y: 0 };
+    }
+    motor.vx = away.x * motor.knockbackSpeed;
+    motor.vy = away.y * motor.knockbackSpeed;
+}
+/** Builds the common player graph and role around one genre-specific grid motor. */
+export function createGridPlayerRole(Motor, description) {
+    const graph = gridPlayerGraph();
+    const update = gridPlayerUpdate(Motor);
     const role = {
         description,
         driver: Motor.componentName,
@@ -112,22 +135,10 @@ export function createGridPlayerRole(Motor, description) {
                 onUpdate() { },
             },
             hurt: {
-                onEnter({ entity, game }) {
-                    const motor = entity.get(Motor);
-                    if (!motor)
-                        return;
-                    const source = entity.get(Health)?.lastDamageSource;
-                    const dx = source ? entity.position.x - source.position.x : 0;
-                    const dy = source ? entity.position.y - source.position.y : 0;
-                    const distance = Math.hypot(dx, dy);
-                    let away = distance > 0 ? { x: dx / distance, y: dy / distance } : undefined;
-                    if (!away) {
-                        // No source (or one standing on top of us): recoil from the facing.
-                        const forward = logicalDirection(motor.facing, game.projection);
-                        away = forward ? { x: -forward.x, y: -forward.y } : { x: 0, y: 0 };
-                    }
-                    motor.vx = away.x * motor.knockbackSpeed;
-                    motor.vy = away.y * motor.knockbackSpeed;
+                onEnter(ctx) {
+                    const motor = ctx.entity.get(Motor);
+                    if (motor)
+                        knockBack(ctx, motor);
                 },
                 // The shove resolves against Solids like any movement; no input.
                 onUpdate({ entity }, dt) {

package/dist/iso-motor.d.ts

@@ -7,7 +7,7 @@ export type IsoFacing = ScreenFacing;
  * shared GridMotor integrates and collides in logical square-grid space.
  * State code owns the frame; this component has no onUpdate of its own.
  */
-export declare class IsoMotor extends GridMotor<IsoFacing> {
+export declare class IsoMotor extends GridMotor {
     static componentName: string;
     facing: IsoFacing;
     /**

package/dist/pathfinding.js

@@ -35,6 +35,13 @@ function neighbors(grid, cell) {
 function stepCost(dc, dr) {
     return dc !== 0 && dr !== 0 ? Math.SQRT2 : 1;
 }
+/** The best known cost of a cell A* has already scored (every open or current cell has one). */
+function scoreOf(gScore, cellKey) {
+    const score = gScore.get(cellKey);
+    if (score === undefined)
+        throw new Error(`A* has no score for cell ${cellKey}`);
+    return score;
+}
 /** Octile distance: admissible heuristic for 8-way movement with unit/√2 costs. */
 function octile(a, b) {
     const dx = Math.abs(a.column - b.column);
@@ -51,8 +58,7 @@ export function reachableCells(grid, start) {
         return [];
     const visited = new Map([[key(start), start]]);
     const queue = [start];
-    while (queue.length > 0) {
-        const current = queue.shift();
+    for (let current = queue.shift(); current !== undefined; current = queue.shift()) {
         for (const next of neighbors(grid, current)) {
             const k = key(next);
             if (visited.has(k))
@@ -84,7 +90,7 @@ export function findPath(grid, start, goal) {
         let current;
         let bestF = Infinity;
         for (const [k, cell] of open) {
-            const f = gScore.get(k) + octile(cell, goal);
+            const f = scoreOf(gScore, k) + octile(cell, goal);
             if (f < bestF) {
                 bestF = f;
                 currentKey = k;
@@ -96,8 +102,7 @@ export function findPath(grid, start, goal) {
         if (currentKey === goalKey) {
             const path = [current];
             let trace = currentKey;
-            while (cameFrom.has(trace)) {
-                const previous = cameFrom.get(trace);
+            for (let previous = cameFrom.get(trace); previous; previous = cameFrom.get(trace)) {
                 path.unshift(previous);
                 trace = key(previous);
             }
@@ -106,7 +111,7 @@ export function findPath(grid, start, goal) {
         }
         open.delete(currentKey);
         closed.add(currentKey);
-        const currentG = gScore.get(currentKey);
+        const currentG = scoreOf(gScore, currentKey);
         for (const next of neighbors(grid, current)) {
             const nextKey = key(next);
             if (closed.has(nextKey))

package/dist/topdown-motor.d.ts

@@ -6,7 +6,7 @@ export type TopDownFacing = 'n' | 's' | 'e' | 'w';
  * step(). Eight-direction input is normalized so diagonals match cardinal
  * speed; movement has no gravity and resolves each axis against Solids.
  */
-export declare class TopDownMotor extends GridMotor<TopDownFacing> {
+export declare class TopDownMotor extends GridMotor {
     static componentName: string;
     /** Four-direction facing; starts looking at the camera. */
     facing: TopDownFacing;

package/package.json

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