incanto 0.64.1 → 0.66.0

package/dist/{gameplay-CLgFdkh5.js → gameplay-D1RADWu3.js}

@@ -1,7 +1,7 @@
-import { O as Node, P as Behavior, _ as SaveSlots, k as diagnose, n as loadScene, w as effectiveOrder, z as registerBehavior } from "./loader-zDynoew_.js";
+import { O as Node, P as Behavior, _ as SaveSlots, k as diagnose, n as loadScene, w as effectiveOrder, z as registerBehavior } from "./loader-lQDCwNag.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
 import { t as jsonClone } from "./json-CwwhxQgb.js";
-import { t as duplicateNode } from "./duplicate-BOOKmkQ7.js";
+import { t as duplicateNode } from "./duplicate-CqSAtdrh.js";
 import { Color, CubeCamera, DepthTexture, DoubleSide, Euler, FloatType, Frustum, HalfFloatType, LinearMipmapLinearFilter, MathUtils, Matrix4, Mesh, MeshDepthMaterial, Object3D, PerspectiveCamera, Plane, PlaneGeometry, Quaternion, ShaderMaterial, Sphere, Vector2, Vector3, Vector4, WebGLCubeRenderTarget, WebGLRenderTarget } from "three";
 //#region src/3d/frustum.ts
 const scratchFrustum = new Frustum();
@@ -2534,6 +2534,36 @@ var StaticBody3D = class extends PhysicsBody3D {
 /** Sensor volume emitting `triggerEnter(other)` / `triggerExit(other)`. */
 var Area3D = class extends PhysicsBody3D {
 	static typeName = "Area3D";
+	/**
+	* Who is inside RIGHT NOW — the standing answer behind the enter/exit pair.
+	*
+	* Enter and exit tell you about crossings; a pressure plate, a capture point,
+	* a "how many enemies are in the blast" count and a shop trigger all want
+	* OCCUPANCY. Without this every one of them kept a private `Set` fed by the
+	* two signals, and had to guard it, because a body that is teleported or
+	* freed inside a sensor does not reliably announce its exit. Physics already
+	* knows; now it says.
+	*
+	* ```ts
+	* const load = this.area.overlapping()
+	*   .reduce((kg, b) => kg + ((b as RigidBody3D).mass ?? 0), 0);
+	* door.open = load >= 60;
+	* ```
+	*
+	* It reports everything the solver says is inside, STATIC WORLD INCLUDED — a
+	* plate laid into the floor genuinely contains the floor. Pass a group to ask
+	* the question you usually mean:
+	*
+	* ```ts
+	* area.overlapping('crate')   // only things tagged `crate`
+	* ```
+	*
+	* Empty in a scene with no physics world.
+	*/
+	overlapping(group) {
+		const all = this._physics?.overlapping(this) ?? [];
+		return group === void 0 ? all : all.filter((n) => n.isInGroup(group));
+	}
 };
 /** Dynamic simulated body. */
 var RigidBody3D = class extends PhysicsBody3D {
@@ -2548,6 +2578,11 @@ var RigidBody3D = class extends PhysicsBody3D {
 			0,
 			0,
 			0
+		] },
+		angularVelocity: { default: [
+			0,
+			0,
+			0
 		] }
 	};
 	mass = 1;
@@ -2561,6 +2596,18 @@ var RigidBody3D = class extends PhysicsBody3D {
 		0,
 		0
 	];
+	/**
+	* rad/s about each world axis. Read back every step; write to spin.
+	*
+	* A puzzle builder could neither launch a spinning body nor read how fast a
+	* lever was swinging — only its angle, differenced by hand — because this had
+	* no counterpart to `linearVelocity`. `fixedRotation` pins it at zero.
+	*/
+	angularVelocity = [
+		0,
+		0,
+		0
+	];
 	/** @internal set by Physics3D */
 	_physics3d = null;
 	/** World-space impulse (kg·m/s) — the floating-capsule controller's verb. */
@@ -4360,6 +4407,65 @@ function firstWater(node) {
 	return null;
 }
 //#endregion
