incanto 0.4.2 → 0.5.0

package/dist/{create-game-CMS7DiPi.js → create-game-D8UvwXme.js}

@@ -1,14 +1,14 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { _ as registerBehavior, n as loadScene } from "./loader-CGs_G-r0.js";
-import { a as Engine } from "./particle-sim-DYuSUxvK.js";
+import { _ as registerBehavior, n as loadScene } from "./loader-B4OEXDZ8.js";
+import { a as Engine } from "./particle-sim-CFkILGwh.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
-import { r as AudioPlayer } from "./register-BuUV1_KB.js";
+import { s as AudioPlayer } from "./register-Dl_ixIJe.js";
 import { i as resolveRendering, n as attachTouchControls } from "./touch-031PxtCR.js";
-import { n as registerGameplayBehaviors } from "./gameplay-Ccruc3Wd.js";
+import { n as registerGameplayBehaviors } from "./gameplay-CDFgSG6z.js";
 import { t as debugSources } from "./debug-draw-CZmOYjL2.js";
-import { E as PhysicsBody3D, c as ModelInstance3D, k as Node3D, t as registerNodes3D, u as DirectionalLight3D, v as Camera3D } from "./register-02aSywx2.js";
-import { n as enablePhysics3D } from "./physics-3d-CXOBOUKG.js";
-import { ACESFilmicToneMapping, AmbientLight, BufferAttribute, BufferGeometry, Color, DepthTexture, EquirectangularReflectionMapping, FloatType, Fog, LineBasicMaterial, LineSegments, Matrix4, Mesh, PCFShadowMap, PMREMGenerator, PerspectiveCamera, PlaneGeometry, Quaternion, Raycaster, Scene, ShaderMaterial, Vector2, Vector3, WebGLRenderTarget, WebGLRenderer } from "three";
+import { O as PhysicsBody3D, c as ModelInstance3D, d as DirectionalLight3D, j as Node3D, t as registerNodes3D, y as Camera3D } from "./register-DvPHJdVj.js";
+import { n as enablePhysics3D } from "./physics-3d-C58oQzTX.js";
+import { ACESFilmicToneMapping, AmbientLight, BufferAttribute, BufferGeometry, Color, DepthTexture, EquirectangularReflectionMapping, FloatType, Fog, HalfFloatType, LineBasicMaterial, LineSegments, Matrix4, Mesh, PCFShadowMap, PMREMGenerator, PerspectiveCamera, PlaneGeometry, Quaternion, Raycaster, Scene, ShaderMaterial, Vector2, Vector3, WebGLRenderTarget, WebGLRenderer } from "three";
 import { VRMLoaderPlugin, VRMUtils } from "@pixiv/three-vrm";
 import { GLTFLoader } from "three/addons/loaders/GLTFLoader.js";
 import { RGBELoader } from "three/examples/jsm/loaders/RGBELoader.js";
@@ -127,6 +127,122 @@ var AssetStore3D = class {
 	}
 };
 //#endregion
