@waica/cli 0.7.0 → 0.9.0

package/dist/mcp/node_modules/@waica/behaviors/dist/iso-motor.d.ts

@@ -0,0 +1,21 @@
+import { type ScreenFacing } from './facing.js';
+import { GridMotor } from './grid-motor.js';
+/** The eight screen-relative facings declared by the isometric archetype. */
+export type IsoFacing = ScreenFacing;
+/**
+ * Passive isometric motor. Input and facing are screen-relative while the
+ * 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> {
+    static componentName: string;
+    facing: IsoFacing;
+    /**
+     * Under the diamond projection neither logical axis is "up the screen", so
+     * the footprint is square: as deep as it is wide, one cell-ish, instead of
+     * the short body top-down uses to let the player overlap a fence's top.
+     */
+    hitboxHeight: number;
+    /** Accelerates screen-relative input toward a logical-space velocity. */
+    run(inputX: number, inputY: number, dt: number): void;
+}

package/dist/mcp/node_modules/@waica/behaviors/dist/iso-motor.js

@@ -0,0 +1,24 @@
+import { screenInputToLogical } from '@waica/engine';
+import { facingForInput } from './facing.js';
+import { GridMotor } from './grid-motor.js';
+/**
+ * Passive isometric motor. Input and facing are screen-relative while the
+ * shared GridMotor integrates and collides in logical square-grid space.
+ * State code owns the frame; this component has no onUpdate of its own.
+ */
+export class IsoMotor extends GridMotor {
+    static componentName = 'IsoMotor';
+    facing = 's';
+    /**
+     * Under the diamond projection neither logical axis is "up the screen", so
+     * the footprint is square: as deep as it is wide, one cell-ish, instead of
+     * the short body top-down uses to let the player overlap a fence's top.
+     */
+    hitboxHeight = 0.9;
+    /** Accelerates screen-relative input toward a logical-space velocity. */
+    run(inputX, inputY, dt) {
+        const direction = screenInputToLogical(inputX, inputY);
+        this.accelerateToward(direction.x, direction.y, dt);
+        this.facing = facingForInput(inputX, inputY) ?? this.facing;
+    }
+}

package/dist/mcp/node_modules/@waica/behaviors/dist/iso-player-states.d.ts

@@ -0,0 +1,5 @@
+/** The state graph new isometric player characters start with, as prefab data. */
+export declare const ISO_PLAYER_STATE_GRAPH: import("@waica/engine").RoleGraph;
+/** Drives IsoMotor from screen-relative actions and reports body state. */
+export declare const isoPlayerUpdate: (ctx: import("@waica/engine").StateContext, dt: number) => void;
+export declare const ISO_PLAYER_ROLE: import("@waica/engine").RoleDefinition;

package/dist/mcp/node_modules/@waica/behaviors/dist/iso-player-states.js

@@ -0,0 +1,9 @@
+import { createGridPlayerRole } from './grid-player-role.js';
+import { IsoMotor } from './iso-motor.js';
+const isoPlayer = createGridPlayerRole(IsoMotor, 'You control this character with screen-relative eight-direction movement ' +
+    'projected into an isometric logical world. Its states move the Motor.');
+/** The state graph new isometric player characters start with, as prefab data. */
+export const ISO_PLAYER_STATE_GRAPH = isoPlayer.graph;
+/** Drives IsoMotor from screen-relative actions and reports body state. */
+export const isoPlayerUpdate = isoPlayer.update;
+export const ISO_PLAYER_ROLE = isoPlayer.role;

package/dist/mcp/node_modules/@waica/behaviors/dist/melee-attack.d.ts

@@ -0,0 +1,48 @@
+import { Component, type Entity } from '@waica/engine';
+/**
+ * A short frontal strike. Passive like a motor: state code decides when it
+ * happens (the player's `attack` state) and calls strike(facing); this only
+ * knows where the blow lands and who can be hurt by it. The hit area is a
+ * `range` × `width` rectangle in logical space, laid along the facing from
+ * the attacker's position — under the isometric projection that is the
+ * diamond diagonal screen-east maps to, so "in front" matches the screen.
+ */
+export declare class MeleeAttack extends Component {
+    static componentName: string;
+    static displayName: string;
+    static params: {
+        damage: {
+            label: string;
+            min: number;
+            max: number;
+            step: number;
+        };
+        range: {
+            label: string;
+            min: number;
+            max: number;
+            step: number;
+        };
+        width: {
+            label: string;
+            min: number;
+            max: number;
+            step: number;
+        };
+    };
+    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;
+    /**
+     * Lands one blow along `facing`: every other living entity with a Hitbox
+     * and a Health inside the strike area takes `damage` once, with this
+     * entity as the source. Returns the entities whose health actually
+     * dropped — a target still inside its invulnerability window is not
+     * counted. An unknown facing strikes nothing.
+     */
+    strike(facing: string): Entity[];
+    /** The oriented rectangle in front of the attacker, as a unit-scaled polygon. */
+    private strikeArea;
+}

