incanto 0.7.1 → 0.8.0

package/dist/{register-Cl3pAxX-.js → register-Cqjxrfq0.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-DRPIjrKG.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-CxmuI9FL.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-DRPIjrKG.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