incanto 0.1.0

package/dist/physics-2d-KuMWPTf6.js

@@ -0,0 +1,288 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
+import { t as IncantoError } from "./errors-BpWbnbb_.js";
+import { d as CharacterBody2D, f as PhysicsBody2D, g as validateCollider2D, h as Node2D, p as RigidBody2D, u as Area2D } from "./register-DPEV9_9t.js";
+import { n as registerDebugSource } from "./debug-draw-CZmOYjL2.js";
+//#region src/2d/physics/physics-2d.ts
+var physics_2d_exports = /* @__PURE__ */ __exportAll({
+	Physics2D: () => Physics2D,
+	enablePhysics2D: () => enablePhysics2D
+});
+/** Internal unit scale: Rapier's solver is tuned for meters; we speak pixels. */
+const SCALE = 100;
+const DEG = Math.PI / 180;
+/**
+* Enable 2D physics for an engine. Dynamically imports Rapier (compat build,
+* wasm inlined) so games without physics never pay its bundle cost.
+*/
+async function enablePhysics2D(engine, opts) {
+	const R = await import("@dimforge/rapier2d-compat");
+	await R.init();
+	return new Physics2D(R, engine, opts);
+}
+/**
+* Per-engine 2D physics world (y-down pixel space, consistent with Node2D).
+* Each fixedUpdate: sync tree → step world → write back → drain trigger events.
+*/
+var Physics2D = class {
+	R;
+	engine;
+	/** Render collider outlines in the GAME view (renderers pick this up). */
+	debugDraw = false;
+	dimension = "2d";
+	unregisterDebug;
+	warnedNoCollider = /* @__PURE__ */ new WeakSet();
+	entries = /* @__PURE__ */ new Map();
+	byColliderHandle = /* @__PURE__ */ new Map();
+	world;
+	events;
+	kcc;
+	disconnect;
+	lastDt = 1 / 60;
+	optsGravity;
+	lastScene = null;
+	constructor(R, engine, opts) {
+		this.R = R;
+		this.engine = engine;
+		this.optsGravity = opts?.gravity;
+		this.lastScene = engine.scene;
+		const declared = engine.scene?.physics?.gravity;
+		const g = opts?.gravity ?? declared ?? [0, 980];
+		this.world = new R.World({
+			x: (g[0] ?? 0) / SCALE,
+			y: (g[1] ?? 0) / SCALE
+		});
+		this.kcc = this.world.createCharacterController(.01);
+		this.kcc.setUp({
+			x: 0,
+			y: -1
+		});
+		this.events = new R.EventQueue(true);
+		this.unregisterDebug = registerDebugSource(this);
+		this.disconnect = engine.fixedUpdated.connect((dt) => this.step(dt));
+		this.syncBodies();
+	}
+	/** @internal Driven by engine.fixedUpdated. */
+	step(dt) {
+		this.lastDt = dt;
+		if (this.engine.scene !== this.lastScene) {
+			this.lastScene = this.engine.scene;
+			if (!this.optsGravity) {
+				const g = this.engine.scene?.physics?.gravity ?? [0, 980];
+				this.world.gravity = {
+					x: (g[0] ?? 0) / SCALE,
+					y: (g[1] ?? 0) / SCALE
+				};
+			}
+		}
+		this.syncBodies();
+		this.world.timestep = dt;
+		this.world.step(this.events);
+		for (const [node, e] of this.entries) {
+			const t = e.body.translation();
+			if (!e.body.isFixed()) {
+				const [ox, oy] = parentWorldOffset2D(node);
+				node.position = [t.x * SCALE - ox, t.y * SCALE - oy];
+			}
+			if (node instanceof RigidBody2D) {
+				if (!node.fixedRotation) node.rotation = e.body.rotation() / DEG;
+				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;
+			}
+			const [wx, wy] = worldPosition2D(node);
+			e.lastX = wx;
+			e.lastY = wy;
+		}
+		this.events.drainCollisionEvents((h1, h2, started) => {
+			const a = this.byColliderHandle.get(h1);
+			const b = this.byColliderHandle.get(h2);
+			if (!a || !b) return;
+			const sig = started ? "triggerEnter" : "triggerExit";
+			a.emit(sig, b);
+			b.emit(sig, a);
+		});
+	}
+	/** @internal Called by CharacterBody2D.moveAndSlide (during tree fixedUpdate). */
+	moveAndSlide(node) {
+		const e = this.ensureEntry(node);
+		const vy = node.velocity[1] ?? 0;
+		if (node.snapToGround && vy >= 0) this.kcc.enableSnapToGround(.05);
+		else this.kcc.disableSnapToGround();
+		this.kcc.setMaxSlopeClimbAngle(node.slopeLimitDeg * DEG);
+		const desired = {
+			x: (node.velocity[0] ?? 0) * this.lastDt / SCALE,
+			y: vy * this.lastDt / SCALE
+		};
+		this.kcc.computeColliderMovement(e.collider, desired, this.R.QueryFilterFlags.EXCLUDE_SENSORS);
+		const corrected = this.kcc.computedMovement();
+		const t = e.body.translation();
+		e.body.setNextKinematicTranslation({
+			x: t.x + corrected.x,
+			y: t.y + corrected.y
+		});
+		node._grounded = this.kcc.computedGrounded();
+	}
+	/** Rapier debug segments, scaled back to pixels. Null while debugDraw is off. */
+	debugLines() {
+		if (!this.debugDraw) return null;
+		const raw = this.world.debugRender().vertices;
+		const px = new Float32Array(raw.length);
+		for (let i = 0; i < raw.length; i++) px[i] = raw[i] * SCALE;
+		return px;
+	}
+	dispose() {
+		this.disconnect();
+		this.unregisterDebug();
+		this.world.free();
+	}
+	syncBodies() {
+		const scene = this.engine.scene;
+		if (!scene) return;
+		const seen = /* @__PURE__ */ new Set();
+		collectBodies(scene.root, seen);
+		for (const node of seen) {
+			if (node.collider.shape === void 0) {
+				const stale = this.entries.get(node);
+				if (stale) {
+					this.byColliderHandle.delete(stale.collider.handle);
+					this.world.removeRigidBody(stale.body);
+					this.entries.delete(node);
+					node._physics = null;
+				}
+				if (!this.warnedNoCollider.has(node)) {
+					this.warnedNoCollider.add(node);
+					console.warn(`[incanto] '${node.name}' has no collider — physics skips it.`);
+				}
+				continue;
+			}
+			const existing = this.entries.get(node);
+			if (existing && existing.colliderKey !== JSON.stringify(node.collider)) {
+				this.byColliderHandle.delete(existing.collider.handle);
+				this.world.removeRigidBody(existing.body);
+				this.entries.delete(node);
+				node._physics = null;
+			}
+			this.ensureEntry(node);
+		}
+		for (const [node, e] of this.entries) if (!seen.has(node)) {
+			this.byColliderHandle.delete(e.collider.handle);
+			this.world.removeRigidBody(e.body);
+			this.entries.delete(node);
+			node._physics = null;
+		}
+	}
+	ensureEntry(node) {
+		let e = this.entries.get(node);
+		const R = this.R;
+		if (!e) {
+			const [wx, wy] = worldPosition2D(node);
+			const x = wx / SCALE;
+			const y = wy / SCALE;
+			let desc;
+			if (node instanceof RigidBody2D) 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);
+			if (node instanceof RigidBody2D) {
+				desc.setGravityScale(node.gravityScale);
+				desc.setLinvel((node.linearVelocity[0] ?? 0) / SCALE, (node.linearVelocity[1] ?? 0) / SCALE);
+				if (node.fixedRotation) desc.lockRotations();
+			}
+			const body = this.world.createRigidBody(desc);
+			const colDesc = parseCollider2D(R, node.collider, node.name);
+			colDesc.setActiveEvents(R.ActiveEvents.COLLISION_EVENTS);
+			colDesc.setActiveCollisionTypes(R.ActiveCollisionTypes.ALL);
+			if (node instanceof Area2D) colDesc.setSensor(true);
+			if (node instanceof RigidBody2D) colDesc.setMass(node.mass).setFriction(node.friction).setRestitution(node.restitution);
+			const collider = this.world.createCollider(colDesc, body);
+			e = {
+				body,
+				collider,
+				colliderKey: JSON.stringify(node.collider),
+				lastX: wx,
+				lastY: wy,
+				lastVX: 0,
+				lastVY: 0
+			};
+			this.entries.set(node, e);
+			this.byColliderHandle.set(collider.handle, node);
+			node._physics = this;
+			return e;
+		}
+		const [px, py] = worldPosition2D(node);
+		if (px !== e.lastX || py !== e.lastY) {
+			e.body.setTranslation({
+				x: px / SCALE,
+				y: py / SCALE
+			}, true);
+			e.lastX = px;
+			e.lastY = py;
+		}
+		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.lastVX = vx;
+				e.lastVY = vy;
+			}
+		}
+		return e;
+	}
+};
+function collectBodies(node, out) {
+	if (node instanceof PhysicsBody2D) out.add(node);
+	for (const c of node.children) collectBodies(c, out);
+}
+/**
+* Composed world position (translation only — ancestor rotation/scale are NOT
+* supported for physics bodies; keep body ancestors untransformed or offset-only).
+*/
+function worldPosition2D(node) {
+	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;
+	}
+	return [x, y];
+}
+function parentWorldOffset2D(node) {
+	let x = 0;
+	let y = 0;
+	for (let n = node.parent; n; n = n.parent) if (n instanceof Node2D) {
+		x += n.position[0] ?? 0;
+		y += n.position[1] ?? 0;
+	}
+	return [x, y];
+}
+function parseCollider2D(R, collider, nodeName) {
+	validateCollider2D(collider, nodeName);
+	const desc = buildColliderDesc(R, collider, nodeName);
+	const offset = collider.offset;
+	if (Array.isArray(offset)) desc.setTranslation((offset[0] ?? 0) / SCALE, (offset[1] ?? 0) / SCALE);
+	return desc;
+}
+function buildColliderDesc(R, collider, nodeName) {
+	const shape = collider.shape;
+	if (shape === "rect") {
+		const size = collider.size;
+		if (!Array.isArray(size) || size.length !== 2 || size.some((v) => typeof v !== "number")) throw new IncantoError("BAD_FORMAT", `Collider on '${nodeName}': rect needs "size": [width, height].`);
+		return R.ColliderDesc.cuboid(size[0] / 2 / SCALE, size[1] / 2 / SCALE);
+	}
+	if (shape === "circle") {
+		if (typeof collider.radius !== "number") throw new IncantoError("BAD_FORMAT", `Collider on '${nodeName}': circle needs "radius".`);
+		return R.ColliderDesc.ball(collider.radius / SCALE);
+	}
+	if (shape === "capsule") {
+		if (typeof collider.radius !== "number" || typeof collider.height !== "number") throw new IncantoError("BAD_FORMAT", `Collider on '${nodeName}': capsule needs "radius" and "height".`);
+		return R.ColliderDesc.capsule(collider.height / 2 / SCALE, collider.radius / SCALE);
+	}
+	throw new IncantoError("BAD_FORMAT", `Collider on '${nodeName}': "shape" must be 'rect', 'circle', or 'capsule', got ${JSON.stringify(shape)}.`);
+}
+//#endregion
+export { enablePhysics2D as n, physics_2d_exports as r, Physics2D as t };