incanto 0.4.3 → 0.6.0

package/dist/{gameplay-Ccruc3Wd.js → gameplay-CDFgSG6z.js}

@@ -1,6 +1,7 @@
-import { _ as registerBehavior, m as Behavior } from "./loader-CGs_G-r0.js";
+import { _ as registerBehavior, m as Behavior, n as loadScene } from "./loader-B4OEXDZ8.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
-import { t as duplicateNode } from "./duplicate-DP2WPYom.js";
+import { t as jsonClone } from "./json-BLk7H2Qa.js";
+import { t as duplicateNode } from "./duplicate-BEvGBtb_.js";
 //#region src/gameplay/spatial.ts
 /** Duck-type test: every spatial node (Node2D/Node3D) exposes `position: number[]`. */
 function hasPosition$1(node) {
@@ -36,13 +37,6 @@ function add(a, b) {
 	for (let i = 0; i < n; i++) out[i] = (a[i] ?? 0) + (b[i] ?? 0);
 	return out;
 }
-/** Component-wise `a - b`. */
-function sub(a, b) {
-	const n = Math.max(a.length, b.length);
-	const out = new Array(n);
-	for (let i = 0; i < n; i++) out[i] = (a[i] ?? 0) - (b[i] ?? 0);
-	return out;
-}
 /** Vector length. */
 function length(v) {
 	let sum = 0;
@@ -60,15 +54,28 @@ function normalize(v) {
 * whether the destination was reached this step (clamped — no overshoot).
 */
 function moveToward(from, to, maxStep) {
-	const delta = sub(to, from);
-	const dist = length(delta);
-	if (dist <= maxStep || dist === 0) return {
-		position: [...to],
-		reached: true
-	};
+	const n = Math.max(from.length, to.length);
+	let sum = 0;
+	for (let i = 0; i < n; i++) {
+		const d = (to[i] ?? 0) - (from[i] ?? 0);
+		sum += d * d;
+	}
+	const dist = Math.sqrt(sum);
+	const position = new Array(n);
+	if (dist <= maxStep || dist === 0) {
+		for (let i = 0; i < n; i++) position[i] = to[i] ?? 0;
+		return {
+			position,
+			reached: true
+		};
+	}
 	const f = maxStep / dist;
+	for (let i = 0; i < n; i++) {
+		const c = from[i] ?? 0;
+		position[i] = c + ((to[i] ?? 0) - c) * f;
+	}
 	return {
-		position: from.map((c, i) => c + (delta[i] ?? 0) * f),
+		position,
 		reached: false
 	};
 }
@@ -427,19 +434,128 @@ var FollowCamera = class extends Behavior {
 		if (this.deadzone < 0) throw new IncantoError("PROP_TYPE_MISMATCH", `FollowCamera on '${this.node.getPath()}': "deadzone" must be >= 0, got ${this.deadzone}.`, { prop: "deadzone" });
 		requirePosition(this);
 	}
+	shakeMag = 0;
+	shakeT = 0;
+	shakeFalloff = .28;
+	/** Kick the camera (impacts, explosions). Composes with the follow. */
+	shake(magnitude, seconds = .28) {
+		this.shakeMag = Math.max(this.shakeMag, magnitude);
+		this.shakeT = seconds;
+		this.shakeFalloff = seconds;
+	}
 	update(dt) {
 		const cam = this.node;
 		if (!hasPosition$1(cam)) return;
 		const target = cam.getNodeOrNull(this.target);
 		if (!target || !hasPosition$1(target)) return;
 		const desired = add(target.position, this.offset);
-		if (this.deadzone > 0 && distance$1(cam.position, desired) <= this.deadzone) return;
-		const f = smoothingFactor(this.smoothing, dt);
-		if (f >= 1) {
-			cam.position = [...desired];
-			return;
+		if (!(this.deadzone > 0 && distance$1(cam.position, desired) <= this.deadzone)) {
+			const f = smoothingFactor(this.smoothing, dt);
+			if (f >= 1) cam.position = [...desired];
+			else cam.position = cam.position.map((c, i) => c + ((desired[i] ?? c) - c) * f);
+		}
+		if (this.shakeT > 0) {
+			this.shakeT -= dt;
+			const k = this.shakeMag * Math.max(0, this.shakeT) / this.shakeFalloff;
+			if (this.shakeT <= 0) this.shakeMag = 0;
+			const jolted = cam.position.slice();
+			for (let i = 0; i < jolted.length; i++) {
+				const scale = jolted.length >= 3 && i === 1 ? .5 : 1;
+				jolted[i] = (jolted[i] ?? 0) + (this.engine.rng.next() * 2 - 1) * k * scale;
+			}
+			cam.position = jolted;
 		}
-		cam.position = cam.position.map((c, i) => c + ((desired[i] ?? c) - c) * f);
+	}
+};
+//#endregion
+//#region src/gameplay/game-flow.ts
+/**
+* Reload the CURRENT scene from its source JSON — fresh nodes, reset physics,
+* rewired input. The restart primitive every game-over screen wants.
+*/
+function restartScene(engine) {
+	const source = engine.scene?.source;
+	if (!source) return;
+	engine.timeScale = 1;
+	engine.setScene(loadScene(jsonClone(source)));
+}
+/**
+* The win/lose/restart state machine 6+ examples hand-rolled as `over`/`win`
+* booleans. Attach to any node (the scene root is natural):
+*
+*   const flow = root.behavior as GameFlow;   // script: { "name": "GameFlow" }
+*   flow.gameOver('YOU DIED');                 // freezes time, sticky banner
+*   flow.win('AREA CLEAR');
+*   flow.pause(); flow.resume();
+*
+* While in `gameover`/`won`, pressing `restartAction` (default action name
+* 'restart' — declare it in the scene input map, or leave undeclared and call
+* `flow.restart()` yourself) reloads the scene from source. Banners render
+* through a `%Banner` UiBanner when one exists; otherwise states are silent
+* (drive your own UI off the `flowChanged` signal).
+*/
+var GameFlow = class extends Behavior {
+	static signals = ["flowChanged"];
+	static props = {
+		restartAction: { default: "restart" },
+		freezeOnEnd: { default: true },
+		bannerPath: { default: "%Banner" }
+	};
+	/** Input action that restarts from gameover/won (declare it in `input{}`). */
+	restartAction = "restart";
+	/** Freeze `engine.timeScale` on gameover/won (banner UI keeps rendering). */
+	freezeOnEnd = true;
+	/** Where the flow looks for a UiBanner ('' = never). */
+	bannerPath = "%Banner";
+	state = "playing";
+	frozeScale = false;
+	gameOver(text = "GAME OVER", color = "#ef4444") {
+		this.transition("gameover", text, color);
+	}
+	win(text = "YOU WIN", color = "#4ade80") {
+		this.transition("won", text, color);
+	}
+	pause() {
+		if (this.state !== "playing") return;
+		this.state = "paused";
+		this.freeze();
+		this.node.emit("flowChanged", this.state);
+	}
+	resume() {
+		if (this.state !== "paused") return;
+		this.state = "playing";
+		this.thaw();
+		this.node.emit("flowChanged", this.state);
+	}
+	restart() {
+		this.thaw();
+		restartScene(this.engine);
+	}
+	transition(state, text, color) {
+		if (this.state === "gameover" || this.state === "won") return;
+		this.state = state;
+		if (this.freezeOnEnd) this.freeze();
+		if (this.bannerPath !== "") this.node.getNodeOrNull(this.bannerPath)?.show(text, {
+			color,
+			seconds: 0
+		});
+		this.node.emit("flowChanged", state);
+	}
+	freeze() {
+		if (this.frozeScale) return;
+		this.frozeScale = true;
+		this.engine.timeScale = 0;
+	}
+	thaw() {
+		if (!this.frozeScale) return;
+		this.frozeScale = false;
+		this.engine.timeScale = 1;
+	}
+	update() {
+		if (this.state !== "gameover" && this.state !== "won") return;
+		try {
+			if (this.engine.input.justPressed(this.restartAction)) this.restart();
+		} catch {}
 	}
 };
 //#endregion
@@ -508,6 +624,153 @@ function collectGroup(node, group) {
 	return out;
 }
 //#endregion
+//#region src/gameplay/juice.ts
+/**
+* Game-feel primitives ("juice"): the weapon cooldown, camera shake, screen
+* flash and hit-stop that action examples kept hand-rolling.
+*/
+/**
+* A fire-rate / ability cooldown — replaces the copy-pasted
+* `this.clock += dt * 1000; if (now > nextFire)` pattern:
+*
+*   private gun = new Cooldown(0.2);
+*   override update(dt: number): void {
+*     this.gun.tick(dt);
+*     if (this.engine.input.isPressed('fire') && this.gun.tryUse()) this.shoot();
+*   }
+*/
+var Cooldown = class {
+	seconds;
+	remaining = 0;
+	constructor(seconds) {
+		this.seconds = seconds;
+	}
+	/** Advance time. Call once per update with the frame dt. */
+	tick(dt) {
+		if (this.remaining > 0) this.remaining -= dt;
+	}
+	get ready() {
+		return this.remaining <= 0;
+	}
+	/** 0..1 — how far through the cooldown we are (1 = ready). UiBar-friendly. */
+	get progress() {
+		return this.seconds <= 0 ? 1 : Math.min(1, Math.max(0, 1 - this.remaining / this.seconds));
+	}
+	/** Consume if ready. Returns whether the action should fire. */
+	tryUse() {
+		if (this.remaining > 0) return false;
+		this.remaining = this.seconds;
+		return true;
+	}
+	/** Force-ready (pickups that reset your reload). */
+	reset() {
+		this.remaining = 0;
+	}
+};
+const SHAKE_FALLOFF_SECONDS = .28;
+/**
+* Camera shake as a standalone behavior for cameras WITHOUT another script.
+* (FollowCamera has this built in — one script per node.) Composes with any
+* other position writer by applying only the DELTA of its own offset, so the
+* camera returns exactly to where the other writer left it.
+*
+*   (camera.behavior as CameraShake).shake(8);           // pixels (2D) / meters·100 feel (3D: use ~0.2)
+*/
+var CameraShake = class extends Behavior {
+	static props = { falloff: { default: SHAKE_FALLOFF_SECONDS } };
+	/** Seconds a shake takes to decay to zero. */
+	falloff = SHAKE_FALLOFF_SECONDS;
+	magnitude = 0;
+	t = 0;
+	prev = [];
+	shake(magnitude, seconds) {
+		this.magnitude = Math.max(this.magnitude, magnitude);
+		this.t = seconds ?? this.falloff;
+	}
+	update(dt) {
+		const node = requirePosition(this);
+		const pos = node.position;
+		for (let i = 0; i < this.prev.length; i++) pos[i] = (pos[i] ?? 0) - (this.prev[i] ?? 0);
+		if (this.t <= 0) {
+			if (this.prev.length > 0) {
+				node.position = pos.slice();
+				this.prev.length = 0;
+			}
+			return;
+		}
+		this.t -= dt;
+		const k = this.magnitude * Math.max(0, this.t) / this.falloff;
+		if (this.t <= 0) this.magnitude = 0;
+		const next = pos.slice();
+		if (this.prev.length !== next.length) this.prev = new Array(next.length).fill(0);
+		for (let i = 0; i < next.length; i++) {
+			const scale = next.length >= 3 && i === 1 ? .5 : 1;
+			this.prev[i] = (this.engine.rng.next() * 2 - 1) * k * scale;
+			next[i] = (next[i] ?? 0) + this.prev[i];
+		}
+		node.position = next;
+	}
+};
+/**
+* Full-screen color flash (damage red, pickup white). DOM overlay above
+* everything; headless no-op. Repeated calls restart the fade.
+*/
+function screenFlash(color = "#ffffff", opacity = .35, seconds = .25) {
+	if (typeof document === "undefined") return;
+	const id = "incanto-screen-flash";
+	let el = document.getElementById(id);
+	if (!el) {
+		el = document.createElement("div");
+		el.id = id;
+		el.style.cssText = "position:fixed;inset:0;pointer-events:none;z-index:9999;opacity:0;transition:opacity .05s;";
+		document.body.appendChild(el);
+	}
+	el.style.background = color;
+	el.style.transition = "opacity .05s";
+	el.style.opacity = String(opacity);
+	const fade = () => {
+		el.style.transition = `opacity ${seconds}s`;
+		el.style.opacity = "0";
+	};
+	if (typeof requestAnimationFrame === "function") requestAnimationFrame(fade);
+	else fade();
+}
+/**
+* Hit-stop: freeze game time for `seconds` of REAL time, then restore the
+* previous timeScale. Stacking calls extend the freeze instead of fighting.
+*/
+function hitStop(engine, seconds = .08) {
+	const state = hitStops.get(engine);
+	if (state) {
+		state.until = Math.max(state.until, realNow() + seconds * 1e3);
+		return;
+	}
+	const restore = engine.timeScale;
+	const entry = {
+		until: realNow() + seconds * 1e3,
+		restore
+	};
+	hitStops.set(engine, entry);
+	engine.timeScale = 0;
+	const pump = () => {
+		if (realNow() >= entry.until) {
+			engine.timeScale = entry.restore;
+			hitStops.delete(engine);
+			return;
+		}
+		schedule(pump);
+	};
+	schedule(pump);
+}
+const hitStops = /* @__PURE__ */ new Map();
+function realNow() {
+	return typeof performance !== "undefined" ? performance.now() : Date.now();
+}
+function schedule(fn) {
+	if (typeof requestAnimationFrame === "function") requestAnimationFrame(fn);
+	else setTimeout(fn, 16);
+}
+//#endregion
 //#region src/gameplay/lifetime.ts
 /**
 * Self-destruct after a fixed time — bullets, particles, temporary spawns,
@@ -876,7 +1139,11 @@ var Projectile = class extends Behavior {
 	update(dt) {
 		const node = this.node;
 		if (this.gravity !== 0) this.velocity[1] = (this.velocity[1] ?? 0) + this.gravity * dt;
-		node.position = add(node.position, this.velocity.map((v) => v * dt));
+		const pos = node.position;
+		const n = Math.max(pos.length, this.velocity.length);
+		const next = new Array(n);
+		for (let i = 0; i < n; i++) next[i] = (pos[i] ?? 0) + (this.velocity[i] ?? 0) * dt;
+		node.position = next;
 	}
 	/** Resolve `direction` to a unit vector, deriving 'forward' from rotation. */
 	resolveDirection() {
@@ -1470,6 +1737,8 @@ var ZombieAI = class extends Behavior {
 */
 /** Every built-in gameplay behavior, keyed by its registration name. */
 const GAMEPLAY_BEHAVIORS = {
+	CameraShake,
+	GameFlow,
 	Health,
 	Lifetime,
 	ScoreKeeper,
@@ -1498,4 +1767,4 @@ function registerGameplayBehaviors(opts) {
 	for (const [name, ctor] of Object.entries(GAMEPLAY_BEHAVIORS)) registerBehavior(name, ctor, { replace });
 }
 //#endregion
-export { Health as _, Wander as a, Projectile as c, Oscillate as d, MoveTo as f, DamageOnContact as g, FollowCamera as h, WaveSpawner as i, Pickup as l, Interactable as m, registerGameplayBehaviors as n, Spawner as o, Lifetime as p, ZombieAI as r, ScoreKeeper as s, GAMEPLAY_BEHAVIORS as t, Patrol as u, Collector as v, Chase as y };
+export { Health as C, DamageOnContact as S, Chase as T, screenFlash as _, Wander as a, restartScene as b, Projectile as c, Oscillate as d, MoveTo as f, hitStop as g, Cooldown as h, WaveSpawner as i, Pickup as l, CameraShake as m, registerGameplayBehaviors as n, Spawner as o, Lifetime as p, ZombieAI as r, ScoreKeeper as s, GAMEPLAY_BEHAVIORS as t, Patrol as u, Interactable as v, Collector as w, FollowCamera as x, GameFlow as y };

package/dist/gameplay.d.ts

@@ -1,5 +1,5 @@
 import { c as JsonValue } from "./schema-CcoWb32N.js";
-import { T as Node, l as PropSchema, n as BehaviorCtor, t as Behavior } from "./behavior-BAQq7HGM.js";
+import { T as Node, l as PropSchema, n as BehaviorCtor, t as Behavior, v as Engine } from "./behavior-CWhW3oa6.js";
 
 //#region src/gameplay/chase.d.ts
 /**
@@ -154,6 +154,11 @@ declare class FollowCamera extends Behavior {
   smoothing: number;
   deadzone: number;
   override onReady(): void;
+  private shakeMag;
+  private shakeT;
+  private shakeFalloff;
+  /** Kick the camera (impacts, explosions). Composes with the follow. */
+  shake(magnitude: number, seconds?: number): void;
   override update(dt: number): void;
 }
 //#endregion
@@ -528,6 +533,112 @@ declare class ZombieAI extends Behavior {
   private pickGoal;
 }
 //#endregion
+//#region src/gameplay/game-flow.d.ts
+/**
+* Reload the CURRENT scene from its source JSON — fresh nodes, reset physics,
+* rewired input. The restart primitive every game-over screen wants.
+*/
+declare function restartScene(engine: Engine): void;
+type GameFlowState = "playing" | "paused" | "gameover" | "won";
+/**
+* The win/lose/restart state machine 6+ examples hand-rolled as `over`/`win`
+* booleans. Attach to any node (the scene root is natural):
+*
+*   const flow = root.behavior as GameFlow;   // script: { "name": "GameFlow" }
+*   flow.gameOver('YOU DIED');                 // freezes time, sticky banner
+*   flow.win('AREA CLEAR');
+*   flow.pause(); flow.resume();
+*
+* While in `gameover`/`won`, pressing `restartAction` (default action name
+* 'restart' — declare it in the scene input map, or leave undeclared and call
+* `flow.restart()` yourself) reloads the scene from source. Banners render
+* through a `%Banner` UiBanner when one exists; otherwise states are silent
+* (drive your own UI off the `flowChanged` signal).
+*/
+declare class GameFlow extends Behavior {
+  static readonly signals: readonly string[];
+  static readonly props: Record<string, {
+    default: string | boolean;
+  }>;
+  /** Input action that restarts from gameover/won (declare it in `input{}`). */
+  restartAction: string;
+  /** Freeze `engine.timeScale` on gameover/won (banner UI keeps rendering). */
+  freezeOnEnd: boolean;
+  /** Where the flow looks for a UiBanner ('' = never). */
+  bannerPath: string;
+  state: GameFlowState;
+  private frozeScale;
+  gameOver(text?: string, color?: string): void;
+  win(text?: string, color?: string): void;
+  pause(): void;
+  resume(): void;
+  restart(): void;
+  private transition;
+  private freeze;
+  private thaw;
+  override update(): void;
+}
+//#endregion
+//#region src/gameplay/juice.d.ts
+/**
+* Game-feel primitives ("juice"): the weapon cooldown, camera shake, screen
+* flash and hit-stop that action examples kept hand-rolling.
+*/
+/**
+* A fire-rate / ability cooldown — replaces the copy-pasted
+* `this.clock += dt * 1000; if (now > nextFire)` pattern:
+*
+*   private gun = new Cooldown(0.2);
+*   override update(dt: number): void {
+*     this.gun.tick(dt);
+*     if (this.engine.input.isPressed('fire') && this.gun.tryUse()) this.shoot();
+*   }
+*/
+declare class Cooldown {
+  readonly seconds: number;
+  private remaining;
+  constructor(seconds: number);
+  /** Advance time. Call once per update with the frame dt. */
+  tick(dt: number): void;
+  get ready(): boolean;
+  /** 0..1 — how far through the cooldown we are (1 = ready). UiBar-friendly. */
+  get progress(): number;
+  /** Consume if ready. Returns whether the action should fire. */
+  tryUse(): boolean;
+  /** Force-ready (pickups that reset your reload). */
+  reset(): void;
+}
+/**
+* Camera shake as a standalone behavior for cameras WITHOUT another script.
+* (FollowCamera has this built in — one script per node.) Composes with any
+* other position writer by applying only the DELTA of its own offset, so the
+* camera returns exactly to where the other writer left it.
+*
+*   (camera.behavior as CameraShake).shake(8);           // pixels (2D) / meters·100 feel (3D: use ~0.2)
+*/
+declare class CameraShake extends Behavior {
+  static readonly props: Record<string, {
+    default: number;
+  }>;
+  /** Seconds a shake takes to decay to zero. */
+  falloff: number;
+  private magnitude;
+  private t;
+  private prev;
+  shake(magnitude: number, seconds?: number): void;
+  override update(dt: number): void;
+}
+/**
+* Full-screen color flash (damage red, pickup white). DOM overlay above
+* everything; headless no-op. Repeated calls restart the fade.
+*/
+declare function screenFlash(color?: string, opacity?: number, seconds?: number): void;
+/**
+* Hit-stop: freeze game time for `seconds` of REAL time, then restore the
+* previous timeScale. Stacking calls extend the freeze instead of fighting.
+*/
+declare function hitStop(engine: Engine, seconds?: number): void;
+//#endregion
 //#region src/gameplay/index.d.ts
 /** Every built-in gameplay behavior, keyed by its registration name. */
 declare const GAMEPLAY_BEHAVIORS: Readonly<Record<string, BehaviorCtor>>;
@@ -540,4 +651,4 @@ declare function registerGameplayBehaviors(opts?: {
   replace?: boolean;
 }): void;
 //#endregion
-export { Chase, Collector, DamageOnContact, FollowCamera, GAMEPLAY_BEHAVIORS, Health, Interactable, Lifetime, MoveTo, Oscillate, Patrol, Pickup, Projectile, ScoreKeeper, Spawner, Wander, WaveSpawner, ZombieAI, registerGameplayBehaviors };
+export { CameraShake, Chase, Collector, Cooldown, DamageOnContact, FollowCamera, GAMEPLAY_BEHAVIORS, GameFlow, type GameFlowState, Health, Interactable, Lifetime, MoveTo, Oscillate, Patrol, Pickup, Projectile, ScoreKeeper, Spawner, Wander, WaveSpawner, ZombieAI, hitStop, registerGameplayBehaviors, restartScene, screenFlash };

package/dist/gameplay.js

@@ -1,2 +1,2 @@
-import { _ as Health, a as Wander, c as Projectile, d as Oscillate, f as MoveTo, g as DamageOnContact, h as FollowCamera, i as WaveSpawner, l as Pickup, m as Interactable, n as registerGameplayBehaviors, o as Spawner, p as Lifetime, r as ZombieAI, s as ScoreKeeper, t as GAMEPLAY_BEHAVIORS, u as Patrol, v as Collector, y as Chase } from "./gameplay-Ccruc3Wd.js";
-export { Chase, Collector, DamageOnContact, FollowCamera, GAMEPLAY_BEHAVIORS, Health, Interactable, Lifetime, MoveTo, Oscillate, Patrol, Pickup, Projectile, ScoreKeeper, Spawner, Wander, WaveSpawner, ZombieAI, registerGameplayBehaviors };
+import { C as Health, S as DamageOnContact, T as Chase, _ as screenFlash, a as Wander, b as restartScene, c as Projectile, d as Oscillate, f as MoveTo, g as hitStop, h as Cooldown, i as WaveSpawner, l as Pickup, m as CameraShake, n as registerGameplayBehaviors, o as Spawner, p as Lifetime, r as ZombieAI, s as ScoreKeeper, t as GAMEPLAY_BEHAVIORS, u as Patrol, v as Interactable, w as Collector, x as FollowCamera, y as GameFlow } from "./gameplay-CDFgSG6z.js";
+export { CameraShake, Chase, Collector, Cooldown, DamageOnContact, FollowCamera, GAMEPLAY_BEHAVIORS, GameFlow, Health, Interactable, Lifetime, MoveTo, Oscillate, Patrol, Pickup, Projectile, ScoreKeeper, Spawner, Wander, WaveSpawner, ZombieAI, hitStop, registerGameplayBehaviors, restartScene, screenFlash };