package/dist/mcp/node_modules/@waica/behaviors/dist/melee-attack.js

@@ -0,0 +1,83 @@
+import { Component, Hitbox, collisionOverlap, } from '@waica/engine';
+import { logicalDirection } from './facing.js';
+import { Health } from './health.js';
+/**
+ * A short frontal strike. Passive like a motor: state code decides when it
+ * happens (the player's `attack` state) and calls strike(facing); this only
+ * knows where the blow lands and who can be hurt by it. The hit area is a
+ * `range` × `width` rectangle in logical space, laid along the facing from
+ * the attacker's position — under the isometric projection that is the
+ * diamond diagonal screen-east maps to, so "in front" matches the screen.
+ */
+export class MeleeAttack extends Component {
+    static componentName = 'MeleeAttack';
+    static displayName = 'Melee attack';
+    static params = {
+        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 },
+    };
+    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;
+    /**
+     * Lands one blow along `facing`: every other living entity with a Hitbox
+     * and a Health inside the strike area takes `damage` once, with this
+     * entity as the source. Returns the entities whose health actually
+     * dropped — a target still inside its invulnerability window is not
+     * counted. An unknown facing strikes nothing.
+     */
+    strike(facing) {
+        const direction = logicalDirection(facing, this.game.projection);
+        if (!direction)
+            return [];
+        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)
+                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)
+                struck.push(other);
+        }
+        return struck;
+    }
+    /** The oriented rectangle in front of the attacker, as a unit-scaled polygon. */
+    strikeArea(dx, dy) {
+        const along = { x: (dx * this.range) / 2, y: (dy * this.range) / 2 };
+        const across = { x: (-dy * this.width) / 2, y: (dx * this.width) / 2 };
+        const points = [
+            [-along.x - across.x, -along.y - across.y],
+            [along.x - across.x, along.y - across.y],
+            [along.x + across.x, along.y + across.y],
+            [-along.x + across.x, -along.y + across.y],
+        ];
+        return {
+            x: this.entity.position.x + along.x,
+            y: this.entity.position.y + along.y,
+            width: 1,
+            height: 1,
+            shape: 'polygon',
+            points,
+        };
+    }
+}

package/dist/mcp/node_modules/@waica/behaviors/dist/patrol.d.ts

@@ -1,14 +1,16 @@
-import { Component, type RoleDefinition, type RoleGraph } from '@waica/engine';
+import { Component, type AnimationFacingProvider, type RoleDefinition, type RoleGraph } from '@waica/engine';
 export type PatrolAxis = 'horizontal' | 'vertical';
 /**
  * Rail patrol: back and forth `distance` units from the starting
  * position along one axis — sideways or up and down — turning around
- * at the ends (with a sprite flip when walking sideways).
+ * at the ends. It reports which way it walks as seen on screen, so a
+ * directional contract picks the matching clip; without one, walking
+ * sideways flips the sprite by scale instead.
  * Passive like a motor: no onUpdate of its own — the 'patroller' logic
  * set's walk state calls step(dt), so the StateMachine stays the single
  * owner of the frame.
  */