+//#region src/gameplay/face-travel.ts
+const RAD2DEG = 180 / Math.PI;
+/**
+* Turn a node to face the direction something is travelling.
+*
+* `CharacterController3D` does this for the PLAYER (`skinPath`/`turnSpeed`) and
+* nothing did it for anyone else — so every game with a patrolling or chasing
+* enemy hand-wrote the same six lines, against a formula the docs simultaneously
+* teach and warn about: `incanto-3d-character.md` calls the wrong version of it
+* "the #1 recurring bug" (a character that runs BACKWARDS, showing you its back
+* while charging at you). This is the right version, once, in the engine.
+*
+* The rule, for 3D: the model is **+Z-FORWARD**, so `yaw = atan2(dx, dz)` — x
+* and z, never y, and NO 180° added. The 180° is only the at-rest mount for a
+* behind-the-shoulder camera, not a facing formula.
+*
+* In 2D `rotation` is a scalar and the plane is x/y, so it is `atan2(dy, dx)` —
+* correct for the top-down games that use `Patrol`/`Chase`. A platformer faces
+* with `flipX` instead and should not set `facePath`.
+*
+* `turnSpeed` is rad/s, the same units and the same shortest-arc, rate-limited
+* step the controller uses; at the default 100 it is effectively an instant
+* snap. A zero-length direction leaves the rotation alone — a node that is not
+* moving has nothing to face.
+*/
+function faceTravel(target, dir, dt, turnSpeed) {
+	const spatial = target;
+	const rot = spatial.rotation;
+	const is3d = Array.isArray(rot);
+	const [a, b] = is3d ? [dir[0] ?? 0, dir[2] ?? 0] : [dir[0] ?? 0, dir[1] ?? 0];
+	if (Math.hypot(a, b) < 1e-6) return;
+	const want = (is3d ? Math.atan2(a, b) : Math.atan2(b, a)) * RAD2DEG;
+	const current = is3d ? rot[1] ?? 0 : rot ?? 0;
+	let delta = (want - current + 540) % 360 - 180;
+	const step = turnSpeed * dt * RAD2DEG;
+	if (Math.abs(delta) > step) delta = Math.sign(delta) * step;
+	const next = current + delta;
+	if (is3d) spatial.rotation = [
+		rot[0] ?? 0,
+		next,
+		rot[2] ?? 0
+	];
+	else spatial.rotation = next;
+}
+/** The shared `facePath`/`turnSpeed` prop pair for the AI movement behaviors. */
+const FACING_PROPS = {
+	/**
+	* Node path of the thing to TURN toward the travel direction — usually the
+	* `ModelInstance3D` skin ('../Skin'). Empty (default) turns nothing, so a
+	* scene that never asks is unchanged.
+	*/
+	facePath: {
+		default: "",
+		nodePath: true
+	},
+	/** Turn rate in rad/s; 100 (default) is an instant snap, like the controller. */
+	turnSpeed: { default: 100 }
+};
+//#endregion
 //#region src/gameplay/move-body.ts
 function moveBody(node, to, dt) {
 	const body = node;
@@ -4521,6 +4627,8 @@ function localFromWorld(node, world) {
 *   it leaves), so wire it to an attack.
 * - `loseRange` (>0) gives up the chase when the target gets that far away,
 *   emitting `lostTarget` once.
+* - `facePath`/`turnSpeed` turn a skin toward the direction of travel — the job
+*   `CharacterController3D` does for the player and nobody did for an NPC.
 * - `moveParent` (default false) moves the parent node instead of this one.
 *   A node carries ONE behavior, so an enemy whose ROOT must hold `Health`
 *   (e.g. for `Health.freeOnDeath` clone-safe cleanup) puts `Chase` on a CHILD
@@ -4542,7 +4650,8 @@ var Chase = class extends Behavior {
 		/** Give up (emit lostTarget) beyond this distance (0 = never lose). */
 		loseRange: { default: 0 },
 		/** Move the parent node instead of this one (AI-on-a-child pattern). */
-		moveParent: { default: false }
+		moveParent: { default: false },
+		...FACING_PROPS
 	};
 	static signals = ["reachedTarget", "lostTarget"];
 	target = "";
@@ -4550,6 +4659,8 @@ var Chase = class extends Behavior {
 	stopRange = 0;
 	loseRange = 0;
 	moveParent = false;
+	facePath = "";
+	turnSpeed = 100;
 	inRange = false;
 	lost = false;
 	onReady() {
@@ -4586,8 +4697,13 @@ var Chase = class extends Behavior {
 		}
 		this.inRange = false;
 		const step = Math.min(this.speed * dt, this.stopRange > 0 ? d - this.stopRange : d);
+		const from = [...mover.position];
 		const { position } = moveToward(mover.position, target.position, Math.max(0, step));
 		moveBody(mover, position, dt);
+		if (this.facePath !== "") {
+			const skin = this.node.getNodeOrNull(this.facePath);
+			if (skin) faceTravel(skin, position.map((v, i) => v - (from[i] ?? 0)), dt, this.turnSpeed);
+		}
 	}
 };
 //#endregion
@@ -4621,9 +4737,7 @@ var Clickable = class extends Behavior {
 		/** Mouse button: 0 left, 1 middle, 2 right. */
 		button: { default: 0 },
 		/** Ignore clicks further away than this (0 = any distance). */
-		maxDistance: { default: 0 },
-		/** Stop responding without removing the behavior. */
-		enabled: { default: true }
+		maxDistance: { default: 0 }
 	};
 	static signals = [
 		"clicked",
@@ -4632,20 +4746,19 @@ var Clickable = class extends Behavior {
 	];
 	button = 0;
 	maxDistance = 0;
-	enabled = true;
 	/** True while the cursor is over this node — read it to tint a hover state. */
 	hovering = false;
 	pressedHere = false;
 	update() {
 		const engine = this.node.tree?.engine;
-		if (!engine || !this.enabled) return;
+		if (!engine) return;
 		const picker = engine.picker;
 		const pointer = engine.input.pointerPosition();
 		if (!picker || !pointer) {
 			if (this.hovering) this.setHover(false);
 			return;
 		}
-		const hit = picker(pointer.x, pointer.y);
+		const hit = engine.pickAt(pointer.x, pointer.y);
 		const over = hit !== null && this.isSelfOrDescendant(hit) && this.withinRange(hit);
 		if (over !== this.hovering) this.setHover(over);
 		if (engine.input.mouseJustPressed(this.button)) this.pressedHere = over;
@@ -4715,6 +4828,104 @@ group: { default: "player" } };
 	}
 };
 //#endregion
