@waica/cli 0.7.0 → 0.8.0

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

@@ -0,0 +1,74 @@
+import { Component, resolveSolidAxis, THREE, } from '@waica/engine';
+/** Shared velocity, collision and provider behavior for square-grid motors. */
+export class GridMotor extends Component {
+    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;
+    /** 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 each axis toward an already-normalized logical direction. */
+    accelerateToward(x, y, dt) {
+        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);
+    }
+    /** Live speed, for the idle ↔ walk edge. */
+    speed() {
+        return Math.hypot(this.vx, this.vy);
+    }
+    /** Integrates velocity and resolves each logical axis against Solids. */
+    step(dt) {
+        const position = this.entity.position;
+        const previousX = position.x;
+        position.x += this.vx * dt;
+        if (this.resolveAxis('x', previousX))
+            this.vx = 0;
+        const previousY = position.y;
+        position.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/grid-player-role.d.ts

@@ -0,0 +1,15 @@
+import { type Component, type ComponentClass, type RoleDefinition, type RoleGraph, type StateContext } from '@waica/engine';
+interface PlayerMotor extends Component {
+    walkThreshold: number;
+    run(inputX: number, inputY: number, dt: number): void;
+    step(dt: number): void;
+    speed(): number;
+}
+interface GridPlayerRoleParts {
+    graph: RoleGraph;
+    update(ctx: StateContext, dt: number): void;
+    role: RoleDefinition;
+}
+/** Builds the common player graph and role around one genre-specific grid motor. */
+export declare function createGridPlayerRole<T extends PlayerMotor>(Motor: ComponentClass<T>, description: string): GridPlayerRoleParts;
+export {};

package/dist/mcp/node_modules/@waica/behaviors/dist/grid-player-role.js

@@ -0,0 +1,71 @@
+import {} from '@waica/engine';
+import { Health } from './health.js';
+import { interactUpdate } from './interactable.js';
+import { Respawnable } from './respawnable.js';
+/** Builds the common player graph and role around one genre-specific grid motor. */
+export function createGridPlayerRole(Motor, description) {
+    const 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',
+                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' }] },
+        },
+    };
+    const update = ({ entity, game, fsm }, dt) => {
+        const motor = entity.get(Motor);
+        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');
+    };
+    const role = {
+        description,
+        driver: Motor.componentName,
+        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: update },
+            idle: { onUpdate: update },
+            walk: { onUpdate: update },
+            // 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 this no-op keeps the player still for the death beat.
+                onUpdate() { },
+                onExit({ entity }) {
+                    entity.get(Respawnable)?.respawn();
+                    entity.get(Health)?.heal(Infinity);
+                },
+            },
+        },
+    };
+    return { graph, update, role };
+}

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

@@ -1,8 +1,10 @@
 export { PlatformerMotor } from './platformer-motor.js';
 export { PLAYER_ROLE, PLAYER_STATE_GRAPH, playerUpdate } from './player-states.js';
 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 { Interactable, interactUpdate } from './interactable.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 { Collectible } from './collectible.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';

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

@@ -1,8 +1,10 @@
 export { PlatformerMotor } from './platformer-motor.js';
 export { PLAYER_ROLE, PLAYER_STATE_GRAPH, playerUpdate } from './player-states.js';
 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 { Interactable, interactUpdate } from './interactable.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 { Collectible } from './collectible.js';
 export { Patrol, PATROLLER_ROLE, PATROLLER_STATE_GRAPH } from './patrol.js';
 export { Chaser, CHASER_ROLE, CHASER_STATE_GRAPH } from './chaser.js';

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

@@ -22,6 +22,9 @@ export declare class Interactable extends Component {
     line: string;
     radius: number;
 }
+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>>;
 /**
  * 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/mcp/node_modules/@waica/behaviors/dist/interactable.js

@@ -15,6 +15,29 @@ export class Interactable extends Component {
     line = 'Hello, traveler!';
     radius = 1.5;
 }
+export const INTERACTABLE_UI_PIECE = 'npc-line';
+/** The UI fragment every archetype using Interactable must register. */
+export const INTERACTABLE_UI = {
+    [INTERACTABLE_UI_PIECE]: `<style>
+  .npc-line {
+    position: absolute;
+    left: 50%;
+    bottom: 24px;
+    transform: translateX(-50%);
+    max-width: 70%;
+    padding: 10px 18px;
+    border-radius: 8px;
+    background: #1a1a2ecc;
+    border: 1px solid #ffffff2e;
+    font: 500 18px system-ui, sans-serif;
+    color: #f5f5f5;
+    text-shadow: 0 1px 2px #000a;
+    user-select: none;
+  }
+</style>
+<div class="npc-line">{{npcLine}}</div>
+`,
+};
 /**
  * The player role's interact lookup, run by its '*' hook in every state:
  * pressing interact near an Interactable publishes its line through the
@@ -37,13 +60,13 @@ export function interactUpdate({ entity, game }) {
         }
     }
     if (!nearest) {
-        game.ui.hide('npc-line');
+        game.ui.hide(INTERACTABLE_UI_PIECE);
         return;
     }
     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');
         game.stats.set('npcLine', nearest.line);
-        game.ui.show('npc-line');
+        game.ui.show(INTERACTABLE_UI_PIECE);
     }
 }

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

@@ -0,0 +1,14 @@
+import { GridMotor } from './grid-motor.js';
+/** The eight screen-relative facings declared by the isometric archetype. */
+export type IsoFacing = 'n' | 'ne' | 'e' | 'se' | 's' | 'sw' | 'w' | 'nw';
+/**
+ * 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;
+    /** 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,36 @@
+import { screenInputToLogical } from '@waica/engine';
+import { GridMotor } from './grid-motor.js';
+function facingForInput(inputX, inputY) {
+    if (inputX === 0 && inputY === 0)
+        return undefined;
+    if (inputY > 0) {
+        if (inputX > 0)
+            return 'ne';
+        if (inputX < 0)
+            return 'nw';
+        return 'n';
+    }
+    if (inputY < 0) {
+        if (inputX > 0)
+            return 'se';
+        if (inputX < 0)
+            return 'sw';
+        return 's';
+    }
+    return inputX > 0 ? 'e' : 'w';
+}
+/**
+ * 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';
+    /** 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/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.8.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.8.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. */