-export declare class Patrol extends Component {
+export declare class Patrol extends Component implements AnimationFacingProvider {
     static componentName: string;
     static params: {
         axis: {
@@ -36,6 +38,12 @@ export declare class Patrol extends Component {
     private originY;
     private dir;
     onReady(): void;
+    /**
+     * The rail direction as rendered: the logical axis it walks along,
+     * projected when the scene is isometric — a horizontal rail reads as
+     * south-east/north-west there, a vertical one as south-west/north-east.
+     */
+    getAnimationFacing(): string;
     /** One patrol step: advance, turn at the rail's ends, flip the sprite. */
     step(dt: number): void;
 }

package/dist/mcp/node_modules/@waica/behaviors/dist/patrol.js

@@ -1,8 +1,15 @@
-import { Component } from '@waica/engine';
+import { Component, installedDirectionalAnimation, projectIsometric, } from '@waica/engine';
+import { facingForInput } from './facing.js';
+/** Seconds a hit stops the rail. */
+const HURT_SECONDS = 0.25;
+/** Seconds the death pose stays on screen before the entity goes away. */
+const DEATH_SECONDS = 0.5;
 /**
  * Rail patrol: back and forth `distance` units from the starting
  * position along one axis — sideways or up and down — turning around
- * at the ends (with a sprite flip when walking sideways).
+ * at the ends. It reports which way it walks as seen on screen, so a
+ * directional contract picks the matching clip; without one, walking
+ * sideways flips the sprite by scale instead.
  * Passive like a motor: no onUpdate of its own — the 'patroller' logic
  * set's walk state calls step(dt), so the StateMachine stays the single
  * owner of the frame.
@@ -26,6 +33,18 @@ export class Patrol extends Component {
         this.originX = this.entity.position.x;
         this.originY = this.entity.position.y;
     }
+    /**
+     * The rail direction as rendered: the logical axis it walks along,
+     * projected when the scene is isometric — a horizontal rail reads as
+     * south-east/north-west there, a vertical one as south-west/north-east.
+     */
+    getAnimationFacing() {
+        const vertical = this.axis === 'vertical';
+        const lx = vertical ? 0 : this.dir;
+        const ly = vertical ? this.dir : 0;
+        const screen = this.game.projection === 'isometric' ? projectIsometric(lx, ly) : { x: lx, y: ly };
+        return facingForInput(Math.sign(screen.x), Math.sign(screen.y)) ?? 's';
+    }
     /** One patrol step: advance, turn at the rail's ends, flip the sprite. */
     step(dt) {
         const pos = this.entity.position;
@@ -42,16 +61,32 @@ export class Patrol extends Component {
             this.dir = 1;
         }
         pos[key] = next;
-        if (!vertical)
+        // With a directional contract installed the clip carries the mirroring
+        // (flipX); a scale flip on top would undo it.
+        if (!vertical && !installedDirectionalAnimation())
             this.entity.scale.x = this.dir;
     }
 }
 /** The state graph new patrolling characters start with, as prefab data. */
 export const PATROLLER_STATE_GRAPH = {
     initial: 'walk',
-    states: { walk: {} },
+    states: {
+        walk: {},
+        hurt: { transitions: [{ on: `timer:${HURT_SECONDS}`, to: 'walk' }] },
+        // The death pose, resolved directionally like every other clip.
+        dead: { clip: 'death' },
+        // Death first: a lethal hit must never land in hurt. The death edge is
+        // also what makes Health hand the death to this graph instead of
+        // destroying the entity on the spot.
+        '*': {
+            transitions: [
+                { on: 'signal:death', to: 'dead' },
+                { on: 'signal:hurt', to: 'hurt' },
+            ],
+        },
+    },
 };
-// The walking-critter role. One state out of the box; give patrolling
+// The walking-critter role. Walks, flinches, dies; give patrolling
 // characters more states by registering on top (defineStates('patroller',
 // { chasing: {...} })) plus prefab data.
 export const PATROLLER_ROLE = {
@@ -65,5 +100,14 @@ export const PATROLLER_ROLE = {
                 entity.get(Patrol)?.step(dt);
             },
         },
+        // The rail stops for the flinch: no step, nothing else to do.
+        hurt: { onUpdate() { } },
+        // Holds the death pose for a beat, then the body goes away for good.
+        dead: {
+            onUpdate({ entity, fsm }) {
+                if (fsm.elapsed >= DEATH_SECONDS)
+                    entity.destroy();
+            },
+        },
     },
 };

package/dist/mcp/node_modules/@waica/behaviors/dist/topdown-motor.d.ts

@@ -1,72 +1,18 @@
-import { Component, type AnimationFacingProvider, type CameraVelocity, type CameraVelocityProvider } from '@waica/engine';
+import { GridMotor } from './grid-motor.js';
 /** The four facings the top-down animation contract declares. */
 export type TopDownFacing = 'n' | 's' | 'e' | 'w';
 /**
- * Passive top-down motor: tuning params, physical state and movement
- * methods for state code to call. It has no onUpdate of its own — the
- * StateMachine is the only owner of the frame; this is the toolbox the
- * active state moves the body with. Eight-direction movement with the
- * input vector normalized so diagonals match cardinal speed, no gravity,
- * and per-axis collision against the scene's Solids — deterministic
- * genre movement (Zelda-style), not "realistic" physics.
+ * Passive top-down motor: state code owns the frame and calls run() then
+ * 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 Component implements CameraVelocityProvider, AnimationFacingProvider {
+export declare class TopDownMotor extends GridMotor<TopDownFacing> {
     static componentName: string;
-    static displayName: string;
-    static params: {
-        moveSpeed: {
-            label: string;
-            min: number;
-            max: number;
-            step: number;
-        };
-        acceleration: {
-            label: string;
-            min: number;
-            max: number;
-            step: number;
-        };
-        deceleration: {
-            label: string;
-            min: number;
-            max: number;
-            step: number;
-        };
-        walkThreshold: {
-            label: string;
-            min: number;
-            max: number;
-            step: number;
-        };
-    };
-    static transient: string[];
-    moveSpeed: number;
-    acceleration: number;
-    deceleration: number;
-    /** Speed above this reads as walking (the idle ↔ walk edge). */
-    walkThreshold: number;
-    /** The character's AABB hitbox — a footprint, shorter than the sprite. */
-    hitboxWidth: number;
-    hitboxHeight: number;
-    vx: number;
-    vy: number;
     /** Four-direction facing; starts looking at the camera. */
     facing: TopDownFacing;
-    /** The scene camera reads follow velocity through this explicit seam. */
-    getCameraVelocity(): CameraVelocity;
-    /** The StateMachine resolves directional clips through this explicit seam. */
-    getAnimationFacing(): string;
     /**
-     * Accelerates toward the input vector (each axis -1..1) * moveSpeed.
-     * The vector is normalized so diagonals move at cardinal speed, and
-     * facing follows the dominant input axis — ties keep the last facing.
+     * Accelerates toward the input vector and lets the dominant raw input axis
+     * select facing. Perfect ties preserve the previous facing.
      */
     run(inputX: number, inputY: number, dt: number): void;
-    /** Live speed, for the idle ↔ walk edge. */
-    speed(): number;
-    /** Integrates velocity and resolves each axis against Solids. */
-    step(dt: number): void;
-    halt(): void;
-    private resolveAxis;
-    private collisionBody;
 }