+//#region src/gameplay/currency.ts
+/**
+* Money. Earn it, spend it, and refuse what you cannot afford.
+*
+* `ScoreKeeper` is the closest thing the library had and it is a SCORE: it
+* counts up, it has no spend, no affordability question, and its counter is
+* already wired to the win condition. So a tower defense built on 0.65.0 wrote
+* its own wallet — and so does every shop, every build mode, every upgrade tree
+* and every economy game.
+*
+* `spend` is the whole point: it returns whether it went through, and emits
+* `refused` when it did not, so "you cannot afford that" is a wire rather than
+* a comparison every caller repeats and one caller forgets.
+*/
+var Currency = class extends Behavior {
+	static props = {
+		/** What you start with. */
+		amount: { default: 0 },
+		/** Ceiling (0 = none). */
+		max: { default: 0 }
+	};
+	static signals = [
+		"changed",
+		"earned",
+		"spent",
+		"refused"
+	];
+	amount = 0;
+	max = 0;
+	/** Can this be paid right now? */
+	canAfford(cost) {
+		return cost <= this.amount;
+	}
+	/** Pay `cost` if it is there. Returns whether it went through. */
+	spend(cost) {
+		if (!this.canAfford(cost)) {
+			this.emit("refused", cost);
+			return false;
+		}
+		this.amount -= cost;
+		this.emit("spent", cost);
+		this.emit("changed", this.amount);
+		return true;
+	}
+	/** Take payment in. */
+	earn(gain) {
+		this.amount = this.max > 0 ? Math.min(this.max, this.amount + gain) : this.amount + gain;
+		this.emit("earned", gain);
+		this.emit("changed", this.amount);
+	}
+	/** Set it outright (a shop that grants, a cheat, a restore). */
+	setAmount(next) {
+		this.amount = this.max > 0 ? Math.min(this.max, next) : next;
+		this.emit("changed", this.amount);
+	}
+	serialize() {
+		return { amount: this.amount };
+	}
+	deserialize(data) {
+		const d = data;
+		if (typeof d.amount === "number") this.amount = d.amount;
+	}
+};
+//#endregion
+//#region src/gameplay/free-target.ts
+/**
+* Free the ENTITY a despawning behavior belongs to, not just the node it sits on.
+*
+* `Lifetime` and `DamageOnContact` both remove their own node, which is right
+* when the behavior IS the thing. It is wrong for the composition the docs
+* teach: a node carries ONE script, so a bullet that both hurts and expires must
+* put those on CHILD nodes — and then each child quietly removed itself while
+* the bullet flew on forever, leaking a node per shot.
+*
+* `freeParent: true` is the other half. It is the same escape hatch the movement
+* behaviors call `moveParent`, named the same way for the same reason.
+*/
+function freeOwner(behavior, freeParent, who) {
+	if (!freeParent) {
+		behavior.node.queueFree();
+		return;
+	}
+	const parent = behavior.node.parent;
+	if (!parent) {
+		diagnose(behavior.node.tree?.engine ?? null, "error", `[incanto] ${who} on '${behavior.node.getPath()}': "freeParent" is set and this node has no parent to free — it is the scene root. Nothing was removed. Drop the prop, or move this behavior onto a child of the thing you meant to despawn.`);
+		return;
+	}
+	parent.queueFree();
+}
+/** The shared prop, so both behaviors declare it identically. */
+const FREE_PARENT_PROP = { 
+/**
+* Free this node's PARENT instead of this node — the composition where a
+* bullet carries `Projectile` and its children carry the damage and the
+* timer. Without it each child removes only itself and the bullet leaks.
+*/
+freeParent: { default: false } };
+//#endregion
 //#region src/gameplay/health.ts
 /**
 * Hit points with regeneration and post-hit invulnerability (i-frames) —
@@ -4905,7 +5116,9 @@ function onTriggerEnter(behavior, fn) {
 * - `repeatEvery` (seconds, 0 = off) re-damages targets that STAY overlapped —
 *   lava pools, poison clouds, an enemy standing on you. Contact events fire
 *   only on entry/exit; this is the "and it keeps hurting" knob.
-* - `destroySelf` frees the hazard after a hit (single-use projectiles).
+* - `destroySelf` frees the hazard after a hit (single-use projectiles), and
+*   `freeParent` makes that free the PARENT — a bullet whose hitbox is a child,
+*   which is the only shape a node-carries-one-script engine allows.
 *
 * SCORING PATTERN (clone-safe): wire the KILLER's `dealtDamage` →
 * `ScoreKeeper.addScore`. The weapon is usually a non-cloned node (it lives on
@@ -4923,7 +5136,8 @@ var DamageOnContact = class extends Behavior {
 		/** Re-damage targets still overlapping every N seconds (0 = entry only). */
 		repeatEvery: { default: 0 },
 		/** queueFree() this node after the first successful hit. */
