@v12-engine/engine 0.1.0 → 0.4.0

package/dist/navigation/groundAreas.js

@@ -0,0 +1,407 @@
+import { ChunkIdsArray, Detour, DetourTileCacheParams, NavMesh, NavMeshParams, Raw, RecastBuildContext, RecastChunkyTriMesh, TileCache, TileCacheData, TileCacheMeshProcess, TriangleAreasArray, TrianglesArray, VerticesArray, allocCompactHeightfield, allocHeightfield, allocHeightfieldLayerSet, buildCompactHeightfield, buildHeightfieldLayers, buildTileCacheLayer, calcGridSize, cloneRcConfig, createHeightfield, createRcConfig, erodeWalkableArea, filterLedgeSpans, filterLowHangingWalkableObstacles, filterWalkableLowHeightSpans, freeCompactHeightfield, freeHeightfield, freeHeightfieldLayerSet, getHeightfieldLayerAreas, getHeightfieldLayerCons, getHeightfieldLayerHeights, markWalkableTriangles, rasterizeTriangles, recastConfigDefaults, statusFailed, vec3 } from "@recast-navigation/core";
+import { dtIlog2, dtNextPow2, getBoundingBox } from "@recast-navigation/generators";
+//#region src/navigation/groundAreas.ts
+/** The areas of slow (or quick) ground: a speed in steps of a sixteenth, 1..62. 0 is ordinary ground, 63 Recast's walkable */
+var STEPS = 16;
+var WALKABLE = 63;
+/** The area of ground of this speed: 0 for ordinary ground, else its speed in sixteenths, 1 at the least and 62 at the most */
+function areaOfSpeed(speed) {
+	if (speed === 1 || !(speed >= 0)) return 0;
+	const steps = Math.round(speed * STEPS);
+	return steps === STEPS ? 0 : Math.min(Math.max(steps, 1), 62);
+}
+/** What a path pays for each area of slow ground, on a filter: `1 / speed`, ordinary ground 1 */
+function setAreaCosts(filter) {
+	for (let area = 1; area < WALKABLE; area++) filter.setAreaCost(area, STEPS / area);
+}
+/** The speed of a cell of a build's grid: 1 off it, or with no grid */
+function speedOfBuild(speeds, x, z) {
+	if (!speeds) return 1;
+	const column = Math.floor(x);
+	const row = Math.floor(z);
+	if (column < 0 || row < 0 || column >= speeds.width || row >= speeds.depth) return 1;
+	return speeds.values[row * speeds.width + column];
+}
+/**
+* What makes a tile's polygons, as Recast's tile cache asks: each walkable (flags 1), its area the speed of the ground
+* under its middle (`speedAt`). Without one, every polygon is ordinary ground, as Recast's default makes them
+*/
+function groundMeshProcess(speedAt) {
+	return new TileCacheMeshProcess((params, polyAreas, polyFlags) => {
+		const count = params.polyCount();
+		if (!speedAt) {
+			for (let i = 0; i < count; i++) {
+				polyAreas.set(i, 0);
+				polyFlags.set(i, 1);
+			}
+			return;
+		}
+		const nvp = params.nvp();
+		const raw = params.raw;
+		const cs = raw.cs;
+		const originX = raw.get_bmin(0);
+		const originZ = raw.get_bmin(2);
+		for (let i = 0; i < count; i++) {
+			let x = 0;
+			let z = 0;
+			let corners = 0;
+			for (let j = 0; j < nvp; j++) {
+				const vertex = params.polys(i * nvp * 2 + j);
+				if (vertex === 65535) break;
+				x += params.verts(vertex * 3);
+				z += params.verts(vertex * 3 + 2);
+				corners++;
+			}
+			const speed = corners ? speedAt(originX + x / corners * cs, originZ + z / corners * cs) : 1;
+			polyAreas.set(i, areaOfSpeed(speed));
+			polyFlags.set(i, 1);
+		}
+	});
+}
+/** How a build is cut into tiles, as Recast's `generateTileCache` works it out */
+function tileCutOf(build) {
+	const { bbMin, bbMax } = getBoundingBox(build.positions, build.indices);
+	const { expectedLayersPerTile, maxObstacles, ...recastConfig } = {
+		...recastConfigDefaults,
+		...build.config
+	};
+	const config = createRcConfig(recastConfig);
+	const gridSize = calcGridSize(bbMin, bbMax, config.cs);
+	config.width = gridSize.width;
+	config.height = gridSize.height;
+	config.minRegionArea = config.minRegionArea * config.minRegionArea;
+	config.mergeRegionArea = config.mergeRegionArea * config.mergeRegionArea;
+	config.detailSampleDist = config.detailSampleDist < .9 ? 0 : config.cs * config.detailSampleDist;
+	config.detailSampleMaxError = config.ch * config.detailSampleMaxError;
+	const tileSize = Math.floor(config.tileSize);
+	const tileWidth = Math.floor((config.width + tileSize - 1) / tileSize);
+	const tileHeight = Math.floor((config.height + tileSize - 1) / tileSize);
+	config.borderSize = config.walkableRadius + 3;
+	config.width = config.tileSize + config.borderSize * 2;
+	config.height = config.tileSize + config.borderSize * 2;
+	return {
+		config,
+		bbMin: [...bbMin],
+		bbMax: [...bbMax],
+		tileWidth,
+		tileHeight,
+		expectedLayersPerTile,
+		maxObstacles
+	};
+}
+/** The tile cache's parameters of a cut: room for every tile of it and its obstacles, or as much as `room` says */
+function tileCacheParamsOf({ config, bbMin, tileWidth, tileHeight, expectedLayersPerTile, maxObstacles }, room) {
+	return DetourTileCacheParams.create({
+		orig: bbMin,
+		cs: config.cs,
+		ch: config.ch,
+		width: config.tileSize,
+		height: config.tileSize,
+		walkableHeight: config.walkableHeight * config.ch,
+		walkableRadius: config.walkableRadius * config.cs,
+		walkableClimb: config.walkableClimb * config.ch,
+		maxSimplificationError: config.maxSimplificationError,
+		maxTiles: room?.tiles ?? tileWidth * tileHeight * expectedLayersPerTile,
+		maxObstacles: room?.obstacles ?? maxObstacles
+	});
+}
+/**
+* What rasterises the tiles of a build into their compressed layers, from the triangles given (indices into its
+* positions, three to a triangle; all of them when left out): a tile is made of the triangles under it and its border,
+* so a tile made from fewer triangles, those that reach it among them, is the same tile. Undefined where its triangles
+* could not be sorted into chunks
+*/
+function tileRasterizer(build, cut, compressor, chunked = true, speedOf = build.speeds && ((x, z) => speedOfBuild(build.speeds, x, z))) {
+	const { positions } = build;
+	const { config, bbMin, bbMax } = cut;
+	const buildContext = new RecastBuildContext();
+	const verticesArray = new VerticesArray();
+	verticesArray.copy(positions);
+	const numVertices = build.indices.length;
+	const trianglesArray = new TrianglesArray();
+	const chunkyTriMesh = new RecastChunkyTriMesh();
+	const destroy = () => {
+		verticesArray.destroy();
+		trianglesArray.destroy();
+	};
+	if (chunked) {
+		trianglesArray.copy(build.indices);
+		if (!chunkyTriMesh.init(verticesArray, trianglesArray, build.indices.length / 3, 256)) {
+			destroy();
+			return;
+		}
+	}
+	/** The speed's area of the `t`th triangle of a chunk (its corners, as indices of the ground's vertices), by its middle */
+	const areaOf = (corners, t) => {
+		let x = 0;
+		let z = 0;
+		for (let k = 0; k < 3; k++) {
+			const vertex = corners.get(t * 3 + k);
+			x += positions[vertex * 3];
+			z += positions[vertex * 3 + 2];
+		}
+		const speed = speedOf(x / 3, z / 3);
+		if (speed < 0) return 0;
+		const area = areaOfSpeed(speed);
+		return area === 0 ? WALKABLE : area;
+	};
+	/** Marks a run of triangles walkable (with their speeds) and rasterises them into the heightfield: false where Recast could not */
+	const rasterizeRun = (tileConfig, heightfield, tris, count) => {
+		const areas = new TriangleAreasArray();
+		areas.resize(count);
+		markWalkableTriangles(buildContext, tileConfig.walkableSlopeAngle, verticesArray, numVertices, tris, count, areas);
+		if (speedOf) {
+			for (let t = 0; t < count; t++) if (areas.get(t) === WALKABLE) areas.set(t, areaOf(tris, t));
+		}
+		const rasterized = rasterizeTriangles(buildContext, verticesArray, numVertices, tris, areas, count, heightfield, tileConfig.walkableClimb);
+		areas.destroy();
+		return rasterized;
+	};
+	const rasterize = (tileX, tileY, own) => {
+		const tcs = config.tileSize * config.cs;
+		const tileConfig = cloneRcConfig(config);
+		const tileBoundsMin = [
+			bbMin[0] + tileX * tcs - config.borderSize * config.cs,
+			bbMin[1],
+			bbMin[2] + tileY * tcs - config.borderSize * config.cs
+		];
+		const tileBoundsMax = [
+			bbMin[0] + (tileX + 1) * tcs + config.borderSize * config.cs,
+			bbMax[1],
+			bbMin[2] + (tileY + 1) * tcs + config.borderSize * config.cs
+		];
+		for (let i = 0; i < 3; i++) {
+			tileConfig.set_bmin(i, tileBoundsMin[i]);
+			tileConfig.set_bmax(i, tileBoundsMax[i]);
+		}
+		const heightfield = allocHeightfield();
+		if (!createHeightfield(buildContext, heightfield, tileConfig.width, tileConfig.height, tileBoundsMin, tileBoundsMax, tileConfig.cs, tileConfig.ch)) {
+			freeHeightfield(heightfield);
+			return [];
+		}
+		if (own) {
+			if (own.length) {
+				trianglesArray.copy(own);
+				if (!rasterizeRun(tileConfig, heightfield, trianglesArray, own.length / 3)) {
+					freeHeightfield(heightfield);
+					return [];
+				}
+			}
+		} else {
+			const maxChunkIds = 512;
+			const chunkIdsArray = new ChunkIdsArray();
+			chunkIdsArray.resize(maxChunkIds);
+			const overlapping = chunkyTriMesh.getChunksOverlappingRect([tileBoundsMin[0], tileBoundsMin[2]], [tileBoundsMax[0], tileBoundsMax[2]], chunkIdsArray, maxChunkIds);
+			for (let i = 0; i < overlapping; ++i) {
+				const nodeId = chunkIdsArray.get(i);
+				if (!rasterizeRun(tileConfig, heightfield, chunkyTriMesh.getNodeTris(nodeId), chunkyTriMesh.nodes(nodeId).n)) {
+					chunkIdsArray.destroy();
+					freeHeightfield(heightfield);
+					return [];
+				}
+			}
+			chunkIdsArray.destroy();
+		}
+		filterLowHangingWalkableObstacles(buildContext, config.walkableClimb, heightfield);
+		filterLedgeSpans(buildContext, config.walkableHeight, config.walkableClimb, heightfield);
+		filterWalkableLowHeightSpans(buildContext, config.walkableHeight, heightfield);
+		const compactHeightfield = allocCompactHeightfield();
+		const compacted = buildCompactHeightfield(buildContext, config.walkableHeight, config.walkableClimb, heightfield, compactHeightfield);
+		freeHeightfield(heightfield);
+		if (!compacted || !erodeWalkableArea(buildContext, config.walkableRadius, compactHeightfield)) {
+			freeCompactHeightfield(compactHeightfield);
+			return [];
+		}
+		const layerSet = allocHeightfieldLayerSet();
+		const layered = buildHeightfieldLayers(buildContext, compactHeightfield, config.borderSize, config.walkableHeight, layerSet);
+		freeCompactHeightfield(compactHeightfield);
+		if (!layered) {
+			freeHeightfieldLayerSet(layerSet);
+			return [];
+		}
+		const tiles = [];
+		for (let i = 0; i < layerSet.nlayers(); i++) {
+			const tile = new TileCacheData();
+			const layer = layerSet.layers(i);
+			const header = new Raw.dtTileCacheLayerHeader();
+			header.magic = Detour.DT_TILECACHE_MAGIC;
+			header.version = Detour.DT_TILECACHE_VERSION;
+			header.tx = tileX;
+			header.ty = tileY;
+			header.tlayer = i;
+			const min = layer.bmin();
+			const max = layer.bmax();
+			header.set_bmin(0, min.x);
+			header.set_bmin(1, min.y);
+			header.set_bmin(2, min.z);
+			header.set_bmax(0, max.x);
+			header.set_bmax(1, max.y);
+			header.set_bmax(2, max.z);
+			header.width = layer.width();
+			header.height = layer.height();
+			header.minx = layer.minx();
+			header.maxx = layer.maxx();
+			header.miny = layer.miny();
+			header.maxy = layer.maxy();
+			header.hmin = layer.hmin();
+			header.hmax = layer.hmax();
+			const status = buildTileCacheLayer(compressor, header, getHeightfieldLayerHeights(layer), getHeightfieldLayerAreas(layer), getHeightfieldLayerCons(layer), tile);
+			if (statusFailed(status)) break;
+			tiles.push(tile);
+		}
+		freeHeightfieldLayerSet(layerSet);
+		return tiles;
+	};
+	return {
+		rasterize,
+		destroy
+	};
+}
+/**
+* Builds a tile cache and its navmesh from a build, as Recast's `generateTileCache` does, but with each triangle of the
+* ground marked with its cell's speed (`NavigationBuild.speeds`) before it is rasterised. What it gives is Recast's own;
+* the caller exports and lets go of it
+*/
+function generateGroundTileCache(build) {
+	const { speeds } = build;
+	const tileCache = new TileCache();
+	const navMesh = new NavMesh();
+	const process = groundMeshProcess((x, z) => speedOfBuild(speeds, x, z));
+	const cut = tileCutOf(build);
+	const { config, bbMin, tileWidth, tileHeight, expectedLayersPerTile } = cut;
+	let rasterizer;
+	const fail = (error) => {
+		rasterizer?.destroy();
+		tileCache.destroy();
+		navMesh.destroy();
+		throw new Error(`Navmesh generation failed: ${error}`);
+	};
+	const allocator = new Raw.RecastLinearAllocator(32e3);
+	const compressor = new Raw.RecastFastLZCompressor();
+	if (!tileCache.init(tileCacheParamsOf(cut), allocator, compressor, process)) fail("Failed to initialize tile cache");
+	const tileBits = Math.min(Math.floor(dtIlog2(dtNextPow2(tileWidth * tileHeight * expectedLayersPerTile))), 14);
+	const navMeshParams = NavMeshParams.create({
+		orig: vec3.fromArray(bbMin),
+		tileWidth: config.tileSize * config.cs,
+		tileHeight: config.tileSize * config.cs,
+		maxTiles: 1 << tileBits,
+		maxPolys: 1 << 22 - tileBits
+	});
+	if (!navMesh.initTiled(navMeshParams)) fail("Failed to initialize tiled navmesh");
+	rasterizer = tileRasterizer(build, cut, compressor);
+	if (!rasterizer) return fail("Failed to build chunky triangle mesh");
+	for (let y = 0; y < tileHeight; ++y) for (let x = 0; x < tileWidth; ++x) for (const tile of rasterizer.rasterize(x, y)) tileCache.addTile(tile);
+	for (let y = 0; y < tileHeight; y++) for (let x = 0; x < tileWidth; x++) if (statusFailed(tileCache.buildNavMeshTilesAt(x, y, navMesh))) fail(`Failed to build nav mesh tiles at ${x}, ${y}`);
+	rasterizer.destroy();
+	return {
+		navMesh,
+		tileCache,
+		process
+	};
+}
+/** A tile of the grid by its column and row: `tx * 65536 + ty` */
+var tileKey = (tx, ty) => tx * 65536 + ty;
+/**
+* Some tiles of a build made again (`RecastNavigation.reshape`): each tile's compressed layers, made as
+* `generateGroundTileCache` makes them, from the triangles that reach it. Also the bounds of the whole build, for the
+* caller to know the tiles are cut on the grid it has (a build of other bounds is cut on another). `speedOf` is the speed
+* of the ground at a point where the build has no speeds of its own (a part of the ground, `RecastNavigation.groundChanged`).
+* Undefined where they could not be made
+*/
+function groundTileLayers(build, tiles, cut = tileCutOf(build), speedOf) {
+	const { config, bbMin, tileWidth, tileHeight } = cut;
+	const tcs = config.tileSize * config.cs;
+	const border = config.borderSize * config.cs;
+	const own = new Map(tiles.map((key) => [key, []]));
+	const { positions, indices } = build;
+	for (let t = 0; t < indices.length; t += 3) {
+		let x0 = Infinity;
+		let x1 = -Infinity;
+		let z0 = Infinity;
+		let z1 = -Infinity;
+		for (let k = 0; k < 3; k++) {
+			const v = indices[t + k] * 3;
+			x0 = Math.min(x0, positions[v]);
+			x1 = Math.max(x1, positions[v]);
+			z0 = Math.min(z0, positions[v + 2]);
+			z1 = Math.max(z1, positions[v + 2]);
+		}
+		const tx0 = Math.max(0, Math.floor((x0 - border - bbMin[0]) / tcs));
+		const tx1 = Math.min(tileWidth - 1, Math.floor((x1 + border - bbMin[0]) / tcs));
+		const ty0 = Math.max(0, Math.floor((z0 - border - bbMin[2]) / tcs));
+		const ty1 = Math.min(tileHeight - 1, Math.floor((z1 + border - bbMin[2]) / tcs));
+		for (let tx = tx0; tx <= tx1; tx++) for (let ty = ty0; ty <= ty1; ty++) own.get(tileKey(tx, ty))?.push(indices[t], indices[t + 1], indices[t + 2]);
+	}
+	const made = /* @__PURE__ */ new Map();
+	const compressor = new Raw.RecastFastLZCompressor();
+	const rasterizer = speedOf ? tileRasterizer(build, cut, compressor, false, speedOf) : tileRasterizer(build, cut, compressor, false);
+	if (!rasterizer) {
+		Raw.destroy(compressor);
+		return;
+	}
+	try {
+		for (const key of tiles) {
+			const layers = rasterizer.rasterize(Math.floor(key / 65536), key % 65536, Uint32Array.from(own.get(key)));
+			made.set(key, layers.map((layer) => {
+				const bytes = layer.toTypedArray().slice();
+				layer.destroy();
+				return bytes;
+			}));
+		}
+	} finally {
+		rasterizer.destroy();
+		Raw.destroy(compressor);
+	}
+	return made;
+}
+/**
+* The grid a build is cut on: its bounds and its tiles across and down. A build of the same grid as another's is cut
+* into the same tiles, so a tile of one may be made again alone from the other (`groundTileLayers`)
+*/
+function tileGridOf(build) {
+	const cut = tileCutOf(build);
+	const { bbMin, bbMax, tileWidth, tileHeight, config } = cut;
+	return {
+		bbMin,
+		bbMax,
+		tileWidth,
+		tileHeight,
+		tileSize: config.tileSize * config.cs,
+		border: config.borderSize * config.cs,
+		cut
+	};
+}
+/**
+* A tile cache of the grid a build is cut on (`tileGridOf`), empty, with room for `room`'s tiles and obstacles: what
+* a column of tiles made again alone is made into the navmesh's tiles through (`RecastNavigation.groundChanged`,
+* `reshape`), as the whole's tile cache would make them. It works in the allocator and compressor given (the whole's:
+* a tile is made in one call, and each starts the allocator over), which it does not take. Undefined where Recast
+* would not make it
+*/
+function columnTileCache(cut, process, room, allocator, compressor) {
+	const tileCache = new TileCache();
+	const params = tileCacheParamsOf(cut, room);
+	const made = tileCache.init(params, allocator, compressor, process);
+	Raw.destroy(params.raw);
+	if (made) return tileCache;
+	tileCache.destroy();
+}
+/**
+* Puts a compressed layer (`groundTileLayers`) in a tile cache, which does not take it: its copy is given back, to be let
+* go of (`destroy`) once the tile cache is. Undefined where the tile cache would not take it
+*/
+function addTileLayer(tileCache, bytes) {
+	const data = new TileCacheData();
+	data.copy(bytes);
+	if (!statusFailed(tileCache.addTile(data, 0).status)) return data;
+	data.destroy();
+}
+/**
+* Which layer of its column a compressed layer (`groundTileLayers`) is: the navmesh's tile made of it is at that layer.
+* Its header (Detour's `dtTileCacheLayerHeader`) leads it uncompressed: magic, version, tx, ty, then the layer, each an int
+*/
+var layerOf = (bytes) => new DataView(bytes.buffer, bytes.byteOffset, 20).getInt32(16, true);
+//#endregion
+export { addTileLayer, areaOfSpeed, columnTileCache, generateGroundTileCache, groundMeshProcess, groundTileLayers, layerOf, setAreaCosts, speedOfBuild, tileGridOf, tileKey };
+
+//# sourceMappingURL=groundAreas.js.map

