incanto 0.7.1 → 0.9.0

package/dist/particle-sim-CyUU7HVU.js

@@ -0,0 +1,281 @@
+import { n as jsonEquals } from "./json-BLk7H2Qa.js";
+//#region src/core/order-groups.ts
+const ORDER_GROUP_BASE = {
+	background: -2e3,
+	terrain: -1e3,
+	default: 0,
+	characters: 1e3,
+	effects: 2e3,
+	overlay: 3e3
+};
+/** base + fine offset (unknown group names fall back to `default`). */
+function effectiveOrder(group, renderOrder) {
+	return (ORDER_GROUP_BASE[group] ?? 0) + renderOrder;
+}
+//#endregion
+//#region src/core/particle-presets.ts
+const PARTICLE_PRESETS = {
+	fire: {
+		rate: 60,
+		lifetime: [.4, .9],
+		speed: [30, 70],
+		directionDeg: -90,
+		spreadDeg: 35,
+		gravity: [0, -30],
+		sizeStart: 14,
+		sizeEnd: 3,
+		colorStart: "#ffcf5a",
+		colorEnd: "#e8401f",
+		alphaStart: .9,
+		alphaEnd: 0,
+		blend: "add"
+	},
+	smoke: {
+		rate: 20,
+		lifetime: [1.5, 2.5],
+		speed: [10, 25],
+		directionDeg: -90,
+		spreadDeg: 40,
+		gravity: [0, -12],
+		sizeStart: 10,
+		sizeEnd: 26,
+		colorStart: "#8a8a8a",
+		colorEnd: "#3a3a3a",
+		alphaStart: .35,
+		alphaEnd: 0,
+		blend: "normal"
+	},
+	sparks: {
+		rate: 80,
+		lifetime: [.3, .7],
+		speed: [120, 260],
+		spreadDeg: 360,
+		gravity: [0, 240],
+		drag: 1,
+		sizeStart: 4,
+		sizeEnd: 1,
+		colorStart: "#fff3b0",
+		colorEnd: "#ff9d2e",
+		blend: "add"
+	},
+	fireworks: {
+		rate: 0,
+		burst: 120,
+		lifetime: [.8, 1.6],
+		speed: [80, 240],
+		spreadDeg: 360,
+		gravity: [0, 90],
+		drag: .6,
+		sizeStart: 5,
+		sizeEnd: 1,
+		colorStart: "#9ad8ff",
+		colorEnd: "#ff5ad8",
+		blend: "add"
+	},
+	explosion: {
+		rate: 0,
+		burst: 60,
+		lifetime: [.25, .6],
+		speed: [150, 420],
+		spreadDeg: 360,
+		drag: 3,
+		sizeStart: 16,
+		sizeEnd: 2,
+		colorStart: "#ffe08a",
+		colorEnd: "#ff3b1f",
+		blend: "add"
+	},
+	flash: {
+		rate: 0,
+		burst: 8,
+		lifetime: [.08, .16],
+		speed: [0, 30],
+		spreadDeg: 360,
+		sizeStart: 64,
+		sizeEnd: 96,
+		colorStart: "#ffffff",
+		colorEnd: "#ffffff",
+		alphaStart: 1,
+		alphaEnd: 0,
+		blend: "add"
+	},
+	lightning: {
+		rate: 90,
+		lifetime: [.05, .12],
+		speed: [400, 900],
+		directionDeg: -90,
+		spreadDeg: 14,
+		sizeStart: 6,
+		sizeEnd: 2,
+		colorStart: "#eaf2ff",
+		colorEnd: "#7fb4ff",
+		blend: "add"
+	},
+	rain: {
+		rate: 160,
+		lifetime: [.8, 1.2],
+		speed: [300, 420],
+		directionDeg: 90,
+		spreadDeg: 6,
+		sizeStart: 3,
+		sizeEnd: 3,
+		colorStart: "#9ec8ff",
+		colorEnd: "#9ec8ff",
+		alphaStart: .5,
+		alphaEnd: .2,
+		blend: "normal"
+	},
+	snow: {
+		rate: 40,
+		lifetime: [3, 5],
+		speed: [20, 50],
+		directionDeg: 90,
+		spreadDeg: 30,
+		drag: .2,
+		sizeStart: 5,
+		sizeEnd: 4,
+		colorStart: "#ffffff",
+		colorEnd: "#ffffff",
+		alphaStart: .9,
+		alphaEnd: .6,
+		blend: "normal"
+	},
+	magic: {
+		rate: 50,
+		lifetime: [.6, 1.4],
+		speed: [20, 80],
+		spreadDeg: 360,
+		gravity: [0, -20],
+		sizeStart: 7,
+		sizeEnd: 1,
+		colorStart: "#9dffe8",
+		colorEnd: "#7a5cff",
+		blend: "add"
+	}
+};
+const PARTICLE_PRESET_NAMES = Object.keys(PARTICLE_PRESETS);
+/**
+* Apply the delta rule across three layers: schema default < preset < the
+* scene's explicit props. A prop still equal to its SCHEMA default is
+* considered "unset" and takes the preset value.
+*/
+function applyParticlePreset(target, presetName, schema) {
+	if (presetName === "custom") return;
+	const preset = PARTICLE_PRESETS[presetName];
+	if (!preset) return;
+	for (const [key, presetValue] of Object.entries(preset)) {
+		const def = schema[key]?.default;
+		const current = target[key];
+		if (def !== void 0 && jsonEquals(current, def)) target[key] = Array.isArray(presetValue) ? [...presetValue] : presetValue;
+	}
+}
+//#endregion
+//#region src/core/particle-sim.ts
+const FIELDS = 9;
+var ParticleSim = class {
+	config;
+	rng;
+	data;
+	alive = 0;
+	spawnAccumulator = 0;
+	everSpawned = false;
+	constructor(config, rng) {
+		this.config = config;
+		this.rng = rng;
+		this.data = new Float64Array(Math.max(1, config.maxParticles) * FIELDS);
+	}
+	/** Change the emission rate LIVE (particles/sec; 0 pauses emission) — lets an
+	* emitter toggle on/off at runtime (drift smoke, throttle flames). */
+	setRate(rate) {
+		this.config.rate = rate;
+		if (rate <= 0) this.spawnAccumulator = 0;
+	}
+	get count() {
+		return this.alive;
+	}
+	/** True when nothing is alive and at least one particle has ever spawned. */
+	get done() {
+		return this.everSpawned && this.alive === 0;
+	}
+	/** Spawn n particles immediately (fireworks, explosions, flashes). */
+	burst(n) {
+		for (let i = 0; i < n; i++) this.spawn();
+	}
+	update(dt) {
+		if (this.config.rate > 0) {
+			this.spawnAccumulator += this.config.rate * dt;
+			while (this.spawnAccumulator >= 1) {
+				this.spawnAccumulator -= 1;
+				this.spawn();
+			}
+		}
+		const d = this.data;
+		const [gx, gy, gz] = this.config.gravity;
+		const damp = this.config.drag > 0 ? Math.exp(-this.config.drag * dt) : 1;
+		let i = 0;
+		while (i < this.alive) {
+			const base = i * FIELDS;
+			const age = d[base + 6] + dt;
+			if (age >= d[base + 7]) {
+				this.kill(i);
+				continue;
+			}
+			d[base + 6] = age;
+			d[base + 3] = (d[base + 3] + gx * dt) * damp;
+			d[base + 4] = (d[base + 4] + gy * dt) * damp;
+			d[base + 5] = (d[base + 5] + gz * dt) * damp;
+			d[base + 0] = d[base + 0] + d[base + 3] * dt;
+			d[base + 1] = d[base + 1] + d[base + 4] * dt;
+			d[base + 2] = d[base + 2] + d[base + 5] * dt;
+			i += 1;
+		}
+	}
+	forEach(fn) {
+		const d = this.data;
+		for (let i = 0; i < this.alive; i++) {
+			const base = i * FIELDS;
+			const age = d[base + 6];
+			const life = d[base + 7];
+			fn({
+				x: d[base + 0],
+				y: d[base + 1],
+				z: d[base + 2],
+				vx: d[base + 3],
+				vy: d[base + 4],
+				vz: d[base + 5],
+				age,
+				life,
+				t: life > 0 ? age / life : 1,
+				seed: d[base + 8]
+			});
+		}
+	}
+	spawn() {
+		if (this.alive >= this.config.maxParticles) return;
+		const base = this.alive * FIELDS;
+		const d = this.data;
+		const c = this.config;
+		const angle = (c.directionDeg + (this.rng.next() - .5) * c.spreadDeg) * Math.PI / 180;
+		const speed = c.speed[0] + this.rng.next() * (c.speed[1] - c.speed[0]);
+		const zTilt = c.spreadZ ? (this.rng.next() - .5) * (c.spreadDeg * Math.PI / 180) : 0;
+		const planar = Math.cos(zTilt);
+		d[base + 0] = 0;
+		d[base + 1] = 0;
+		d[base + 2] = 0;
+		d[base + 3] = Math.cos(angle) * speed * planar;
+		d[base + 4] = Math.sin(angle) * speed * planar;
+		d[base + 5] = Math.sin(zTilt) * speed;
+		d[base + 6] = 0;
+		d[base + 7] = c.lifetime[0] + this.rng.next() * (c.lifetime[1] - c.lifetime[0]);
+		d[base + 8] = this.rng.next();
+		this.alive += 1;
+		this.everSpawned = true;
+	}
+	kill(index) {
+		const last = this.alive - 1;
+		if (index !== last) this.data.copyWithin(index * FIELDS, last * FIELDS, last * FIELDS + FIELDS);
+		this.alive = last;
+	}
+};
+//#endregion
+export { ORDER_GROUP_BASE as a, applyParticlePreset as i, PARTICLE_PRESETS as n, effectiveOrder as o, PARTICLE_PRESET_NAMES as r, ParticleSim as t };

