incanto 0.74.0 → 0.76.0

package/dist/{physics-2d-C-SfvjzH.js → physics-2d-Tuf5LAyq.js}

@@ -1,9 +1,10 @@
 import { o as __exportAll } from "./json-CfTjpvW8.js";
-import { Y as diagnose } from "./save-slots-CEUGeLuB.js";
+import { et as diagnose } from "./pose-ByFB_J3O.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
-import { _ as RigidBody2D, b as validateCollider2D, g as PhysicsBody2D, h as CharacterBody2D, m as Area2D, p as Joint2D, v as StaticBody2D, y as Node2D } from "./register-DRQyZKGU.js";
+import { _ as Node2D, f as Area2D, g as StaticBody2D, h as RigidBody2D, m as PhysicsBody2D, p as CharacterBody2D, v as validateCollider2D } from "./gameplay-Bfff_beb.js";
 import { n as registerDebugSource } from "./debug-draw-BM3DsvtT.js";
 import { n as jointContacts, t as withoutRapierInitNoise } from "./quiet-rapier-C6fW4zcW.js";
+import { p as Joint2D } from "./register-7E3P1gz6.js";
 //#region src/2d/physics/physics-2d.ts
 var physics_2d_exports = /* @__PURE__ */ __exportAll({
 	Physics2D: () => Physics2D,
@@ -98,13 +99,18 @@ var Physics2D = class {
 		for (const [node, e] of this.entries) {
 			const t = e.body.translation();
 			if (!e.body.isFixed() && !(node instanceof Area2D)) {
-				const [ox, oy] = parentWorldOffset2D(node);
-				node.position = [t.x * SCALE - ox, t.y * SCALE - oy];
+				const [ox, oy, oa] = parentPose2D(node);
+				const dx = t.x * SCALE - ox;
+				const dy = t.y * SCALE - oy;
+				if (oa !== 0) {
+					const a = -oa * DEG;
+					node.position = [dx * Math.cos(a) - dy * Math.sin(a), dx * Math.sin(a) + dy * Math.cos(a)];
+				} else node.position = [dx, dy];
 			}
 			if (node instanceof RigidBody2D) {
 				if (!node.fixedRotation) {
-					node.rotation = e.body.rotation() / DEG;
-					e.lastRot = node.rotation;
+					node.rotation = e.body.rotation() / DEG - parentPose2D(node)[2];
+					e.lastRot = e.body.rotation() / DEG;
 				}
 				const lv = e.body.linvel();
 				node.linearVelocity = [lv.x * SCALE, lv.y * SCALE];
@@ -121,6 +127,7 @@ var Physics2D = class {
 			const a = this.byColliderHandle.get(h1);
 			const b = this.byColliderHandle.get(h2);
 			if (!a || !b) return;
+			if (!a.enabled || !b.enabled) return;
 			const sig = started ? "triggerEnter" : "triggerExit";
 			if (started === (this.overlaps.get(a)?.has(b) ?? false)) return;
 			this.trackOverlap(a, b, started);
@@ -149,6 +156,7 @@ var Physics2D = class {
 	* you can carry you.
 	*/
 	canCarry(rider, candidate) {
+		if (this.jointed.get(rider)?.has(candidate)) return false;
 		let at = candidate;
 		for (let depth = 0; depth < 8 && at; depth++) {
 			if (at === rider) return false;
@@ -171,6 +179,14 @@ var Physics2D = class {
 			const [gx, gy] = worldPosition2D(e.ground);
 			carryX = gx - (e.groundX ?? gx);
 			carryY = gy - (e.groundY ?? gy);
+			const gb = this.entries.get(e.ground);
+			if (gb && e.groundRot !== void 0 && e.riderX !== void 0 && e.riderY !== void 0) {
+				const d = gb.body.rotation() - e.groundRot;
+				const ox = e.riderX - (e.groundX ?? gx);
+				const oy = e.riderY - (e.groundY ?? gy);
+				carryX += ox * Math.cos(d) - oy * Math.sin(d) - ox;
+				carryY += ox * Math.sin(d) + oy * Math.cos(d) - oy;
+			}
 		} else e.ground = null;
 		const vyTerm = carryY < -.1 && node.isOnFloor?.() === true && vy > 0 ? 0 : vy * this.lastDt;
 		const desired = {
@@ -186,7 +202,15 @@ var Physics2D = class {
 			}
 			return true;
 		};
-		const filter = node.collideWithCharacters ? predicate : (c) => !(this.byColliderHandle.get(c.handle) instanceof CharacterBody2D) && predicate(c);
+		const noContact = this.jointed.get(node);
+		const filter = (c) => {
+			const other = this.byColliderHandle.get(c.handle);
+			if (!node.collideWithCharacters && other instanceof CharacterBody2D) return false;
+			if (other && noContact?.get(other) === false) return false;
+			return predicate(c);
+		};
+		this.kcc.setApplyImpulsesToDynamicBodies(node.pushes > 0);
+		if (node.pushes > 0) this.kcc.setCharacterMass(node.pushes);
 		this.kcc.computeColliderMovement(e.collider, desired, this.R.QueryFilterFlags.EXCLUDE_SENSORS, void 0, filter);
 		const corrected = this.kcc.computedMovement();
 		const t = e.body.translation();
@@ -214,6 +238,9 @@ var Physics2D = class {
 				const [gx, gy] = worldPosition2D(hit.node);
 				e.groundX = gx;
 				e.groundY = gy;
+				e.groundRot = this.entries.get(hit.node)?.body.rotation();
+				e.riderX = footX;
+				e.riderY = (t.y + corrected.y) * SCALE + charHalfHeight(node);
 			} else e.ground = null;
 		} else e.ground = null;
 	}
@@ -290,14 +317,28 @@ var Physics2D = class {
 			for (const [joint, impulse] of this.joints) if (!this.jointSet.has(joint)) {
 				this.world.removeImpulseJoint(impulse, true);
 				this.joints.delete(joint);
+				const pair = this.jointBodies.get(joint);
+				if (pair) this.unlinkJointed(pair[0], pair[1]);
+				this.jointBodies.delete(joint);
+				this.hingeState.delete(joint);
+				this.tetherState.delete(joint);
 			}
 		}
 		for (const joint of this.jointSet) {
-			if (this.joints.has(joint)) continue;
+			if (this.joints.has(joint) || this.refusedJoints.has(joint)) continue;
 			const { a, b } = joint._resolveBodies();
 			const ea = this.entries.get(a);
 			const eb = this.entries.get(b);
 			if (!ea || !eb) continue;
+			if (joint.type === "prismatic") {
+				let off = Math.abs(ea.body.rotation() - eb.body.rotation()) / DEG;
+				off = Math.abs((off + 180) % 360 - 180);
+				if (off > .5) {
+					this.refusedJoints.add(joint);
+					diagnose(this.engine, "error", `[incanto] Joint2D '${joint.getPath()}': its two bodies disagree about the slide axis by ${off.toFixed(1)}° — '${a.name}' and '${b.name}' are authored with different rotations, and Rapier reads the axis in BOTH bodies' local frames. Give both bodies the same rotation. The joint was not made.`);
+					continue;
+				}
+			}
 			const a1 = {
 				x: (joint.anchor[0] ?? 0) / SCALE,
 				y: (joint.anchor[1] ?? 0) / SCALE
@@ -316,10 +357,63 @@ var Physics2D = class {
 			if (joint.type === "fixed") data = R.JointData.fixed(a1, 0, a2, 0);
 			else if (joint.type === "rope") data = R.JointData.rope(length, a1, a2);
 			else if (joint.type === "spring") data = R.JointData.spring(length, joint.stiffness, joint.damping, a1, a2);
-			else data = R.JointData.revolute(a1, a2);
+			else if (joint.type === "prismatic") {
+				const ax = joint.axis[0] ?? 0;
+				const ay = joint.axis[1] ?? 0;
+				const n = Math.hypot(ax, ay) || 1;
+				data = R.JointData.prismatic(a1, a2, {
+					x: ax / n,
+					y: ay / n
+				});
+			} else data = R.JointData.revolute(a1, a2);
 			const made = this.world.createImpulseJoint(data, ea.body, eb.body, true);
-			made.setContactsEnabled(jointContacts(joint.type, joint.collide));
+			if (joint.type === "revolute" || joint.type === "prismatic") this.applyHinge(joint, made, true);
+			const contacts = jointContacts(joint.type, joint.collide);
+			made.setContactsEnabled(contacts);
 			this.joints.set(joint, made);
+			this.jointBodies.set(joint, [a, b]);
+			this.linkJointed(a, b, contacts);
+			if (joint.type === "rope" || joint.type === "spring") this.tetherState.set(joint, this.tetherKey(joint));
+		}
+		for (const [joint, made] of this.joints) {
+			if (joint.type !== "rope" && joint.type !== "spring") continue;
+			const key = this.tetherKey(joint);
+			if (this.tetherState.get(joint) === key) continue;
+			this.world.removeImpulseJoint(made, true);
+			this.joints.delete(joint);
+			const pair = this.jointBodies.get(joint);
+			if (pair) this.unlinkJointed(pair[0], pair[1]);
+			this.jointBodies.delete(joint);
+			this.tetherState.delete(joint);
+		}
+		for (const [joint, made] of this.joints) {
+			if (joint.type !== "revolute" && joint.type !== "prismatic") continue;
+			this.applyHinge(joint, made, false);
+			const pair = this.jointBodies.get(joint);
+			const ea = pair && this.entries.get(pair[0]);
+			const eb = pair && this.entries.get(pair[1]);
+			if (!ea || !eb) continue;
+			if (joint.type === "revolute") {
+				let deg = (ea.body.rotation() - eb.body.rotation()) / DEG;
+				deg = ((deg + 180) % 360 + 360) % 360 - 180;
+				joint.angle = deg;
+			} else {
+				const ra = ea.body.rotation();
+				const rb = eb.body.rotation();
+				const ta = ea.body.translation();
+				const tb = eb.body.translation();
+				const [ax, ay] = [joint.anchor[0] ?? 0, joint.anchor[1] ?? 0];
+				const [bx, by] = [joint.targetAnchor[0] ?? 0, joint.targetAnchor[1] ?? 0];
+				const wax = ta.x * SCALE + ax * Math.cos(ra) - ay * Math.sin(ra);
+				const way = ta.y * SCALE + ax * Math.sin(ra) + ay * Math.cos(ra);
+				const wbx = tb.x * SCALE + bx * Math.cos(rb) - by * Math.sin(rb);
+				const wby = tb.y * SCALE + bx * Math.sin(rb) + by * Math.cos(rb);
+				const [ux, uy] = [joint.axis[0] ?? 0, joint.axis[1] ?? 0];
+				const n = Math.hypot(ux, uy) || 1;
+				const ex = (ux * Math.cos(ra) - uy * Math.sin(ra)) / n;
+				const ey = (ux * Math.sin(ra) + uy * Math.cos(ra)) / n;
+				joint.travel = (wax - wbx) * ex + (way - wby) * ey;
+			}
 		}
 	}
 	/** Who is currently inside each sensor/body, maintained from the event drain. */
@@ -418,6 +512,11 @@ var Physics2D = class {
 	massOf(node) {
 		return this.entries.get(node)?.body.mass() ?? 1;
 	}
+	/** The solver's rotation of a body, in degrees (the node's own unit). */
+	rotationOf(node) {
+		const e = this.entries.get(node);
+		return e ? e.body.rotation() / DEG : 0;
+	}
 	/**
 	* Current solver velocity in px/s (fresher than the node prop mid-step).
 	*
@@ -436,10 +535,26 @@ var Physics2D = class {
 	* adapters while only one of them had it.
 	*/
 	applyImpulse(node, impulse) {
-		this.entries.get(node)?.body.applyImpulse({
+		const e = this.entries.get(node);
+		if (!e) return;
+		if (node instanceof RigidBody2D) {
+			const vx = node.linearVelocity[0] ?? 0;
+			const vy = node.linearVelocity[1] ?? 0;
+			if (vx !== e.lastVX || vy !== e.lastVY) e.body.setLinvel({
+				x: vx / SCALE,
+				y: vy / SCALE
+			}, true);
+		}
+		e.body.applyImpulse({
 			x: impulse[0] / SCALE,
 			y: impulse[1] / SCALE
 		}, true);
+		if (node instanceof RigidBody2D) {
+			const lv = e.body.linvel();
+			node.linearVelocity = [lv.x * SCALE, lv.y * SCALE];
+			e.lastVX = node.linearVelocity[0] ?? 0;
+			e.lastVY = node.linearVelocity[1] ?? 0;
+		}
 	}
 	/**
 	* World-space raycast in PIXELS (y-down); `dir` may be any length (it is
@@ -514,6 +629,71 @@ var Physics2D = class {
 	lastRoot = null;
 	jointSet = /* @__PURE__ */ new Set();
 	joints = /* @__PURE__ */ new Map();
+	/** The two bodies each live joint ties, so a departed joint can be unlinked. */
+	jointBodies = /* @__PURE__ */ new Map();
+	/** What a pin's limits/motor were last pushed as, so a write re-applies. */
+	hingeState = /* @__PURE__ */ new Map();
+	/** Joints refused at creation (bodies that disagree about the axis) — said once. */
+	refusedJoints = /* @__PURE__ */ new Set();
+	/** A rope's or spring's numbers as last made, so a write REMAKES the joint. */
+	tetherState = /* @__PURE__ */ new Map();
+	tetherKey(joint) {
+		return `${joint.length}/${joint.stiffness}/${joint.damping}`;
+	}
+	/**
+	* Who is jointed to whom, and whether that pair's contacts are on — see the
+	* 3D twin: a joint's own bodies are not the world to the character
+	* controller (not its obstacle when the contacts are off, never its ground).
+	*/
+	jointed = /* @__PURE__ */ new Map();
+	linkJointed(a, b, contacts) {
+		for (const [x, y] of [[a, b], [b, a]]) {
+			let m = this.jointed.get(x);
+			if (!m) {
+				m = /* @__PURE__ */ new Map();
+				this.jointed.set(x, m);
+			}
+			m.set(y, contacts);
+		}
+	}
+	unlinkJointed(a, b) {
+		this.jointed.get(a)?.delete(b);
+		this.jointed.get(b)?.delete(a);
+	}
+	/**
+	* Push a pin's `limits` and motor to the solver — on creation, and again
+	* whenever either changes. Limits and `angle` are this body relative to the
+	* target; Rapier measures the other way round, hence the flip.
+	*/
+	applyHinge(joint, made, first) {
+		const limits = JSON.stringify(joint.limits);
+		const motor = `${joint.motorSpeed}/${joint.motorStrength}`;
+		const last = this.hingeState.get(joint);
+		const unit = made;
+		const unitScale = joint.type === "revolute" ? DEG : 1 / SCALE;
+		if (first || last?.limits !== limits) {
+			if (joint.limits.length === 2) {
+				const lo = (joint.limits[0] ?? 0) * unitScale;
+				const hi = (joint.limits[1] ?? 0) * unitScale;
+				unit.setLimits(-Math.max(lo, hi), -Math.min(lo, hi));
+			} else if (!first) unit.setLimits(-1e9, 1e9);
+		}
+		if (first || last?.motor !== motor) {
+			if (joint.motorSpeed !== 0) unit.configureMotorVelocity(-joint.motorSpeed * unitScale, joint.motorStrength);
+			else if (!first) unit.configureMotorVelocity(0, 0);
+		}
+		this.hingeState.set(joint, {
+			limits,
+			motor
+		});
+		if (joint.motorSpeed !== 0) {
+			const pair = this.jointBodies.get(joint);
+			for (const b of pair ?? []) {
+				const e = this.entries.get(b);
+				if (e && !e.body.isFixed() && e.body.isSleeping()) e.body.wakeUp();
+			}
+		}
+	}
 	bodySet = /* @__PURE__ */ new Set();
 	/**
 	* Move every body to its node's current transform — outline mode only.
@@ -523,12 +703,12 @@ var Physics2D = class {
 	*/
 	poseFromTree() {
 		for (const [node, e] of this.entries) {
-			const [wx, wy] = worldPosition2D(node);
+			const [wx, wy, wa] = worldPose2D(node);
 			e.body.setTranslation({
 				x: wx / SCALE,
 				y: wy / SCALE
 			}, false);
-			e.body.setRotation(node.rotation * DEG, false);
+			e.body.setRotation(wa * DEG, false);
 		}
 		this.world.propagateModifiedBodyPositionsToColliders();
 	}
@@ -600,7 +780,7 @@ var Physics2D = class {
 		let e = this.entries.get(node);
 		const R = this.R;
 		if (!e) {
-			const [wx, wy] = worldPosition2D(node);
+			const [wx, wy, wa] = worldPose2D(node);
 			const x = wx / SCALE;
 			const y = wy / SCALE;
 			let desc;
@@ -608,7 +788,7 @@ var Physics2D = class {
 			if (dyn) desc = R.RigidBodyDesc.dynamic();
 			else if (node instanceof CharacterBody2D || node instanceof Area2D) desc = R.RigidBodyDesc.kinematicPositionBased();
 			else desc = R.RigidBodyDesc.fixed();
-			desc.setTranslation(x, y).setRotation(node.rotation * DEG);
+			desc.setTranslation(x, y).setRotation(wa * DEG);
 			if (node instanceof RigidBody2D) {
 				desc.setGravityScale(node.gravityScale);
 				desc.setLinearDamping(node.linearDamping).setAngularDamping(node.angularDamping);
@@ -629,7 +809,7 @@ var Physics2D = class {
 				collider,
 				lastX: wx,
 				lastY: wy,
-				lastRot: node.rotation,
+				lastRot: wa,
 				lastVX: 0,
 				lastVY: 0,
 				lastAV: dyn ? node.angularVelocity : 0,
@@ -658,7 +838,7 @@ var Physics2D = class {
 			node._enabledChanged = false;
 			if (node.enabled) this.armOverlaps(node, e.collider);
 		}
-		const [px, py] = worldPosition2D(node);
+		const [px, py, pa] = worldPose2D(node);
 		if (px !== e.lastX || py !== e.lastY) {
 			e.body.setTranslation({
 				x: px / SCALE,
@@ -667,9 +847,9 @@ var Physics2D = class {
 			e.lastX = px;
 			e.lastY = py;
 		}
-		if (node.rotation !== e.lastRot) {
-			e.body.setRotation(node.rotation * DEG, true);
-			e.lastRot = node.rotation;
+		if (pa !== e.lastRot) {
+			e.body.setRotation(pa * DEG, true);
+			e.lastRot = pa;
 		}
 		if (node instanceof RigidBody2D) {
 			const vx = node.linearVelocity[0] ?? 0;
@@ -743,23 +923,62 @@ function platformTopPx(node) {
 	const c = node.collider;
 	return wy - (c.shape === "rect" ? (c.size?.[1] ?? 32) / 2 : c.shape === "capsule" ? (c.height ?? 32) / 2 + (c.radius ?? 8) : c.radius ?? 16);
 }
-function worldPosition2D(node) {
+const poseChain2 = [];
+const poseOut = [
+	0,
+	0,
+	0
+];
+/**
+* The WORLD pose of `node` — position and angle (degrees) composed through
+* every Node2D ancestor, the way the renderer composes them. This used to sum
+* positions only, so a sensor 120 px down +x of a body turned 90° was put at
+* world +x while the renderer drew it at world +y. Scale is not composed.
+*/
+function worldPose2D(node) {
+	poseChain2.length = 0;
+	for (let n = node; n; n = n.parent) if (n instanceof Node2D) poseChain2.push(n);
 	let x = 0;
 	let y = 0;
-	for (let n = node; n; n = n.parent) if (n instanceof Node2D) {
-		x += n.position[0] ?? 0;
-		y += n.position[1] ?? 0;
+	let angle = 0;
+	for (let i = poseChain2.length - 1; i >= 0; i--) {
+		const n = poseChain2[i];
+		const lx = n.position[0] ?? 0;
+		const ly = n.position[1] ?? 0;
+		if (angle !== 0) {
+			const a = angle * DEG;
+			const c = Math.cos(a);
+			const s = Math.sin(a);
+			x += lx * c - ly * s;
+			y += lx * s + ly * c;
+		} else {
+			x += lx;
+			y += ly;
+		}
+		angle += n.rotation;
 	}
-	return [x, y];
+	poseOut[0] = x;
+	poseOut[1] = y;
+	poseOut[2] = angle;
+	return poseOut;
 }
-function parentWorldOffset2D(node) {
-	let x = 0;
-	let y = 0;
+function worldPosition2D(node) {
+	const p = worldPose2D(node);
+	return [p[0], p[1]];
+}
+/** The pose of `node`'s PARENT frame: [x, y, angleDeg]. */
+function parentPose2D(node) {
+	let parent = null;
 	for (let n = node.parent; n; n = n.parent) if (n instanceof Node2D) {
-		x += n.position[0] ?? 0;
-		y += n.position[1] ?? 0;
+		parent = n;
+		break;
 	}
-	return [x, y];
+	const p = worldPose2D(parent);
+	return [
+		p[0],
+		p[1],
+		p[2]
+	];
 }
 function parseCollider2D(R, collider, nodeName) {
 	validateCollider2D(collider, nodeName);