package/dist/mcp/node_modules/@waica/behaviors/dist/topdown-motor.js

@@ -1,47 +1,16 @@
-import { Component, resolveSolidAxis, THREE, } from '@waica/engine';
+import { GridMotor } from './grid-motor.js';
 /**
- * Passive top-down motor: tuning params, physical state and movement
- * methods for state code to call. It has no onUpdate of its own — the
- * StateMachine is the only owner of the frame; this is the toolbox the
- * active state moves the body with. Eight-direction movement with the
- * input vector normalized so diagonals match cardinal speed, no gravity,
- * and per-axis collision against the scene's Solids — deterministic
- * genre movement (Zelda-style), not "realistic" physics.
+ * Passive top-down motor: state code owns the frame and calls run() then
+ * step(). Eight-direction input is normalized so diagonals match cardinal
+ * speed; movement has no gravity and resolves each axis against Solids.
  */
-export class TopDownMotor extends Component {
+export class TopDownMotor extends GridMotor {
     static componentName = 'TopDownMotor';
-    static displayName = 'Motor';
-    static params = {
-        moveSpeed: { label: 'Speed', min: 1, max: 30, step: 0.5 },
-        acceleration: { label: 'Acceleration', min: 5, max: 200, step: 5 },
-        deceleration: { label: 'Deceleration', min: 5, max: 200, step: 5 },
-        walkThreshold: { label: 'Walk threshold', min: 0, max: 5, step: 0.1 },
-    };
-    static transient = ['vx', 'vy', 'facing'];
-    moveSpeed = 6;
-    acceleration = 60;
-    deceleration = 80;
-    /** Speed above this reads as walking (the idle ↔ walk edge). */
-    walkThreshold = 0.5;
-    /** The character's AABB hitbox — a footprint, shorter than the sprite. */
-    hitboxWidth = 0.9;
-    hitboxHeight = 0.6;
-    vx = 0;
-    vy = 0;
     /** Four-direction facing; starts looking at the camera. */
     facing = 's';
-    /** The scene camera reads follow velocity through this explicit seam. */
-    getCameraVelocity() {
-        return { vx: this.vx, vy: this.vy };
-    }
-    /** The StateMachine resolves directional clips through this explicit seam. */
-    getAnimationFacing() {
-        return this.facing;
-    }
     /**
-     * Accelerates toward the input vector (each axis -1..1) * moveSpeed.
-     * The vector is normalized so diagonals move at cardinal speed, and
-     * facing follows the dominant input axis — ties keep the last facing.
+     * Accelerates toward the input vector and lets the dominant raw input axis
+     * select facing. Perfect ties preserve the previous facing.
      */
     run(inputX, inputY, dt) {
         let x = inputX;
@@ -51,10 +20,7 @@ export class TopDownMotor extends Component {
             x /= length;
             y /= length;
         }
-        const rateX = x !== 0 ? this.acceleration : this.deceleration;
-        const rateY = y !== 0 ? this.acceleration : this.deceleration;
-        this.vx = THREE.MathUtils.damp(this.vx, x * this.moveSpeed, rateX / this.moveSpeed, dt);
-        this.vy = THREE.MathUtils.damp(this.vy, y * this.moveSpeed, rateY / this.moveSpeed, dt);
+        this.accelerateToward(x, y, dt);
         const absX = Math.abs(inputX);
         const absY = Math.abs(inputY);
         if (absX > absY)
@@ -62,41 +28,4 @@ export class TopDownMotor extends Component {
         else if (absY > absX)
             this.facing = inputY < 0 ? 's' : 'n';
     }
-    /** Live speed, for the idle ↔ walk edge. */
-    speed() {
-        return Math.hypot(this.vx, this.vy);
-    }
-    /** Integrates velocity and resolves each axis against Solids. */
-    step(dt) {
-        const pos = this.entity.position;
-        const previousX = pos.x;
-        pos.x += this.vx * dt;
-        if (this.resolveAxis('x', previousX))
-            this.vx = 0;
-        const previousY = pos.y;
-        pos.y += this.vy * dt;
-        if (this.resolveAxis('y', previousY))
-            this.vy = 0;
-    }
-    halt() {
-        this.vx = 0;
-        this.vy = 0;
-    }
-    resolveAxis(axis, previous) {
-        return resolveSolidAxis({
-            entity: this.entity,
-            axis,
-            previous,
-            body: () => this.collisionBody(),
-        });
-    }
-    collisionBody() {
-        return {
-            x: this.entity.position.x,
-            y: this.entity.position.y,
-            width: this.hitboxWidth,
-            height: this.hitboxHeight,
-            shape: 'rectangle',
-        };
-    }
 }

package/dist/mcp/node_modules/@waica/behaviors/dist/topdown-player-states.d.ts

@@ -1,18 +1,5 @@
-import { type RoleDefinition, type RoleGraph, type StateContext } from '@waica/engine';
-/**
- * The top-down 'player' role: the character you control from above. Both
- * default states share one body update; they differ only in the edges
- * their prefab data declares. Extending the player is defineStates
- * ('player', { yourState: {...} }) plus a state in the prefab — never a
- * fight with a parallel controller.
- */
 /** The state graph new top-down player characters start with, as prefab data. */
-export declare const TOPDOWN_PLAYER_STATE_GRAPH: RoleGraph;
-/**
- * One body update shared by every default state: read the four-direction
- * actions, accelerate, collide, then report what the body is doing as
- * signals. Unmatched signals are no-ops, so each state only reacts to
- * the edges its data declares.
- */
-export declare function topdownPlayerUpdate({ entity, game, fsm }: StateContext, dt: number): void;
-export declare const TOPDOWN_PLAYER_ROLE: RoleDefinition;
+export declare const TOPDOWN_PLAYER_STATE_GRAPH: import("@waica/engine").RoleGraph;
+/** Drives TopDownMotor from project actions and reports body state. */
+export declare const topdownPlayerUpdate: (ctx: import("@waica/engine").StateContext, dt: number) => void;
+export declare const TOPDOWN_PLAYER_ROLE: import("@waica/engine").RoleDefinition;

package/dist/mcp/node_modules/@waica/behaviors/dist/topdown-player-states.js

@@ -1,86 +1,14 @@
-import {} from '@waica/engine';
-import { Health } from './health.js';
-import { interactUpdate } from './interactable.js';
-import { Respawnable } from './respawnable.js';
+import { createGridPlayerRole } from './grid-player-role.js';
 import { TopDownMotor } from './topdown-motor.js';
 /**
- * The top-down 'player' role: the character you control from above. Both
- * default states share one body update; they differ only in the edges
- * their prefab data declares. Extending the player is defineStates
- * ('player', { yourState: {...} }) plus a state in the prefab — never a
- * fight with a parallel controller.
+ * The top-down player role: eight-direction logical-grid movement with
+ * normalized diagonals and no gravity, driven by TopDownMotor.
  */
+const topdownPlayer = createGridPlayerRole(TopDownMotor, 'You control this character with the project controls: eight-direction ' +
+    'top-down movement with normalized diagonals and no gravity. Its ' +
+    'states move the Motor.');
 /** The state graph new top-down player characters start with, as prefab data. */
-export const TOPDOWN_PLAYER_STATE_GRAPH = {
-    initial: 'idle',
-    states: {
-        idle: {
-            transitions: [{ on: 'signal:move', to: 'walk' }],
-        },
-        walk: {
-            transitions: [{ on: 'signal:stop', to: 'idle' }],
-        },
-        dead: {
-            // Freeze on idle (resolved directionally) rather than name a death
-            // clip the stock sheets do not have and warn every frame.
-            clip: 'idle',
-            // A beat before control comes back, so death reads as an event.
-            transitions: [{ on: 'timer:0.8', to: 'idle' }],
-        },
-        // Dying is the same from every state, so the edge lives on '*'. Its
-        // presence is also the contract Health checks before signalling: a graph
-        // without it gets its entity destroyed instead.
-        '*': { transitions: [{ on: 'signal:death', to: 'dead' }] },
-    },
-};
-/**
- * One body update shared by every default state: read the four-direction
- * actions, accelerate, collide, then report what the body is doing as
- * signals. Unmatched signals are no-ops, so each state only reacts to
- * the edges its data declares.
- */
-export function topdownPlayerUpdate({ entity, game, fsm }, dt) {
-    const motor = entity.get(TopDownMotor);
-    if (!motor)
-        return;
-    motor.run(game.input.axis('left', 'right'), game.input.axis('down', 'up'), dt);
-    motor.step(dt);
-    fsm.signal(motor.speed() > motor.walkThreshold ? 'move' : 'stop');
-}
-export const TOPDOWN_PLAYER_ROLE = {
-    description: 'You control this character with the project controls: eight-direction ' +
-        'top-down movement with normalized diagonals and no gravity. Its ' +
-        'states move the Motor.',
-    driver: 'TopDownMotor',
-    graph: TOPDOWN_PLAYER_STATE_GRAPH,
-    signals: {
-        move: 'moving',
-        stop: 'standing still',
-    },
-    states: {
-        // Always-hook: the interact lookup must survive custom states like an
-        // attack, so it runs in every state.
-        '*': {
-            onUpdate(ctx) {
-                interactUpdate(ctx);
-            },
-        },
-        // Fallback: a custom state without its own onUpdate keeps the full
-        // body update — its file only has to say what makes it special.
-        default: { onUpdate: topdownPlayerUpdate },
-        idle: { onUpdate: topdownPlayerUpdate },
-        walk: { onUpdate: topdownPlayerUpdate },
-        // Coming back is what leaving death means, so it hangs off onExit: any
-        // other way out of this state (a project's own edge) revives too.
-        dead: {
-            // A state without its own onUpdate falls back to the role's default
-            // body update, so without this no-op the player kept walking for the
-            // whole death beat instead of the graph taking control away.
-            onUpdate() { },
-            onExit({ entity }) {
-                entity.get(Respawnable)?.respawn();
-                entity.get(Health)?.heal(Infinity);
-            },
-        },
-    },
-};
+export const TOPDOWN_PLAYER_STATE_GRAPH = topdownPlayer.graph;
+/** Drives TopDownMotor from project actions and reports body state. */
+export const topdownPlayerUpdate = topdownPlayer.update;
+export const TOPDOWN_PLAYER_ROLE = topdownPlayer.role;

package/dist/mcp/node_modules/@waica/behaviors/package.json

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

package/dist/mcp/node_modules/@waica/engine/dist/component.d.ts

@@ -63,6 +63,8 @@ export declare abstract class Component {
     onReady?(): void;
     /** Runs once per frame. */
     onUpdate?(dt: number): void;
+    /** Runs after the scene changes between identity and projected rendering. */
+    onProjectionChange?(projection: 'isometric' | null): void;
     /** Runs when this entity's Hitbox overlaps another one's. */
     onCollide?(other: Entity): void;
     /** Runs when this entity's DynamicBody physically contacts a Solid. */