package/dist/navigation/groundAreas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"groundAreas.js","names":[],"sources":["../../src/navigation/groundAreas.ts"],"sourcesContent":["import {\n\tallocCompactHeightfield,\n\tallocHeightfield,\n\tallocHeightfieldLayerSet,\n\tbuildCompactHeightfield,\n\tbuildHeightfieldLayers,\n\tbuildTileCacheLayer,\n\tcalcGridSize,\n\tChunkIdsArray,\n\tcloneRcConfig,\n\tcreateHeightfield,\n\tcreateRcConfig,\n\tDetour,\n\tDetourTileCacheParams,\n\terodeWalkableArea,\n\tfilterLedgeSpans,\n\tfilterLowHangingWalkableObstacles,\n\tfilterWalkableLowHeightSpans,\n\tfreeCompactHeightfield,\n\tfreeHeightfield,\n\tfreeHeightfieldLayerSet,\n\tgetHeightfieldLayerAreas,\n\tgetHeightfieldLayerCons,\n\tgetHeightfieldLayerHeights,\n\tmarkWalkableTriangles,\n\tNavMesh,\n\ttype NavMeshCreateParams,\n\tNavMeshParams,\n\ttype QueryFilter,\n\trasterizeTriangles,\n\tRaw,\n\tRecastBuildContext,\n\tRecastChunkyTriMesh,\n\trecastConfigDefaults,\n\tstatusFailed,\n\tTileCache,\n\tTileCacheData,\n\tTileCacheMeshProcess,\n\tTriangleAreasArray,\n\tTrianglesArray,\n\tvec3,\n\tVerticesArray\n} from '@recast-navigation/core'\nimport { dtIlog2, dtNextPow2, getBoundingBox } from '@recast-navigation/generators'\nimport type { NavigationBuild, NavigationSpeeds } from './builds'\n\n/*\n * Ground that slows, in the ways units are sent (EN2). A cell's speed (its tile's and its layers', `groundSpeedOfCell`)\n * is an area of the navigation's: each triangle of the ground is marked with its cell's as it is cut, so the\n * navigation's polygons part where the speed does, and a path weighs each polygon by `1 / speed` (`setAreaCosts`), so a\n * road around the mud wins when it is quicker. Ordinary ground (speed 1) is area 0 as it always was: a map without slow\n * ground is cut and walked exactly as before. Each polygon's area is the speed under its middle, worked out whenever a\n * tile is made (`groundMeshProcess`): as it is built, as it is read again, as a building comes or goes on it. Where a\n * slowing layer of cells changes in play (`RecastNavigation.groundChanged`), the tiles it reaches are cut again from the\n * ground with its speeds as they are now (`groundTileLayers`), as a world made or loaded now cuts them: made again only\n * from the layers they were first cut into, their polygons would part where the speed did then\n */\n\n/** The areas of slow (or quick) ground: a speed in steps of a sixteenth, 1..62. 0 is ordinary ground, 63 Recast's walkable */\nconst STEPS = 16\nconst WALKABLE = 63\n\n/** The area of ground of this speed: 0 for ordinary ground, else its speed in sixteenths, 1 at the least and 62 at the most */\nexport function areaOfSpeed(speed: number): number {\n\tif (speed === 1 || !(speed >= 0)) return 0\n\tconst steps = Math.round(speed * STEPS)\n\treturn steps === STEPS ? 0 : Math.min(Math.max(steps, 1), WALKABLE - 1)\n}\n\n/** What a path pays for each area of slow ground, on a filter: `1 / speed`, ordinary ground 1 */\nexport function setAreaCosts(filter: QueryFilter): void {\n\tfor (let area = 1; area < WALKABLE; area++) filter.setAreaCost(area, STEPS / area)\n}\n\n/** The speed of a cell of a build's grid: 1 off it, or with no grid */\nexport function speedOfBuild(speeds: NavigationSpeeds | undefined, x: number, z: number): number {\n\tif (!speeds) return 1\n\tconst column = Math.floor(x)\n\tconst row = Math.floor(z)\n\tif (column < 0 || row < 0 || column >= speeds.width || row >= speeds.depth) return 1\n\treturn speeds.values[row * speeds.width + column]\n}\n\n/**\n * What makes a tile's polygons, as Recast's tile cache asks: each walkable (flags 1), its area the speed of the ground\n * under its middle (`speedAt`). Without one, every polygon is ordinary ground, as Recast's default makes them\n */\nexport function groundMeshProcess(speedAt?: (x: number, z: number) => number): TileCacheMeshProcess {\n\treturn new TileCacheMeshProcess((params: NavMeshCreateParams, polyAreas, polyFlags) => {\n\t\tconst count = params.polyCount()\n\t\tif (!speedAt) {\n\t\t\tfor (let i = 0; i < count; i++) {\n\t\t\t\tpolyAreas.set(i, 0)\n\t\t\t\tpolyFlags.set(i, 1)\n\t\t\t}\n\t\t\treturn\n\t\t}\n\t\t// a polygon's corners, as indices into the tile's vertices (voxels from its corner), then as many for its neighbours\n\t\tconst nvp = params.nvp()\n\t\tconst raw = params.raw\n\t\tconst cs = raw.cs\n\t\tconst originX = raw.get_bmin(0)\n\t\tconst originZ = raw.get_bmin(2)\n\t\tfor (let i = 0; i < count; i++) {\n\t\t\tlet x = 0\n\t\t\tlet z = 0\n\t\t\tlet corners = 0\n\t\t\tfor (let j = 0; j < nvp; j++) {\n\t\t\t\tconst vertex = params.polys(i * nvp * 2 + j)\n\t\t\t\t// Recast's \"no more corners\"\n\t\t\t\tif (vertex === 0xffff) break\n\t\t\t\tx += params.verts(vertex * 3)\n\t\t\t\tz += params.verts(vertex * 3 + 2)\n\t\t\t\tcorners++\n\t\t\t}\n\t\t\tconst speed = corners ? speedAt(originX + (x / corners) * cs, originZ + (z / corners) * cs) : 1\n\t\t\tpolyAreas.set(i, areaOfSpeed(speed))\n\t\t\tpolyFlags.set(i, 1)\n\t\t}\n\t})\n}\n\n/** How a build is cut into tiles: Recast's config for one tile with its border, the bounds of the whole, the grid of tiles */\nexport interface TileCut {\n\tconfig: ReturnType<typeof createRcConfig>\n\tbbMin: [number, number, number]\n\tbbMax: [number, number, number]\n\t/** Tiles across and down */\n\ttileWidth: number\n\ttileHeight: number\n\texpectedLayersPerTile: number\n\tmaxObstacles: number\n}\n\n/** How a build is cut into tiles, as Recast's `generateTileCache` works it out */\nfunction tileCutOf(build: NavigationBuild): TileCut {\n\tconst { bbMin, bbMax } = getBoundingBox(build.positions as unknown as number[], build.indices as unknown as number[])\n\tconst { expectedLayersPerTile, maxObstacles, ...recastConfig } = { ...recastConfigDefaults, ...build.config }\n\tconst config = createRcConfig(recastConfig)\n\tconst gridSize = calcGridSize(bbMin, bbMax, config.cs)\n\tconfig.width = gridSize.width\n\tconfig.height = gridSize.height\n\tconfig.minRegionArea = config.minRegionArea * config.minRegionArea\n\tconfig.mergeRegionArea = config.mergeRegionArea * config.mergeRegionArea\n\tconfig.detailSampleDist = config.detailSampleDist < 0.9 ? 0 : config.cs * config.detailSampleDist\n\tconfig.detailSampleMaxError = config.ch * config.detailSampleMaxError\n\tconst tileSize = Math.floor(config.tileSize)\n\tconst tileWidth = Math.floor((config.width + tileSize - 1) / tileSize)\n\tconst tileHeight = Math.floor((config.height + tileSize - 1) / tileSize)\n\tconfig.borderSize = config.walkableRadius + 3\n\tconfig.width = config.tileSize + config.borderSize * 2\n\tconfig.height = config.tileSize + config.borderSize * 2\n\treturn { config, bbMin: [...bbMin] as TileCut['bbMin'], bbMax: [...bbMax] as TileCut['bbMax'], tileWidth, tileHeight, expectedLayersPerTile, maxObstacles }\n}\n\n/** The tile cache's parameters of a cut: room for every tile of it and its obstacles, or as much as `room` says */\nfunction tileCacheParamsOf(\n\t{ config, bbMin, tileWidth, tileHeight, expectedLayersPerTile, maxObstacles }: TileCut,\n\troom?: { tiles: number; obstacles: number }\n): DetourTileCacheParams {\n\treturn DetourTileCacheParams.create({\n\t\torig: bbMin,\n\t\tcs: config.cs,\n\t\tch: config.ch,\n\t\twidth: config.tileSize,\n\t\theight: config.tileSize,\n\t\twalkableHeight: config.walkableHeight * config.ch,\n\t\twalkableRadius: config.walkableRadius * config.cs,\n\t\twalkableClimb: config.walkableClimb * config.ch,\n\t\tmaxSimplificationError: config.maxSimplificationError,\n\t\tmaxTiles: room?.tiles ?? tileWidth * tileHeight * expectedLayersPerTile,\n\t\tmaxObstacles: room?.obstacles ?? maxObstacles\n\t})\n}\n\n/**\n * What rasterises the tiles of a build into their compressed layers, from the triangles given (indices into its\n * positions, three to a triangle; all of them when left out): a tile is made of the triangles under it and its border,\n * so a tile made from fewer triangles, those that reach it among them, is the same tile. Undefined where its triangles\n * could not be sorted into chunks\n */\nfunction tileRasterizer(\n\tbuild: NavigationBuild,\n\tcut: TileCut,\n\tcompressor: InstanceType<typeof Raw.RecastFastLZCompressor>,\n\t/** Sorted into Recast's chunks (all the build's triangles, for every tile), or none where each tile is given its own */\n\tchunked = true,\n\t/** The speed of the ground at a point, where it is not the build's own (`NavigationBuild.speeds`) */\n\tspeedOf: ((x: number, z: number) => number) | undefined = build.speeds && ((x, z) => speedOfBuild(build.speeds, x, z))\n): { rasterize(tileX: number, tileY: number, own?: Uint32Array): InstanceType<typeof TileCacheData>[]; destroy(): void } | undefined {\n\tconst { positions } = build\n\tconst { config, bbMin, bbMax } = cut\n\tconst buildContext = new RecastBuildContext()\n\tconst verticesArray = new VerticesArray()\n\tverticesArray.copy(positions as unknown as number[])\n\t// as Recast's own counts it: the number of indices of the whole build\n\tconst numVertices = build.indices.length\n\tconst trianglesArray = new TrianglesArray()\n\tconst chunkyTriMesh = new RecastChunkyTriMesh()\n\tconst destroy = () => {\n\t\tverticesArray.destroy()\n\t\ttrianglesArray.destroy()\n\t}\n\tif (chunked) {\n\t\ttrianglesArray.copy(build.indices as unknown as number[])\n\t\tif (!chunkyTriMesh.init(verticesArray, trianglesArray, build.indices.length / 3, 256)) {\n\t\t\tdestroy()\n\t\t\treturn undefined\n\t\t}\n\t}\n\n\t/** The speed's area of the `t`th triangle of a chunk (its corners, as indices of the ground's vertices), by its middle */\n\tconst areaOf = (corners: { get(index: number): number }, t: number) => {\n\t\tlet x = 0\n\t\tlet z = 0\n\t\tfor (let k = 0; k < 3; k++) {\n\t\t\tconst vertex = corners.get(t * 3 + k)\n\t\t\tx += positions[vertex * 3]\n\t\t\tz += positions[vertex * 3 + 2]\n\t\t}\n\t\tconst speed = speedOf!(x / 3, z / 3)\n\t\t// ground nobody on foot goes through (a thicket, `navigationSpeedOn`): left out, as a wall's is\n\t\tif (speed < 0) return 0\n\t\tconst area = areaOfSpeed(speed)\n\t\treturn area === 0 ? WALKABLE : area\n\t}\n\n\t/** Marks a run of triangles walkable (with their speeds) and rasterises them into the heightfield: false where Recast could not */\n\tconst rasterizeRun = (tileConfig: ReturnType<typeof cloneRcConfig>, heightfield: ReturnType<typeof allocHeightfield>, tris: InstanceType<typeof TrianglesArray>, count: number) => {\n\t\tconst areas = new TriangleAreasArray()\n\t\tareas.resize(count)\n\t\tmarkWalkableTriangles(buildContext, tileConfig.walkableSlopeAngle, verticesArray, numVertices, tris, count, areas)\n\t\t// what is walkable takes its cell's speed: the one change from Recast's own\n\t\tif (speedOf) for (let t = 0; t < count; t++) if (areas.get(t) === WALKABLE) areas.set(t, areaOf(tris, t))\n\t\tconst rasterized = rasterizeTriangles(buildContext, verticesArray, numVertices, tris, areas, count, heightfield, tileConfig.walkableClimb)\n\t\tareas.destroy()\n\t\treturn rasterized\n\t}\n\n\tconst rasterize = (tileX: number, tileY: number, own?: Uint32Array): InstanceType<typeof TileCacheData>[] => {\n\t\tconst tcs = config.tileSize * config.cs\n\t\tconst tileConfig = cloneRcConfig(config)\n\t\tconst tileBoundsMin: [number, number, number] = [\n\t\t\tbbMin[0] + tileX * tcs - config.borderSize * config.cs,\n\t\t\tbbMin[1],\n\t\t\tbbMin[2] + tileY * tcs - config.borderSize * config.cs\n\t\t]\n\t\tconst tileBoundsMax: [number, number, number] = [\n\t\t\tbbMin[0] + (tileX + 1) * tcs + config.borderSize * config.cs,\n\t\t\tbbMax[1],\n\t\t\tbbMin[2] + (tileY + 1) * tcs + config.borderSize * config.cs\n\t\t]\n\t\tfor (let i = 0; i < 3; i++) {\n\t\t\ttileConfig.set_bmin(i, tileBoundsMin[i])\n\t\t\ttileConfig.set_bmax(i, tileBoundsMax[i])\n\t\t}\n\t\tconst heightfield = allocHeightfield()\n\t\tif (\n\t\t\t!createHeightfield(buildContext, heightfield, tileConfig.width, tileConfig.height, tileBoundsMin, tileBoundsMax, tileConfig.cs, tileConfig.ch)\n\t\t) {\n\t\t\tfreeHeightfield(heightfield)\n\t\t\treturn []\n\t\t}\n\t\tif (own) {\n\t\t\t// the tile's own triangles, as one run\n\t\t\tif (own.length) {\n\t\t\t\ttrianglesArray.copy(own as unknown as number[])\n\t\t\t\tif (!rasterizeRun(tileConfig, heightfield, trianglesArray, own.length / 3)) {\n\t\t\t\t\tfreeHeightfield(heightfield)\n\t\t\t\t\treturn []\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tconst maxChunkIds = 512\n\t\t\tconst chunkIdsArray = new ChunkIdsArray()\n\t\t\tchunkIdsArray.resize(maxChunkIds)\n\t\t\tconst overlapping = chunkyTriMesh.getChunksOverlappingRect(\n\t\t\t\t[tileBoundsMin[0], tileBoundsMin[2]],\n\t\t\t\t[tileBoundsMax[0], tileBoundsMax[2]],\n\t\t\t\tchunkIdsArray,\n\t\t\t\tmaxChunkIds\n\t\t\t)\n\t\t\tfor (let i = 0; i < overlapping; ++i) {\n\t\t\t\tconst nodeId = chunkIdsArray.get(i)\n\t\t\t\tif (!rasterizeRun(tileConfig, heightfield, chunkyTriMesh.getNodeTris(nodeId), chunkyTriMesh.nodes(nodeId).n)) {\n\t\t\t\t\tchunkIdsArray.destroy()\n\t\t\t\t\tfreeHeightfield(heightfield)\n\t\t\t\t\treturn []\n\t\t\t\t}\n\t\t\t}\n\t\t\tchunkIdsArray.destroy()\n\t\t}\n\t\tfilterLowHangingWalkableObstacles(buildContext, config.walkableClimb, heightfield)\n\t\tfilterLedgeSpans(buildContext, config.walkableHeight, config.walkableClimb, heightfield)\n\t\tfilterWalkableLowHeightSpans(buildContext, config.walkableHeight, heightfield)\n\t\tconst compactHeightfield = allocCompactHeightfield()\n\t\tconst compacted = buildCompactHeightfield(buildContext, config.walkableHeight, config.walkableClimb, heightfield, compactHeightfield)\n\t\tfreeHeightfield(heightfield)\n\t\tif (!compacted || !erodeWalkableArea(buildContext, config.walkableRadius, compactHeightfield)) {\n\t\t\tfreeCompactHeightfield(compactHeightfield)\n\t\t\treturn []\n\t\t}\n\t\tconst layerSet = allocHeightfieldLayerSet()\n\t\tconst layered = buildHeightfieldLayers(buildContext, compactHeightfield, config.borderSize, config.walkableHeight, layerSet)\n\t\tfreeCompactHeightfield(compactHeightfield)\n\t\tif (!layered) {\n\t\t\tfreeHeightfieldLayerSet(layerSet)\n\t\t\treturn []\n\t\t}\n\t\tconst tiles: InstanceType<typeof TileCacheData>[] = []\n\t\tfor (let i = 0; i < layerSet.nlayers(); i++) {\n\t\t\tconst tile = new TileCacheData()\n\t\t\tconst layer = layerSet.layers(i)\n\t\t\tconst header = new Raw.dtTileCacheLayerHeader()\n\t\t\theader.magic = Detour.DT_TILECACHE_MAGIC\n\t\t\theader.version = Detour.DT_TILECACHE_VERSION\n\t\t\theader.tx = tileX\n\t\t\theader.ty = tileY\n\t\t\theader.tlayer = i\n\t\t\tconst min = layer.bmin()\n\t\t\tconst max = layer.bmax()\n\t\t\theader.set_bmin(0, min.x)\n\t\t\theader.set_bmin(1, min.y)\n\t\t\theader.set_bmin(2, min.z)\n\t\t\theader.set_bmax(0, max.x)\n\t\t\theader.set_bmax(1, max.y)\n\t\t\theader.set_bmax(2, max.z)\n\t\t\theader.width = layer.width()\n\t\t\theader.height = layer.height()\n\t\t\theader.minx = layer.minx()\n\t\t\theader.maxx = layer.maxx()\n\t\t\theader.miny = layer.miny()\n\t\t\theader.maxy = layer.maxy()\n\t\t\theader.hmin = layer.hmin()\n\t\t\theader.hmax = layer.hmax()\n\t\t\tconst status = buildTileCacheLayer(\n\t\t\t\tcompressor,\n\t\t\t\theader,\n\t\t\t\tgetHeightfieldLayerHeights(layer),\n\t\t\t\tgetHeightfieldLayerAreas(layer),\n\t\t\t\tgetHeightfieldLayerCons(layer),\n\t\t\t\ttile\n\t\t\t)\n\t\t\tif (statusFailed(status)) break\n\t\t\ttiles.push(tile)\n\t\t}\n\t\tfreeHeightfieldLayerSet(layerSet)\n\t\treturn tiles\n\t}\n\treturn { rasterize, destroy }\n}\n\n/**\n * Builds a tile cache and its navmesh from a build, as Recast's `generateTileCache` does, but with each triangle of the\n * ground marked with its cell's speed (`NavigationBuild.speeds`) before it is rasterised. What it gives is Recast's own;\n * the caller exports and lets go of it\n */\nexport function generateGroundTileCache(build: NavigationBuild): { navMesh: NavMesh; tileCache: TileCache; process: TileCacheMeshProcess } {\n\tconst { speeds } = build\n\tconst tileCache = new TileCache()\n\tconst navMesh = new NavMesh()\n\tconst process = groundMeshProcess((x, z) => speedOfBuild(speeds, x, z))\n\tconst cut = tileCutOf(build)\n\tconst { config, bbMin, tileWidth, tileHeight, expectedLayersPerTile } = cut\n\tlet rasterizer: ReturnType<typeof tileRasterizer>\n\tconst fail = (error: string): never => {\n\t\trasterizer?.destroy()\n\t\ttileCache.destroy()\n\t\tnavMesh.destroy()\n\t\tthrow new Error(`Navmesh generation failed: ${error}`)\n\t}\n\tconst allocator = new Raw.RecastLinearAllocator(32000)\n\tconst compressor = new Raw.RecastFastLZCompressor()\n\tif (!tileCache.init(tileCacheParamsOf(cut), allocator, compressor, process)) fail('Failed to initialize tile cache')\n\tconst tileBits = Math.min(Math.floor(dtIlog2(dtNextPow2(tileWidth * tileHeight * expectedLayersPerTile))), 14)\n\tconst navMeshParams = NavMeshParams.create({\n\t\torig: vec3.fromArray(bbMin),\n\t\ttileWidth: config.tileSize * config.cs,\n\t\ttileHeight: config.tileSize * config.cs,\n\t\tmaxTiles: 1 << tileBits,\n\t\tmaxPolys: 1 << (22 - tileBits)\n\t})\n\tif (!navMesh.initTiled(navMeshParams)) fail('Failed to initialize tiled navmesh')\n\trasterizer = tileRasterizer(build, cut, compressor)\n\tif (!rasterizer) return fail('Failed to build chunky triangle mesh')\n\tfor (let y = 0; y < tileHeight; ++y) {\n\t\tfor (let x = 0; x < tileWidth; ++x) for (const tile of rasterizer.rasterize(x, y)) tileCache.addTile(tile)\n\t}\n\tfor (let y = 0; y < tileHeight; y++) {\n\t\tfor (let x = 0; x < tileWidth; x++)\n\t\t\tif (statusFailed(tileCache.buildNavMeshTilesAt(x, y, navMesh))) fail(`Failed to build nav mesh tiles at ${x}, ${y}`)\n\t}\n\trasterizer.destroy()\n\treturn { navMesh, tileCache, process }\n}\n\n/** A tile of the grid by its column and row: `tx * 65536 + ty` */\nexport const tileKey = (tx: number, ty: number): number => tx * 65536 + ty\n\n/**\n * Some tiles of a build made again (`RecastNavigation.reshape`): each tile's compressed layers, made as\n * `generateGroundTileCache` makes them, from the triangles that reach it. Also the bounds of the whole build, for the\n * caller to know the tiles are cut on the grid it has (a build of other bounds is cut on another). `speedOf` is the speed\n * of the ground at a point where the build has no speeds of its own (a part of the ground, `RecastNavigation.groundChanged`).\n * Undefined where they could not be made\n */\nexport function groundTileLayers(\n\tbuild: NavigationBuild,\n\ttiles: readonly number[],\n\tcut: TileCut = tileCutOf(build),\n\tspeedOf?: (x: number, z: number) => number\n): Map<number, Uint8Array[]> | undefined {\n\tconst { config, bbMin, tileWidth, tileHeight } = cut\n\tconst tcs = config.tileSize * config.cs\n\tconst border = config.borderSize * config.cs\n\t// each tile wanted, the triangles that reach it with its border, in the build's order\n\tconst own = new Map<number, number[]>(tiles.map((key) => [key, []]))\n\tconst { positions, indices } = build\n\tfor (let t = 0; t < indices.length; t += 3) {\n\t\tlet x0 = Infinity\n\t\tlet x1 = -Infinity\n\t\tlet z0 = Infinity\n\t\tlet z1 = -Infinity\n\t\tfor (let k = 0; k < 3; k++) {\n\t\t\tconst v = indices[t + k] * 3\n\t\t\tx0 = Math.min(x0, positions[v])\n\t\t\tx1 = Math.max(x1, positions[v])\n\t\t\tz0 = Math.min(z0, positions[v + 2])\n\t\t\tz1 = Math.max(z1, positions[v + 2])\n\t\t}\n\t\tconst tx0 = Math.max(0, Math.floor((x0 - border - bbMin[0]) / tcs))\n\t\tconst tx1 = Math.min(tileWidth - 1, Math.floor((x1 + border - bbMin[0]) / tcs))\n\t\tconst ty0 = Math.max(0, Math.floor((z0 - border - bbMin[2]) / tcs))\n\t\tconst ty1 = Math.min(tileHeight - 1, Math.floor((z1 + border - bbMin[2]) / tcs))\n\t\tfor (let tx = tx0; tx <= tx1; tx++) for (let ty = ty0; ty <= ty1; ty++) own.get(tileKey(tx, ty))?.push(indices[t], indices[t + 1], indices[t + 2])\n\t}\n\tconst made = new Map<number, Uint8Array[]>()\n\tconst compressor = new Raw.RecastFastLZCompressor()\n\tconst rasterizer = speedOf ? tileRasterizer(build, cut, compressor, false, speedOf) : tileRasterizer(build, cut, compressor, false)\n\tif (!rasterizer) {\n\t\tRaw.destroy(compressor)\n\t\treturn undefined\n\t}\n\ttry {\n\t\tfor (const key of tiles) {\n\t\t\tconst layers = rasterizer.rasterize(Math.floor(key / 65536), key % 65536, Uint32Array.from(own.get(key)!))\n\t\t\tmade.set(\n\t\t\t\tkey,\n\t\t\t\tlayers.map((layer) => {\n\t\t\t\t\tconst bytes = layer.toTypedArray().slice()\n\t\t\t\t\t// made by Recast (dtBuildTileCacheLayer), in no tile cache: let go of here\n\t\t\t\t\tlayer.destroy()\n\t\t\t\t\treturn bytes\n\t\t\t\t})\n\t\t\t)\n\t\t}\n\t} finally {\n\t\trasterizer.destroy()\n\t\tRaw.destroy(compressor)\n\t}\n\treturn made\n}\n\n/**\n * The grid a build is cut on: its bounds and its tiles across and down. A build of the same grid as another's is cut\n * into the same tiles, so a tile of one may be made again alone from the other (`groundTileLayers`)\n */\nexport function tileGridOf(build: NavigationBuild): {\n\tbbMin: readonly number[]\n\tbbMax: readonly number[]\n\ttileWidth: number\n\ttileHeight: number\n\t/** A tile's side, in ground units */\n\ttileSize: number\n\t/** How far round a tile the ground it is made of reaches, in ground units */\n\tborder: number\n\t/** The whole of how it is cut, for `groundTileLayers` and `emptyTileCache` not to work it out again */\n\tcut: TileCut\n} {\n\tconst cut = tileCutOf(build)\n\tconst { bbMin, bbMax, tileWidth, tileHeight, config } = cut\n\treturn { bbMin, bbMax, tileWidth, tileHeight, tileSize: config.tileSize * config.cs, border: config.borderSize * config.cs, cut }\n}\n\n/**\n * A tile cache of the grid a build is cut on (`tileGridOf`), empty, with room for `room`'s tiles and obstacles: what\n * a column of tiles made again alone is made into the navmesh's tiles through (`RecastNavigation.groundChanged`,\n * `reshape`), as the whole's tile cache would make them. It works in the allocator and compressor given (the whole's:\n * a tile is made in one call, and each starts the allocator over), which it does not take. Undefined where Recast\n * would not make it\n */\nexport function columnTileCache(\n\tcut: TileCut,\n\tprocess: TileCacheMeshProcess,\n\troom: { tiles: number; obstacles: number },\n\tallocator: InstanceType<typeof Raw.RecastLinearAllocator>,\n\tcompressor: InstanceType<typeof Raw.RecastFastLZCompressor>\n): TileCache | undefined {\n\tconst tileCache = new TileCache()\n\tconst params = tileCacheParamsOf(cut, room)\n\tconst made = tileCache.init(params, allocator, compressor, process)\n\t// Detour copies them in: let go of here, as a column may be made many times a game\n\tRaw.destroy(params.raw)\n\tif (made) return tileCache\n\ttileCache.destroy()\n\treturn undefined\n}\n\n/**\n * Puts a compressed layer (`groundTileLayers`) in a tile cache, which does not take it: its copy is given back, to be let\n * go of (`destroy`) once the tile cache is. Undefined where the tile cache would not take it\n */\nexport function addTileLayer(tileCache: TileCache, bytes: Uint8Array): InstanceType<typeof TileCacheData> | undefined {\n\tconst data = new TileCacheData()\n\tdata.copy(bytes)\n\tif (!statusFailed(tileCache.addTile(data, 0).status)) return data\n\tdata.destroy()\n\treturn undefined\n}\n\n/**\n * Which layer of its column a compressed layer (`groundTileLayers`) is: the navmesh's tile made of it is at that layer.\n * Its header (Detour's `dtTileCacheLayerHeader`) leads it uncompressed: magic, version, tx, ty, then the layer, each an int\n */\nexport const layerOf = (bytes: Uint8Array): number => new DataView(bytes.buffer, bytes.byteOffset, 20).getInt32(16, true)\n"],"mappings":"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"}