+//#region src/3d/bloom/bloom-composite.ts
+/**
+* HDR bloom post pass:
+*
+*   scene → offscreen HalfFloat target (raw linear HDR — three applies neither
+*     tone mapping nor the sRGB transform when rendering into a target)
+*   bright-pass at HALF resolution (keep only luminance above `threshold`;
+*     with HDR buffers, emissives and sun glints sit above 1.0)
+*   separable 9-tap Gaussian blur (H then V) at half res
+*   composite: scene + glow × strength, THEN the standard postprocessing tail
+*     (ACES tone mapping + linear→sRGB) — skipping that tail is exactly the
+*     dark/oversaturated bug the volumetric-clouds pipeline shipped with.
+*/
+const VERT = `
+varying vec2 vUv;
+void main() {
+  vUv = uv;
+  gl_Position = vec4(position.xy, 0.0, 1.0);
+}
+`;
+const BRIGHT_FRAG = `
+precision highp float;
+varying vec2 vUv;
+uniform sampler2D tScene;
+uniform float uThreshold;
+void main() {
+  vec3 c = texture2D(tScene, vUv).rgb;
+  // HDR luminance knee: the scene buffer is raw linear HDR (tone mapping is
+  // applied later, in the composite), so emissives/sun glints sit ABOVE 1.0 —
+  // keep only the energy above the threshold, in proportion
+  float l = dot(c, vec3(0.2126, 0.7152, 0.0722));
+  float k = max(l - uThreshold, 0.0);
+  gl_FragColor = vec4(c * (k / max(l, 1e-4)), 1.0);
+}
+`;
+const BLUR_FRAG = `
+precision highp float;
+varying vec2 vUv;
+uniform sampler2D tTex;
+uniform vec2 uDir;
+void main() {
+  // 9-tap Gaussian, sigma ~2 texels (same recipe as the cloud blur)
+  vec4 sum = texture2D(tTex, vUv) * 0.227027;
+  sum += texture2D(tTex, vUv + uDir * 1.3846) * 0.3162162;
+  sum += texture2D(tTex, vUv - uDir * 1.3846) * 0.3162162;
+  sum += texture2D(tTex, vUv + uDir * 3.2308) * 0.0702703;
+  sum += texture2D(tTex, vUv - uDir * 3.2308) * 0.0702703;
+  gl_FragColor = sum;
+}
+`;
+const COMPOSITE_FRAG = `
+precision highp float;
+varying vec2 vUv;
+uniform sampler2D tScene;
+uniform sampler2D tBloom;
+uniform float uStrength;
+void main() {
+  vec3 base = texture2D(tScene, vUv).rgb;
+  vec3 glow = texture2D(tBloom, vUv).rgb;
+  gl_FragColor = vec4(base + glow * uStrength, 1.0);
+  // three skips BOTH tone mapping and the output colorspace transform when the
+  // scene renders into an offscreen target — the buffer holds raw linear HDR.
+  // This is the final to-screen pass, so apply the standard postprocessing
+  // tail here (ACES then linear→sRGB); without it the frame comes out dark
+  // and oversaturated (the volumetric-clouds pipeline bug, root-caused).
+  #include <tonemapping_fragment>
+  #include <colorspace_fragment>
+}
+`;
+function quad(fragment, uniforms) {
+	const material = new ShaderMaterial({
+		vertexShader: VERT,
+		fragmentShader: fragment,
+		depthTest: false,
+		depthWrite: false,
+		uniforms
+	});
+	const mesh = new Mesh(new PlaneGeometry(2, 2), material);
+	mesh.frustumCulled = false;
+	return mesh;
+}
+/** Half-res bright-pass quad — keeps only pixels brighter than the threshold. */
+function createBloomBrightQuad() {
+	const mesh = quad(BRIGHT_FRAG, {
+		tScene: { value: null },
+		uThreshold: { value: 1 }
+	});
+	return {
+		mesh,
+		uniforms: mesh.material.uniforms
+	};
+}
+/** Separable-blur quad (run twice: uDir = (1/w, 0) then (0, 1/h)). */
+function createBloomBlurQuad() {
+	const mesh = quad(BLUR_FRAG, {
+		tTex: { value: null },
+		uDir: { value: new Vector2() }
+	});
+	return {
+		mesh,
+		uniforms: mesh.material.uniforms
+	};
+}
+/** Full-res composite quad — adds the blurred glow over the scene. */
+function createBloomCompositeQuad() {
+	const mesh = quad(COMPOSITE_FRAG, {
+		tScene: { value: null },
+		tBloom: { value: null },
+		uStrength: { value: .85 }
+	});
+	return {
+		mesh,
+		uniforms: mesh.material.uniforms
+	};
+}
+//#endregion
 //#region src/3d/clouds/clouds-composite.ts
 /**
 * Volumetric clouds — a raymarched cloud DECK the camera flies through, drawn as
@@ -446,6 +562,7 @@ const CLOUD_KEYS = [
 	"speed",
 	"scale"
 ];
+const BLOOM_KEYS = ["threshold", "strength"];
 const SHADOW_KEYS = ["mapSize", "radius"];
 const SHADOW_MAP_SIZES = [1024, 2048];
 const DEFAULT_TURBIDITY = 2;
@@ -462,6 +579,7 @@ function parseEnvironment3D(env) {
 		sky: parseSky(env?.sky),
 		fog: parseFog(env?.fog, env?.sky !== void 0),
 		clouds: parseClouds(env?.clouds),
+		bloom: parseBloom(env?.bloom),
 		shadows: parseShadows(env?.shadows)
 	};
 }
@@ -616,6 +734,23 @@ function parseClouds(value) {
 		scale
 	};
 }
+function parseBloom(value) {
+	if (value === void 0) return null;
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new IncantoError("BAD_FORMAT", `environment.bloom must be an object ({ threshold?, strength? }), got ${JSON.stringify(value)}.`, { prop: "bloom" });
+	const b = value;
+	for (const key of Object.keys(b)) if (!BLOOM_KEYS.includes(key)) throw new IncantoError("BAD_FORMAT", `environment.bloom has unknown key '${key}'. Valid keys: [${BLOOM_KEYS.join(", ")}].`, {
+		prop: "bloom",
+		validOptions: BLOOM_KEYS
+	});
+	const threshold = numberOr(b.threshold, 1, "bloom.threshold");
+	if (threshold < 0 || threshold > 8) throw new IncantoError("BAD_FORMAT", `environment.bloom.threshold must be in [0, 8] (linear-HDR luminance; 1 = white), got ${threshold}.`, { prop: "bloom" });
+	const strength = numberOr(b.strength, .8, "bloom.strength");
+	if (strength < 0) throw new IncantoError("BAD_FORMAT", `environment.bloom.strength must be >= 0, got ${strength}.`, { prop: "bloom" });
+	return {
+		threshold,
+		strength
+	};
+}
 function parseShadows(value) {
 	if (value === void 0) return null;
 	if (value === false) return false;
@@ -730,6 +865,10 @@ var Environment3D = class {
 	get clouds() {
 		return this.config.clouds;
 	}
+	/** Parsed bloom config, or null when no bloom pass is declared. */
+	get bloom() {
+		return this.config.bloom;
+	}
 	/** The live scene fog (color/near/far) the cloud composite fades into, or null. */
 	get sceneFog() {
 		return this.scene.fog instanceof Fog ? this.scene.fog : null;
@@ -1228,6 +1367,15 @@ var Renderer3D = class {
 	cloudsBlurUniforms = null;
 	cloudsCompositeScene = null;
 	cloudsCompositeUniforms = null;
+	bloomTarget = null;
+	bloomBrightTarget = null;
+	bloomBlurTarget = null;
+	bloomBrightScene = null;
+	bloomBrightUniforms = null;
+	bloomBlurScene = null;
+	bloomBlurUniforms = null;
+	bloomCompositeScene = null;
+	bloomCompositeUniforms = null;
 	constructor(opts) {
 		this.canvas = opts.canvas;
 		this.engine = opts.engine;
@@ -1334,11 +1482,80 @@ var Renderer3D = class {
 		}
 		this.environment.applyUnderwater(underwater);
 		const clouds = this.environment.clouds;
+		const bloom = this.environment.bloom;
 		if (underwater?.caustics.enabled) this.renderWithCaustics(activeCamera, underwater);
 		else if (clouds && !underwater) this.renderWithClouds(activeCamera, clouds, threeLight);
+		else if (bloom && !underwater) this.renderWithBloom(activeCamera, bloom);
 		else this.webgl.render(this.threeScene, activeCamera);
 	}
 	/**
+	* Bloom post pass (only when `environment.bloom` is declared). LDR and safe:
+	*   1. scene → full-res offscreen (tone-mapped exactly like direct output)
+	*   2. bright-pass at HALF res (keep pixels above threshold)
+	*   3. separable Gaussian blur (H, V) at half res
+	*   4. composite scene + glow×strength → screen (pure ADD — never re-touches
+	*      the scene's tone; the clouds pipeline taught us that lesson)
+	* Caustics/clouds paths take precedence (composite pipelines don't stack yet).
+	*/
+	renderWithBloom(camera, bloom) {
+		const buf = this.webgl.getDrawingBufferSize(sizeScratch);
+		const w = Math.max(1, buf.x);
+		const h = Math.max(1, buf.y);
+		const hw = Math.max(1, Math.ceil(w / 2));
+		const hh = Math.max(1, Math.ceil(h / 2));
+		if (this.bloomTarget && (this.bloomTarget.width !== w || this.bloomTarget.height !== h)) {
+			this.bloomTarget.dispose();
+			this.bloomTarget = null;
+			this.bloomBrightTarget?.dispose();
+			this.bloomBrightTarget = null;
+			this.bloomBlurTarget?.dispose();
+			this.bloomBlurTarget = null;
+		}
+		if (!this.bloomTarget) {
+			this.bloomTarget = new WebGLRenderTarget(w, h, { type: HalfFloatType });
+			this.bloomBrightTarget = new WebGLRenderTarget(hw, hh, { type: HalfFloatType });
+			this.bloomBlurTarget = new WebGLRenderTarget(hw, hh, { type: HalfFloatType });
+		}
+		if (!this.bloomBrightScene) {
+			const bright = createBloomBrightQuad();
+			this.bloomBrightScene = new Scene();
+			this.bloomBrightScene.add(bright.mesh);
+			this.bloomBrightUniforms = bright.uniforms;
+			const blur = createBloomBlurQuad();
+			this.bloomBlurScene = new Scene();
+			this.bloomBlurScene.add(blur.mesh);
+			this.bloomBlurUniforms = blur.uniforms;
+			const composite = createBloomCompositeQuad();
+			this.bloomCompositeScene = new Scene();
+			this.bloomCompositeScene.add(composite.mesh);
+			this.bloomCompositeUniforms = composite.uniforms;
+		}
+		const brightTarget = this.bloomBrightTarget;
+		const blurTarget = this.bloomBlurTarget;
+		this.webgl.setRenderTarget(this.bloomTarget);
+		this.webgl.render(this.threeScene, camera);
+		const bu = this.bloomBrightUniforms;
+		bu.tScene.value = this.bloomTarget.texture;
+		bu.uThreshold.value = bloom.threshold;
+		this.webgl.setRenderTarget(brightTarget);
+		this.webgl.render(this.bloomBrightScene, camera);
+		const blu = this.bloomBlurUniforms;
+		blu.tTex.value = brightTarget.texture;
+		blu.uDir.value.set(1 / hw, 0);
+		this.webgl.setRenderTarget(blurTarget);
+		this.webgl.render(this.bloomBlurScene, camera);
+		blu.tTex.value = blurTarget.texture;
+		blu.uDir.value.set(0, 1 / hh);
+		this.webgl.setRenderTarget(brightTarget);
+		this.webgl.render(this.bloomBlurScene, camera);
+		const cu = this.bloomCompositeUniforms;
+		cu.tScene.value = this.bloomTarget.texture;
+		cu.tBloom.value = brightTarget.texture;
+		cu.uStrength.value = bloom.strength;
+		this.webgl.setRenderTarget(null);
+		this.webgl.render(this.bloomCompositeScene, camera);
+	}
+	/**
 	* Volumetric cloud pass (only when `environment.clouds` is declared — scenes
 	* without it render exactly as before, zero cost). Three steps:
 	*   1. scene → full-res offscreen target (color + depth)
@@ -1564,10 +1781,16 @@ var Renderer3D = class {
 		this.cloudsTarget?.dispose();
 		this.cloudsHalfTarget?.dispose();
 		this.cloudsBlurTarget?.dispose();
+		this.bloomTarget?.dispose();
+		this.bloomBrightTarget?.dispose();
+		this.bloomBlurTarget?.dispose();
 		for (const s of [
 			this.cloudsScene,
 			this.cloudsBlurScene,
-			this.cloudsCompositeScene
+			this.cloudsCompositeScene,
+			this.bloomBrightScene,
+			this.bloomBlurScene,
+			this.bloomCompositeScene
 		]) {
 			const m = s?.children[0];
 			m?.geometry?.dispose();

package/dist/debug.d.ts

@@ -1,4 +1,4 @@
-import { C as RendererStats, k as LogLevel, v as Engine } from "./behavior-BAQq7HGM.js";
+import { C as RendererStats, k as LogLevel, v as Engine } from "./behavior-CWhW3oa6.js";
 
 //#region src/debug/panel.d.ts
 /** Minimal document surface the overlay needs (injectable for tests). */

package/dist/{duplicate-DP2WPYom.js → duplicate-BEvGBtb_.js}

@@ -1,4 +1,4 @@
-import { i as serializeNode, t as buildNodeJson } from "./loader-CGs_G-r0.js";
+import { i as serializeNode, t as buildNodeJson } from "./loader-B4OEXDZ8.js";
 //#region src/core/scene/duplicate.ts
 function stripUids(json) {
 	const { uid: _uid, ...rest } = json;

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 };