-		destroySelf: { default: false }
+		destroySelf: { default: false },
+		...FREE_PARENT_PROP
 	};
 	static signals = ["dealtDamage"];
 	amount = 10;
@@ -4931,6 +5145,7 @@ var DamageOnContact = class extends Behavior {
 	oncePerTarget = true;
 	repeatEvery = 0;
 	destroySelf = false;
+	freeParent = false;
 	hit = /* @__PURE__ */ new WeakSet();
 	/** Targets currently overlapping → seconds until their next repeat tick. */
 	inside = /* @__PURE__ */ new Map();
@@ -4966,7 +5181,7 @@ var DamageOnContact = class extends Behavior {
 		if (this.oncePerTarget) this.hit.add(other);
 		found.health.damage(this.amount);
 		this.emit("dealtDamage", this.amount, found.owner);
-		if (this.destroySelf) this.node.queueFree();
+		if (this.destroySelf) freeOwner(this, this.freeParent, "DamageOnContact");
 	}
 };
 /**
@@ -5080,6 +5295,109 @@ function phaseOf(hour) {
 	return "dusk";
 }
 //#endregion
+//#region src/gameplay/face-target.ts
+/**
+* Turn toward the nearest thing in a group, and say when you are on it.
+*
+* A turret is the shape every tower defense, sentry gun, security camera and
+* idle-NPC-that-watches-you needs, and it could not be composed. `Chase`
+* already finds the nearest target and turns toward it — and then MOVES, which
+* is the one thing a turret must not do; `Patrol`/`Chase`'s `facePath` only
+* turns as a side effect of locomotion, so a stationary node cannot use it.
+* A tower defense built on 0.65.0 hand-wrote acquisition (~20 lines) and
+* turn-and-gate-the-shot (~15) because of that.
+*
+* `aimed` fires when the facing settles onto the target and `lostAim` when it
+* comes off, so "only fire while actually pointed at it" is a wire rather than
+* an angle comparison you write yourself.
+*/
+var FaceTarget = class extends Behavior {
+	static props = {
+		/** Group to acquire from — the nearest live member wins. */
+		targetGroup: {
+			default: "",
+			required: true
+		},
+		/** Only acquire within this distance (0 = anywhere). */
+		range: { default: 0 },
+		/** Node to TURN (usually a skin); empty turns this behavior's own node. */
+		facePath: {
+			default: "",
+			nodePath: true
+		},
+		/** Turn rate rad/s; 100 is an instant snap, as on the controller. */
+		turnSpeed: { default: 6 },
+		/** Degrees of slop that still counts as pointed at it. */
+		aimTolerance: { default: 6 }
+	};
+	static signals = [
+		"acquired",
+		"lostTarget",
+		"aimed",
+		"lostAim"
+	];
+	targetGroup = "";
+	range = 0;
+	facePath = "";
+	turnSpeed = 6;
+	aimTolerance = 6;
+	/** The node currently being tracked, or null. */
+	target = null;
+	/** True while the facing is within `aimTolerance` of the target. */
+	onTarget = false;
+	onReady() {
+		if (this.targetGroup === "") throw new IncantoError("PROP_TYPE_MISMATCH", `FaceTarget on '${this.node.getPath()}': "targetGroup" is required — it is the group this turret acquires from.`, { prop: "targetGroup" });
+	}
+	update(dt) {
+		const self = this.node;
+		if (!hasPosition$1(self)) return;
+		const found = this.nearest();
+		if (found !== this.target) {
+			this.target = found;
+			this.emit(found ? "acquired" : "lostTarget", found);
+			if (!found) this.setAim(false);
+		}
+		if (!found) return;
+		const turret = this.facePath === "" ? self : this.node.getNodeOrNull(this.facePath);
+		if (!turret) return;
+		const dir = found.position.map((v, i) => v - (self.position[i] ?? 0));
+		faceTravel(turret, dir, dt, this.turnSpeed);
+		this.setAim(this.pointedAt(turret, dir));
+	}
+	nearest() {
+		const self = this.node;
+		let best = null;
+		let bestD = Number.POSITIVE_INFINITY;
+		for (const candidate of this.node.tree?.getNodesInGroup(this.targetGroup) ?? []) {
+			if (!hasPosition$1(candidate)) continue;
+			const d = Math.hypot(...candidate.position.map((v, i) => v - (self.position[i] ?? 0)));
+			if (this.range > 0 && d > this.range) continue;
+			if (d < bestD) {
+				bestD = d;
+				best = candidate;
+			}
+		}
+		return best;
+	}
+	/** Is the turret's forward within tolerance of the direction to the target? */
+	pointedAt(turret, dir) {
+		const rot = turret.rotation;
+		const is3d = Array.isArray(rot);
+		const [a, b] = is3d ? [dir[0] ?? 0, dir[2] ?? 0] : [dir[0] ?? 0, dir[1] ?? 0];
+		const len = Math.hypot(a, b);
+		if (len < 1e-6) return true;
+		const yaw = (is3d ? rot[1] ?? 0 : rot ?? 0) * Math.PI / 180;
+		const fx = is3d ? Math.sin(yaw) : Math.cos(yaw);
+		const fy = is3d ? Math.cos(yaw) : Math.sin(yaw);
+		return (fx * a + fy * b) / len >= Math.cos(this.aimTolerance * Math.PI / 180);
+	}
+	setAim(on) {
+		if (on === this.onTarget) return;
+		this.onTarget = on;
+		this.emit(on ? "aimed" : "lostAim", this.target);
+	}
+};
+//#endregion
 //#region src/gameplay/float-away.ts
 /**
 * Rise, fade, and be gone — the second half of a damage number.
@@ -5714,6 +6032,10 @@ const hitStops = /* @__PURE__ */ new Map();
 * pickups that vanish. Accumulates `dt`; on elapse emits `expired` then
 * `queueFree()`s its node.
 *