package/dist/navigation/navigation.d.ts

@@ -25,30 +25,62 @@ export interface AgentState {
  * @beta
  */
 export interface AgentSave {
+    /** Where the agent is on the map's x axis, in cells */
     x: number;
+    /** Where the agent is on the map's z axis, in cells */
     z: number;
+    /** Its velocity along x, in cells per second */
     vx: number;
+    /** Its velocity along z, in cells per second */
     vz: number;
+    /** Its radius, in cells */
     radius: number;
+    /** How fast it goes, in cells per second */
     speed: number;
     /** How fast it gets up to speed, where that is not what follows from the speed */
     acceleration?: number;
+    /** Whether it flies, over what blocks the ground */
     flying?: boolean;
+    /** Whether it sails, on deep water instead of the ground */
     naval?: boolean;
     /** Where it was sent, snapped to where it can go. Null when it was not */
     target: Vec2 | null;
+    /** Whether it holds its ground, so that others walk around it */
     anchored: boolean;
     /** Where an anchored agent holds its ground */
     anchor?: Vec2;
+    /** Whether it ignores other agents */
     ghost: boolean;
+    /** Whether it walks through every other agent and they through it (`Navigation.setPhasing`) */
+    phasing?: boolean;
 }
-/** @beta */
+/**
+ * A mesh of the navigation, for drawing: `triangles` and `lines` of it
+ *
+ * @beta
+ */
 export interface NavDebugGeometry {
     /** xyz triples, 3 vertices per triangle */
     triangles: Float32Array;
     /** xyz triples, 2 vertices per line */
     lines: Float32Array;
 }
+/**
+ * A part of the ground, in cells: the first cell, and how many across and down (what `World.reshapeGround` changed,
+ * as its `TerrainPatch` says)
+ *
+ * @beta
+ */
+export interface CellArea {
+    /** The first cell on the x axis */
+    x: number;
+    /** The first cell on the z axis */
+    z: number;
+    /** How many cells across */
+    width: number;
+    /** How many cells down */
+    depth: number;
+}
 /**
  * Pathfinding and local avoidance. The simulation only talks to this interface,
  * so the backing implementation can be replaced without touching game logic.
@@ -58,18 +90,31 @@ export interface NavDebugGeometry {
 export interface Navigation {
     /** Bumped whenever walkable space changes (obstacles added or removed) */
     readonly version: number;
+    /** Puts an agent in the crowd by its id (the entity's), at a position and with its radius, speed and the like */
     addAgent(id: number, position: Vec2, params: AgentParams): void;
+    /** Takes the agent out of the crowd */
     removeAgent(id: number): void;
+    /** Whether an agent by this id is in the crowd */
     hasAgent(id: number): boolean;
     /** Path towards `target`. The target is snapped to walkable space; returns false when nothing walkable is near it. */
     setDestination(id: number, target: Vec2): boolean;
+    /** Forgets where the agent was sent; it stops where it is */
     clearDestination(id: number): void;
+    /** Moves the agent to the position at once, without a walk */
     teleport(id: number, position: Vec2): void;
     /** Anchored agents hold their ground: others have to walk around them instead of shoving them away. */
     setAnchored(id: number, anchored: boolean): void;
     /** Ghost agents ignore other agents (used by workers hauling resources). */
     setGhost(id: number, ghost: boolean): void;
+    /**
+     * An agent that phases walks through every other agent and every other through it: neither steers round nor pushes
+     * the other (`BuffDef.phasing`). What blocks the ground (walls, cliffs, obstacles) still stops it. A navigation
+     * without it has the agent a ghost instead (`setGhost`), which others may still push aside
+     */
+    setPhasing?(id: number, phasing: boolean): void;
+    /** Changes how fast the agent goes, in cells per second */
     setSpeed(id: number, speed: number): void;
+    /** Writes the agent's position, velocity and next corners into `out`; returns false when there is no such agent */
     readAgent(id: number, out: AgentState): boolean;
     /** What a save needs of an agent, or undefined when there is none of that id */
     saveAgent(id: number): AgentSave | undefined;
@@ -86,12 +131,14 @@ export interface Navigation {
     reseat(agents: readonly (readonly [id: number, save: AgentSave])[]): void;
     /** After a load: brings walkable space up to date with the obstacles put back, and takes on the version it had */
     settle(version: number): void;
+    /** Steps the crowd by `dt` seconds: agents follow their paths and steer around each other */
     update(dt: number): void;
     /**
      * Something that blocks the way, a building or a shut gate. False when there is no room for another (see
      * `obstacleRoom`): it is then not in the way, and never thrown over in the middle of a tick
      */
     addObstacle(key: number, rect: Rect): boolean;
+    /** Takes the obstacle with this key out of the way, opening the ground it covered */
     removeObstacle(key: number): void;
     /** How many more obstacles there is room for: what placing a building is refused over, before it is placed */
     obstacleRoom(): number;
@@ -104,24 +151,66 @@ export interface Navigation {
     holdObstacles?(hold: boolean): void;
     /**
      * Whether two agents are in each other's way: on the same crowd, so that each steers around the other and neither
-     * walks through. Agents of different layers (ground, air, water), or of different sizes where the ground is cut for
-     * several (`SizedNavigation`), are not. Taken as yes where a navigation does not say
+     * walks through. Agents of different layers (ground, air, water) are not; those of different sizes where the ground
+     * is cut for several are (`SizedNavigation`). Taken as yes where a navigation does not say
      */
     sameCrowd?(a: number, b: number): boolean;
     /** Closest walkable point, or null when there is none within `searchRadius`. */
     closestPoint(point: Vec2, searchRadius?: number): Vec2 | null;
+    /** Finds a path between two points over walkable space, as a list of corners; null when there is none */
     findPath(from: Vec2, to: Vec2): Vec2[] | null;
     /**
      * A layer of cells that slows one on foot changed on these cells (`World.setCells`): what a path weighs there is
-     * made again (EN2). Nothing where a navigation weighs no ground
+     * made again (EN2), as a navigation cut now of the ground as it is would weigh it, so a world loaded from a save made
+     * after plays out the same. `walkability`: the change may have made cells walkable or not (a layer with a thicket
+     * among its values, `FoliageStyleDef.walkable`), which the ways keep their distance from beyond the cells' own part of
+     * the navigation. Nothing where a navigation weighs no ground
+     */
+    groundChanged?(cells: readonly number[], walkability?: boolean): void;
+    /**
+     * The ground it is a navigation of was reshaped (`World.reshapeGround`): cut again from it as it is now, what is in
+     * the way and every agent kept as they were. Told the part that changed (`area`), it may cut again only what that
+     * part reaches. False where it will not be (a navigation of no ground); one that cannot be cut of the ground as it is
+     * now is left as it was. A navigation may do it, and `groundChanged`, later than asked, all together, as long as
+     * nothing asked of it before then sees the ground as it was (`settleGround`)
      */
-    groundChanged?(cells: readonly number[]): void;
+    reshape?(area?: CellArea): boolean;
     /**
-     * The ground it is a navigation of was reshaped (`World.reshapeGround`): cut again from it as it is now, at once, what
-     * is in the way and every agent kept as they were. False where it was not (a navigation of no ground, or one that
-     * cannot be cut of the ground as it is now): it is left as it was
+     * Does now what the ground's changes asked of it and it has not done yet (`groundChanged`, `reshape`): the world asks
+     * it as each tick ends, so that a tick's changes of the ground are done together, once, and none is left over for
+     * after the tick (a save, a screen). Nothing where a navigation does them at once
      */
-    reshape?(): boolean;
+    settleGround?(): void;
+    /** Gives the navigation mesh as triangles and lines, for the debug view */
     debugGeometry(): NavDebugGeometry;
+    /** Frees the navigation and its crowd; it is not used after */
     dispose(): void;
 }
+/**
+ * Where an agent is and how fast it goes, as one crowd tells another of it (`AgentMirrors`)
+ *
+ * @beta
+ */
+export interface AgentMotion {
+    x: number;
+    y: number;
+    z: number;
+    vx: number;
+    vz: number;
+}
+/**
+ * What a navigation of one size does for `SizedNavigation`: has agents of its other sizes stand in its crowd as
+ * mirrors. A mirror is steered round and pushed against as any agent is, but it never moves by itself: it is where it
+ * was last told, and pushes without being pushed, as an anchored agent does
+ *
+ * @beta
+ */
+export interface AgentMirrors {
+    readMotion(id: number, out: AgentMotion): boolean;
+    addMirror(id: number, motion: AgentMotion, radius: number, ghost: boolean): void;
+    moveMirror(id: number, motion: AgentMotion): void;
+    setMirrorGhost(id: number, ghost: boolean): void;
+    /** The agent of a mirror phases (`Navigation.setPhasing`): its mirror is in nobody's way meanwhile */
+    setMirrorPhasing?(id: number, phasing: boolean): void;
+    removeMirror(id: number): void;
+}