package/dist/{physics-2d-CZM5Y90X.js → physics-2d-DweTURFt.js}

@@ -1,6 +1,6 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
-import { _ as validateCollider2D, d as Area2D, f as CharacterBody2D, g as Node2D, m as RigidBody2D, p as PhysicsBody2D, u as Joint2D } from "./register-Cl3pAxX-.js";
+import { _ as RigidBody2D, b as validateCollider2D, g as PhysicsBody2D, h as CharacterBody2D, m as Area2D, p as Joint2D, y as Node2D } from "./register-BD6zgrv_.js";
 import { n as registerDebugSource } from "./debug-draw-CZmOYjL2.js";
 //#region src/2d/physics/physics-2d.ts
 var physics_2d_exports = /* @__PURE__ */ __exportAll({
@@ -110,11 +110,27 @@ var Physics2D = class {
 		if (node.snapToGround && vy >= 0) this.kcc.enableSnapToGround(.05);
 		else this.kcc.disableSnapToGround();
 		this.kcc.setMaxSlopeClimbAngle(node.slopeLimitDeg * DEG);
+		let carryX = 0;
+		let carryY = 0;
+		if (e.ground && e.ground._physics === this) {
+			const [gx, gy] = worldPosition2D(e.ground);
+			carryX = gx - (e.groundX ?? gx);
+			carryY = gy - (e.groundY ?? gy);
+		} else e.ground = null;
 		const desired = {
-			x: (node.velocity[0] ?? 0) * this.lastDt / SCALE,
-			y: vy * this.lastDt / SCALE
+			x: ((node.velocity[0] ?? 0) * this.lastDt + carryX) / SCALE * 1,
+			y: (vy * this.lastDt + carryY) / SCALE * 1
 		};
-		this.kcc.computeColliderMovement(e.collider, desired, this.R.QueryFilterFlags.EXCLUDE_SENSORS);
+		const charBottomPx = e.body.translation().y * SCALE + charHalfHeight(node);
+		const predicate = (collider) => {
+			const other = this.byColliderHandle.get(collider.handle);
+			if (other && other !== node && other.collider.oneWay === true) {
+				if (vy < 0) return false;
+				if (charBottomPx > platformTopPx(other) + ONE_WAY_TOLERANCE_PX) return false;
+			}
+			return true;
+		};
+		this.kcc.computeColliderMovement(e.collider, desired, this.R.QueryFilterFlags.EXCLUDE_SENSORS, void 0, predicate);
 		const corrected = this.kcc.computedMovement();
 		const t = e.body.translation();
 		e.body.setNextKinematicTranslation({
@@ -122,6 +138,17 @@ var Physics2D = class {
 			y: t.y + corrected.y
 		});
 		node._grounded = this.kcc.computedGrounded();
+		if (node._grounded) {
+			const footX = (t.x + corrected.x) * SCALE;
+			const footY = (t.y + corrected.y) * SCALE + charHalfHeight(node) - 2;
+			const hit = this.castRay([footX, footY], [0, 1], 8, node);
+			if (hit?.node && !(hit.node instanceof CharacterBody2D)) {
+				e.ground = hit.node;
+				const [gx, gy] = worldPosition2D(hit.node);
+				e.groundX = gx;
+				e.groundY = gy;
+			} else e.ground = null;
+		} else e.ground = null;
 	}
 	/** Rapier debug segments, scaled back to pixels. Null while debugDraw is off. */
 	debugLines() {
@@ -327,6 +354,20 @@ function collectBodies(node, out) {
 * Composed world position (translation only — ancestor rotation/scale are NOT
 * supported for physics bodies; keep body ancestors untransformed or offset-only).
 */
+const ONE_WAY_TOLERANCE_PX = 4;
+/** Distance from a body's center to its lowest point, px. */
+function charHalfHeight(node) {
+	const c = node.collider;
+	if (c.shape === "rect") return (c.size?.[1] ?? 32) / 2;
+	if (c.shape === "capsule") return (c.height ?? 32) / 2 + (c.radius ?? 8);
+	return c.radius ?? 16;
+}
+/** The stand-on surface of a platform (y-down: its SMALLEST y), px. */
+function platformTopPx(node) {
+	const [, wy] = worldPosition2D(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) {
 	let x = 0;
 	let y = 0;

package/dist/{physics-3d-DT5e8izo.js → physics-3d-Clv1uFzk.js}

@@ -1,7 +1,7 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
 import { n as registerDebugSource } from "./debug-draw-CZmOYjL2.js";
-import { D as CharacterBody3D, E as Area3D, M as validateCollider3D, O as PhysicsBody3D, T as Joint3D, j as Node3D, k as RigidBody3D, x as Terrain3D } from "./register-CpXcMiEk.js";
+import { A as RigidBody3D, D as Area3D, E as Joint3D, M as Node3D, N as validateCollider3D, O as CharacterBody3D, S as Terrain3D, k as PhysicsBody3D } from "./register-iUPtts7T.js";
 import { Euler, Quaternion } from "three";
 //#region src/3d/physics/physics-3d.ts
 var physics_3d_exports = /* @__PURE__ */ __exportAll({

package/dist/react.d.ts

@@ -1,5 +1,5 @@
 import { c as JsonValue } from "./schema-CcoWb32N.js";
-import { n as BehaviorCtor, v as Engine, w as Scene } from "./behavior-q3cejJgs.js";
+import { n as BehaviorCtor, v as Engine, w as Scene } from "./behavior-Bod1AyJS.js";
 import { CSSProperties, ReactNode } from "react";
 
 //#region src/react/index.d.ts

package/dist/react.js

@@ -156,7 +156,7 @@ function IncantoCanvas(props) {
 				pointer: latest.pointer,
 				...keyboard !== void 0 ? { keyboard } : {}
 			};
-			const next = await (_gameFactory ?? (mode === "3d" ? async (o) => (await import("./create-game-rFulaS3s.js").then((n) => n.n)).createGame3D(o) : async (o) => (await import("./create-game-DuDkqnjl.js").then((n) => n.n)).createGame2D(o)))(opts);
+			const next = await (_gameFactory ?? (mode === "3d" ? async (o) => (await import("./create-game-Bydey3CZ.js").then((n) => n.n)).createGame3D(o) : async (o) => (await import("./create-game-C7Zsqbko.js").then((n) => n.n)).createGame2D(o)))(opts);
 			if (disposed) {
 				next.dispose();
 				return;

package/dist/{register-Cl3pAxX-.js → register-BD6zgrv_.js}

@@ -1,10 +1,10 @@
 import { f as Node } from "./loader-B4OEXDZ8.js";
-import { i as applyParticlePreset, o as effectiveOrder, r as PARTICLE_PRESET_NAMES, t as ParticleSim } from "./particle-sim-m3CdTGSl.js";
+import { t as registerCoreNodes } from "./register-DJZXxwAn.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
 import { t as Rng } from "./rng-DP-SR7eg.js";
-import { t as registerCoreNodes } from "./register-Dl_ixIJe.js";
 import { i as getNodeSchema, l as registerNode } from "./registry-BVJ2HbCn.js";
-import { AdditiveBlending, CanvasTexture, Color, DynamicDrawUsage, Group, InstancedMesh, MathUtils, Matrix4, Mesh, MeshBasicMaterial, NormalBlending, Object3D, PlaneGeometry } from "three";
+import { i as applyParticlePreset, o as effectiveOrder, r as PARTICLE_PRESET_NAMES, t as ParticleSim } from "./particle-sim-CyUU7HVU.js";
+import { AdditiveBlending, BufferAttribute, BufferGeometry, CanvasTexture, Color, DynamicDrawUsage, Group, InstancedMesh, MathUtils, Matrix4, Mesh, MeshBasicMaterial, NearestFilter, NormalBlending, Object3D, PlaneGeometry } from "three";
 //#region src/2d/physics/collider-validate.ts
 /**
 * Hard-validate a 2D collider prop — called at LOAD time (via the loader's
@@ -15,6 +15,7 @@ import { AdditiveBlending, CanvasTexture, Color, DynamicDrawUsage, Group, Instan
 function validateCollider2D(collider, nodeName) {
 	const shape = collider.shape;
 	if (shape === void 0) return;
+	if (collider.oneWay !== void 0 && typeof collider.oneWay !== "boolean") throw new IncantoError("BAD_FORMAT", `Collider on '${nodeName}': "oneWay" must be a boolean (platforms you jump up through), got ${JSON.stringify(collider.oneWay)}.`);
 	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].`);
@@ -874,6 +875,254 @@ const colorScratchA = new Color();
 const colorScratchB = new Color();
 const colorScratchC = new Color();
 //#endregion
+//#region src/2d/tilemap-grid.ts
+/**
+* Normalize the `cells` prop into an index grid. Two author formats:
+* - string rows: `"." `/`" "` = empty, digits `0-9` = tile index, anything
+*   else must be in `legend` (char → index). Unknown chars HARD-fail.
+* - number rows: passed through (`-1` = empty).
+* Ragged rows are right-padded with empty.
+*/
+function parseCells(cells, legend) {
+	const rows = [];
+	let width = 0;
+	for (const row of cells) {
+		const out = [];
+		if (typeof row === "string") for (const ch of row) {
+			const mapped = legend[ch];
+			if (mapped !== void 0) out.push(mapped);
+			else if (ch === "." || ch === " ") out.push(-1);
+			else if (ch >= "0" && ch <= "9") out.push(ch.charCodeAt(0) - 48);
+			else throw new IncantoError("BAD_FORMAT", `TileMap2D: unknown tile char '${ch}' — add it to "legend" (char → tile index), or use '.'/' ' for empty and digits 0-9.`);
+		}
+		else for (const v of row) out.push(v);
+		width = Math.max(width, out.length);
+		rows.push(out);
+	}
+	for (const row of rows) while (row.length < width) row.push(-1);
+	return rows;
+}
+/**
+* Greedy rectangle merge over the solid cells: maximal horizontal runs,
+* extended downward while the identical run repeats. A platform level's
+* hundreds of solid tiles collapse to a handful of colliders.
+*/
+function mergeSolidRects(grid, solid) {
+	const h = grid.length;
+	const w = h > 0 ? grid[0].length : 0;
+	const used = grid.map((row) => row.map(() => false));
+	const isSolid = (x, y) => solid.has(grid[y][x]);
+	const rects = [];
+	for (let y = 0; y < h; y++) for (let x = 0; x < w; x++) {
+		if (!isSolid(x, y) || used[y][x]) continue;
+		let runW = 1;
+		while (x + runW < w && isSolid(x + runW, y) && !used[y][x + runW]) runW++;
+		let runH = 1;
+		grow: while (y + runH < h) {
+			for (let i = 0; i < runW; i++) if (!isSolid(x + i, y + runH) || used[y + runH][x + i]) break grow;
+			runH++;
+		}
+		for (let dy = 0; dy < runH; dy++) for (let i = 0; i < runW; i++) used[y + dy][x + i] = true;
+		rects.push({
+			x,
+			y,
+			w: runW,
+			h: runH
+		});
+	}
+	return rects;
+}
+//#endregion
+//#region src/2d/nodes/tile-map-2d.ts
+/**
+* A whole tile level as ONE node — grid render in a single draw call plus
+* greedy-merged static colliders. Author the level as rows of characters:
+*
+*   { "name": "Level", "type": "TileMap2D", "props": {
+*       "texture": "$tiles", "tileSize": 32,
+*       "cells": [
+*         "..................",
+*         "......111.........",
+*         "000000000000000000"
+*       ],
+*       "solid": [0, 1] } }
+*
+* `.` / space = empty, digits 0-9 = atlas tile index, other chars map through
+* `legend` (e.g. `{"G": 12}`). The atlas is read left-to-right, top-to-bottom
+* in `tileSize` squares. Tiles listed in `solid` become static colliders,
+* greedy-merged into a few rectangles (hundreds of cells → a handful of
+* bodies). Cell (0,0) renders with its TOP-LEFT on this node's origin.
+*/
+var TileMap2D = class extends Node2D {
+	static typeName = "TileMap2D";
+	static props = {
+		/** Atlas texture asset ref; tiles are tileSize×tileSize squares in it. */
+		texture: { default: "" },
+		tileSize: { default: 32 },
+		/** Atlas columns; 0 = derive from the texture width. */
+		columns: { default: 0 },
+		/** Rows of chars (or number arrays, -1 empty). */
+		cells: { default: [] },
+		/** char → atlas tile index for non-digit chars. */
+		legend: { default: {} },
+		/** Tile indices that get merged static colliders. */
+		solid: { default: [] },
+		opacity: { default: 1 }
+	};
+	texture = "";
+	tileSize = 32;
+	columns = 0;
+	_cells = [];
+	_legend = {};
+	_solid = [];
+	/** Rebuild flags — raised when the map-shaping props are REPLACED. */
+	geometryDirty = true;
+	collidersDirty = true;
+	/** Replace the whole array to change the map (mutations are not watched). */
+	get cells() {
+		return this._cells;
+	}
+	set cells(value) {
+		this._cells = value;
+		this.geometryDirty = true;
+		this.collidersDirty = true;
+	}
+	get legend() {
+		return this._legend;
+	}
+	set legend(value) {
+		this._legend = value;
+		this.geometryDirty = true;
+		this.collidersDirty = true;
+	}
+	get solid() {
+		return this._solid;
+	}
+	set solid(value) {
+		this._solid = value;
+		this.collidersDirty = true;
+	}
+	opacity = 1;
+	tileMesh = null;
+	builtColumns = 0;
+	builtRows = 0;
+	/** Loader hook: bad cells fail at LOAD (unknown chars), not at render. */
+	static validateJson(node) {
+		const map = node;
+		parseCells(map._cells, map._legend);
+	}
+	/** The parsed index grid (test/tooling hook). */
+	grid() {
+		return parseCells(this._cells, this._legend);
+	}
+	onReady() {
+		this.rebuildColliders();
+	}
+	update(_dt) {
+		if (this.collidersDirty) this.rebuildColliders();
+	}
+	rebuildColliders() {
+		this.collidersDirty = false;
+		for (const child of [...this.children]) if (child.name.startsWith("__tileSolid")) child.free();
+		if (this._solid.length === 0) return;
+		const ts = this.tileSize;
+		mergeSolidRects(this.grid(), new Set(this._solid)).forEach((r, i) => {
+			const body = new StaticBody2D(`__tileSolid${i}`);
+			body.position = [(r.x + r.w / 2) * ts, (r.y + r.h / 2) * ts];
+			body.collider = {
+				shape: "rect",
+				size: [r.w * ts, r.h * ts]
+			};
+			this.addChild(body);
+		});
+	}
+	/** @internal The drawable mesh (lazily created under the backing object). */
+	_mesh() {
+		if (!this.tileMesh) {
+			this.tileMesh = new Mesh(new BufferGeometry(), new MeshBasicMaterial({
+				transparent: true,
+				depthWrite: false
+			}));
+			this._ensureObject2D().add(this.tileMesh);
+		}
+		return this.tileMesh;
+	}
+	_syncObject2D(assets) {
+		super._syncObject2D(assets);
+		const mesh = this._mesh();
+		const mat = mesh.material;
+		if (!this.texture || !assets) {
+			mesh.visible = false;
+			return;
+		}
+		const texture = assets.getTexture(this.texture);
+		const image = texture.image;
+		if (!image?.width || !image.height) {
+			mesh.visible = false;
+			return;
+		}
+		mesh.visible = this.opacity > 0;
+		mesh.renderOrder = this.effectiveRenderOrder;
+		mat.opacity = this.opacity;
+		if (mat.map !== texture) {
+			texture.magFilter = NearestFilter;
+			mat.map = texture;
+			mat.needsUpdate = true;
+			this.geometryDirty = true;
+		}
+		const columns = this.columns > 0 ? this.columns : Math.max(1, Math.floor(image.width / this.tileSize));
+		const atlasRows = Math.max(1, Math.floor(image.height / this.tileSize));
+		if (columns !== this.builtColumns || atlasRows !== this.builtRows) this.geometryDirty = true;
+		if (!this.geometryDirty) return;
+		this.geometryDirty = false;
+		this.builtColumns = columns;
+		this.builtRows = atlasRows;
+		this.buildGeometry(mesh.geometry, columns, atlasRows);
+	}
+	/** One quad per visible tile, atlas UVs — a single draw call for the level. */
+	buildGeometry(geometry, columns, atlasRows) {
+		const grid = this.grid();
+		const ts = this.tileSize;
+		const positions = [];
+		const uvs = [];
+		const indices = [];
+		for (let y = 0; y < grid.length; y++) {
+			const row = grid[y];
+			for (let x = 0; x < row.length; x++) {
+				const tile = row[x];
+				if (tile < 0) continue;
+				const x0 = x * ts;
+				const x1 = x0 + ts;
+				const y0 = -(y * ts);
+				const y1 = -((y + 1) * ts);
+				const base = positions.length / 3;
+				positions.push(x0, y0, 0, x1, y0, 0, x1, y1, 0, x0, y1, 0);
+				const col = tile % columns;
+				const rowIdx = Math.floor(tile / columns);
+				const u0 = col / columns;
+				const u1 = (col + 1) / columns;
+				const v0 = 1 - rowIdx / atlasRows;
+				const v1 = 1 - (rowIdx + 1) / atlasRows;
+				uvs.push(u0, v0, u1, v0, u1, v1, u0, v1);
+				indices.push(base, base + 2, base + 1, base, base + 3, base + 2);
+			}
+		}
+		geometry.setAttribute("position", new BufferAttribute(new Float32Array(positions), 3));
+		geometry.setAttribute("uv", new BufferAttribute(new Float32Array(uvs), 2));
+		geometry.setIndex(indices);
+		geometry.computeBoundingSphere();
+	}
+	/** Test hook: rendered tile count (quads in the built geometry). */
+	get renderedTileCount() {
+		const pos = this.tileMesh?.geometry.getAttribute("position");
+		return pos ? pos.count / 4 : 0;
+	}
+	free() {
+		this.tileMesh?.geometry.dispose();
+		super.free();
+	}
+};
+//#endregion
 //#region src/2d/nodes/ui-layer.ts
 const ANCHORS = [
 	"top-left",
@@ -949,6 +1198,7 @@ function registerNodes2D() {
 	registerNode(CharacterBody2D);
 	registerNode(CharacterController2D);
 	registerNode(Joint2D);
+	registerNode(TileMap2D);
 }
 //#endregion
-export { validateCollider2D as _, ColorRect2D as a, AnimatedSprite2D as c, Area2D as d, CharacterBody2D as f, Node2D as g, StaticBody2D as h, Label as i, Sprite2D as l, RigidBody2D as m, UILayer as n, CharacterController2D as o, PhysicsBody2D as p, Particles2D as r, Camera2D as s, registerNodes2D as t, Joint2D as u };
+export { RigidBody2D as _, parseCells as a, validateCollider2D as b, ColorRect2D as c, AnimatedSprite2D as d, Sprite2D as f, PhysicsBody2D as g, CharacterBody2D as h, mergeSolidRects as i, CharacterController2D as l, Area2D as m, UILayer as n, Particles2D as o, Joint2D as p, TileMap2D as r, Label as s, registerNodes2D as t, Camera2D as u, StaticBody2D as v, Node2D as y };

package/dist/{register-C35HDZpm.js → register-Cwc-yCYx.js}

@@ -1,6 +1,6 @@
 import { f as Node, t as buildNodeJson, y as Signal } from "./loader-B4OEXDZ8.js";
+import { t as registerCoreNodes } from "./register-DJZXxwAn.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
-import { t as registerCoreNodes } from "./register-Dl_ixIJe.js";
 import { n as jsonEquals, t as jsonClone } from "./json-BLk7H2Qa.js";
 import { l as registerNode } from "./registry-BVJ2HbCn.js";
 //#region src/net/network-manager.ts