+* `freeParent: true` frees the node's PARENT instead — the shape a bullet needs,
+* since a node carries ONE script so `Projectile`, the damage and the timer have
+* to live on separate nodes.
+*
 * With `startOnSignal: true` the countdown is armed manually via `startTimer()`
 * (wire a signal → `startTimer`), so the lifetime begins on an event rather
 * than at spawn.
@@ -5723,11 +6045,13 @@ var Lifetime = class extends Behavior {
 		/** Seconds before the node frees itself. */
 		seconds: { default: 1 },
 		/** Defer the countdown until `startTimer()` is called (default: start at ready). */
-		startOnSignal: { default: false }
+		startOnSignal: { default: false },
+		...FREE_PARENT_PROP
 	};
 	static signals = ["expired"];
 	seconds = 1;
 	startOnSignal = false;
+	freeParent = false;
 	elapsed = 0;
 	running = false;
 	fired = false;
@@ -5748,7 +6072,7 @@ var Lifetime = class extends Behavior {
 			this.fired = true;
 			this.running = false;
 			this.emit("expired");
-			this.node.queueFree();
+			freeOwner(this, this.freeParent, "Lifetime");
 		}
 	}
 };
@@ -6004,6 +6328,13 @@ function distanceBetween(a, b) {
 *
 * - `loop` (default) — after the last point, head back to the first.
 * - `mode: 'pingpong'` — reverse direction at each end instead of wrapping.
+* - `moveParent` (default false) moves the parent node instead of this one,
+*   exactly as `Chase` does. A node carries ONE behavior, so a guard that must
+*   patrol AND hold `Health` on its body puts `Patrol` on a CHILD. Without
+*   this the patrolling body had to carry `Patrol` itself and could hold
+*   nothing else — so a patrolling enemy could not be hurt.
+* - `facePath`/`turnSpeed` turn a skin toward the direction of travel, the job
+*   `CharacterController3D` does for the player and nobody did for an NPC.
 */
 var Patrol = class extends Behavior {
 	static props = {
@@ -6022,7 +6353,10 @@ var Patrol = class extends Behavior {
 			options: ["loop", "pingpong"]
 		},
 		/** Seconds to wait at each reached point before continuing. */
-		pauseAt: { default: 0 }
+		pauseAt: { default: 0 },
+		/** Move the parent node instead of this one (AI-on-a-child pattern). */
+		moveParent: { default: false },
+		...FACING_PROPS
 	};
 	static signals = ["reachedPoint"];
 	points = [];
@@ -6030,33 +6364,53 @@ var Patrol = class extends Behavior {
 	loop = true;
 	mode = "loop";
 	pauseAt = 0;
+	moveParent = false;
+	facePath = "";
+	turnSpeed = 100;
 	index = 0;
 	direction = 1;
 	pauseTimer = 0;
 	onReady() {
 		if (!Array.isArray(this.points) || this.points.length === 0) throw new IncantoError("PROP_TYPE_MISMATCH", `Patrol on '${this.node.getPath()}': "points" must be a non-empty array of position arrays or node paths.`, { prop: "points" });
 		if (this.mode !== "loop" && this.mode !== "pingpong") throw new IncantoError("PROP_TYPE_MISMATCH", `Patrol on '${this.node.getPath()}': "mode" must be 'loop' or 'pingpong', got '${this.mode}'.`, { prop: "mode" });
-		requirePosition(this);
+		if (this.moveParent) {
+			const parent = this.node.parent;
+			if (!parent || !hasPosition$1(parent)) throw new IncantoError("PROP_TYPE_MISMATCH", `Patrol on '${this.node.getPath()}': "moveParent" needs a spatial parent (a Node2D/Node3D) to move. '${this.node.name}' has none.`, {
+				prop: "moveParent",
+				path: this.node.getPath()
+			});
+		} else requirePosition(this);
 	}
 	update(dt) {
 		if (this.pauseTimer > 0) {
 			this.pauseTimer = Math.max(0, this.pauseTimer - dt);
 			return;
 		}
-		const node = this.node;
+		const mover = this.moveParent ? this.node.parent : this.node;
+		if (!mover || !hasPosition$1(mover)) return;
+		const node = mover;
 		const target = this.pointAt(this.index);
 		if (!target) {
 			this.reportDeadWaypoint(this.index);
 			return;
 		}
+		const from = [...node.position];
 		const { position, reached } = moveToward(node.position, target, this.speed * dt);
 		moveBody(node, position, dt);
+		this.face(from, position, dt);
 		if (reached) {
 			this.emit("reachedPoint", this.index);
 			this.advance();
 			if (this.pauseAt > 0) this.pauseTimer = this.pauseAt;
 		}
 	}
+	/** Turn the skin toward the step just taken. */
+	face(from, to, dt) {
+		if (this.facePath === "") return;
+		const skin = this.node.getNodeOrNull(this.facePath);
+		if (!skin) return;
+		faceTravel(skin, to.map((v, i) => v - (from[i] ?? 0)), dt, this.turnSpeed);
+	}
 	/** Waypoints already reported dead, so a per-frame stall says it once. */
 	reportedDead = /* @__PURE__ */ new Set();
 	/**
@@ -7006,6 +7360,7 @@ const GAMEPLAY_BEHAVIORS = {
 	Health,
 	Lifetime,
 	ScoreKeeper,
+	Currency,
 	Pickup,
 	Collector,
 	DamageOnContact,
@@ -7015,6 +7370,7 @@ const GAMEPLAY_BEHAVIORS = {
 	FollowCamera,
 	Patrol,
 	Chase,
+	FaceTarget,
 	Wander,
 	ZombieAI,
 	MoveTo,
@@ -7035,4 +7391,4 @@ function registerGameplayBehaviors(opts) {
 	for (const [name, ctor] of Object.entries(GAMEPLAY_BEHAVIORS)) registerBehavior(name, ctor, { replace });
 }
 //#endregion
-export { Health as A, CharacterBody3D as B, restartScene as C, DayNight as D, FloatAway as E, Water3D as F, validateCollider3D as G, RigidBody3D as H, WATER_CUTOUT_MAX as I, colliderFootDrop as J, createCausticsQuad as K, WaterCutout3D as L, Chase as M, localFromWorld as N, phaseOf as O, worldPosition as P, rejectScale as R, goToScene as S, FollowCamera as T, StaticBody3D as U, PhysicsBody3D as V, Node3D as W, Cooldown as _, Wander as a, Interactable as b, SavePoint as c, Patrol as d, PathFollow as f, CameraShake as g, Lifetime as h, WaveSpawner as i, Collector as j, DamageOnContact as k, Projectile as l, MoveTo as m, registerGameplayBehaviors as n, Spawner as o, Oscillate as p, WATER_MAX_RIPPLES as q, ZombieAI as r, ScoreKeeper as s, GAMEPLAY_BEHAVIORS as t, Pickup as u, hitStop as v, tolerateUnknownAction as w, GameFlow as x, screenFlash as y, Area3D as z };
+export { DamageOnContact as A, rejectScale as B, restartScene as C, FaceTarget as D, FloatAway as E, localFromWorld as F, StaticBody3D as G, CharacterBody3D as H, worldPosition as I, createCausticsQuad as J, Node3D as K, Water3D as L, Currency as M, Collector as N, DayNight as O, Chase as P, WATER_CUTOUT_MAX as R, goToScene as S, FollowCamera as T, PhysicsBody3D as U, Area3D as V, RigidBody3D as W, colliderFootDrop as X, WATER_MAX_RIPPLES as Y, Cooldown as _, Wander as a, Interactable as b, SavePoint as c, Patrol as d, PathFollow as f, CameraShake as g, Lifetime as h, WaveSpawner as i, Health as j, phaseOf as k, Projectile as l, MoveTo as m, registerGameplayBehaviors as n, Spawner as o, Oscillate as p, validateCollider3D as q, ZombieAI as r, ScoreKeeper as s, GAMEPLAY_BEHAVIORS as t, Pickup as u, hitStop as v, tolerateUnknownAction as w, GameFlow as x, screenFlash as y, WaterCutout3D as z };