@v12-engine/engine 0.1.1 → 0.4.0

package/dist/navigation/recast.js

@@ -0,0 +1,1379 @@
+import { walkedCell } from "../terrain.js";
+import { addTileLayer, columnTileCache, groundMeshProcess, groundTileLayers, layerOf, setAreaCosts, tileGridOf, tileKey } from "./groundAreas.js";
+import { buildNavigationData, buildNavigationNow, inTurn, initRecast, navigationData } from "./builds.js";
+import { Crowd, DebugDrawerUtils, NavMeshQuery, Raw, TileCacheMeshProcess, importTileCache } from "@recast-navigation/core";
+import { createDefaultTileCacheMeshProcess } from "@recast-navigation/generators";
+//#region src/navigation/recast.ts
+/**
+* The engine's avoidance (`RecastNavigationOptions.avoidance`): Detour's own numbers, which `AVOIDANCE_LEVELS` change the sampling of
+*
+* @internal
+*/
+var DEFAULT_AVOIDANCE = Object.freeze({
+	velBias: .4,
+	weightDesVel: 2,
+	weightCurVel: .75,
+	weightSide: .75,
+	weightToi: 2.5,
+	horizTime: 2.5,
+	gridSize: 33,
+	adaptiveDivs: 7,
+	adaptiveRings: 2,
+	adaptiveDepth: 5
+});
+/**
+* What `walls: 'soft'` changes of `DEFAULT_AVOIDANCE`, under the level and a game's own numbers: what is ahead counts
+* within 1.5 s (Detour's 2.5) and weighs 1.5 (2.5), and going the speed it wants weighs 3 (2), so that a slower
+* velocity that would touch a wall a little later no longer wins
+*
+* @beta
+*/
+var SOFT_WALLS = Object.freeze({
+	horizTime: 1.5,
+	weightToi: 1.5,
+	weightDesVel: 3
+});
+/**
+* What each `AvoidanceLevel` changes of `DEFAULT_AVOIDANCE`: the sampling (`adaptiveDivs`, `adaptiveRings` and
+* `adaptiveDepth`, which what an agent costs a tick goes by)
+*
+* @beta
+*/
+var AVOIDANCE_LEVELS = Object.freeze({
+	low: Object.freeze({
+		adaptiveDivs: 5,
+		adaptiveRings: 1,
+		adaptiveDepth: 3
+	}),
+	medium: Object.freeze({}),
+	high: Object.freeze({
+		adaptiveDivs: 7,
+		adaptiveRings: 3,
+		adaptiveDepth: 7
+	})
+});
+var DEFAULT_FLAGS = 31;
+var GHOST_FLAGS = 25;
+/**
+* An agent with nowhere to go: no velocity sampled among its neighbours, which for one that wants to stand still comes to
+* standing still all the same (a crowd of idle units: EN1, the same hashes). It is pushed as any agent is
+*/
+var RESTING_FLAGS = 29;
+/** What an agent's target is while its path is still being looked for: requesting, waiting for the queue, waiting for the path */
+var PLANNING = /* @__PURE__ */ new Set([
+	3,
+	4,
+	5
+]);
+/** How fast an agent with no speed left comes to a halt, in ground units per second squared */
+var BRAKING = 60;
+/**
+* Detour's states of an agent. An invalid one is left out of every step of the crowd (no path checked, no neighbours
+* looked for, no velocity sampled, not moved, not pushed) but stays in the grid the others look for neighbours in: it
+* is what an anchored agent is, asleep where it stands, while everyone else still goes around it
+*/
+var INVALID = 0;
+var WALKING = 1;
+/**
+* Where the mirror of an agent that phases is kept (`setMirrorPhasing`): far from anyone, so that it is nobody's
+* neighbour, and still in its place among the crowd's agents
+*/
+var PARKED = -1e5;
+/** Each cell's speed on the ground, as a build is told it: none where every cell is 1 (the ground cut as it always was) */
+function speedsOf(terrain, speedAt) {
+	const { width, depth } = terrain;
+	const values = new Float32Array(width * depth);
+	let slow = false;
+	for (let z = 0; z < depth; z++) for (let x = 0; x < width; x++) {
+		const speed = speedAt(x + .5, z + .5);
+		values[z * width + x] = speed;
+		if (speed !== 1) slow = true;
+	}
+	return slow ? {
+		width,
+		depth,
+		values
+	} : void 0;
+}
+/** The least of one coordinate (0 x, 2 z) of the vertices a mesh's triangles use: where its tiles start, as Recast's bounds do */
+function minOf(positions, indices, axis) {
+	let least = Infinity;
+	for (let i = 0; i < indices.length; i++) least = Math.min(least, positions[indices[i] * 3 + axis]);
+	return least;
+}
+/** A limit from the map's size, never less than it was before the map's size counted, never past what Detour counts to */
+var limitFor = (wanted, least) => Math.min(Math.max(Math.ceil(wanted), least), 65535);
+/** How many requests the tile cache queues, and how many tiles it makes again from one batch of them, at most (Detour's) */
+var MAX_REQUESTS = 64;
+/** Half of Detour's 64: a column of the tile grid may hold more than one layer, and each is a tile of its own */
+var MAX_HELD_COLUMNS = 32;
+/**
+* The walkable ground about some tiles (their keys), as `Terrain.buildMesh(true)` and `speedsOf` give it whole: the
+* triangles of the cells within a tile's border (and a cell more) of each, in the whole mesh's order, and the speed of
+* the cell a point is in, so that each of those tiles is made from it as from the whole (`groundTileLayers` takes a
+* tile's triangles by where they reach). As much as those tiles need, however big the map
+*/
+function groundPart(terrain, config, speedAt, keys, grid) {
+	const { width, depth, vertsX } = terrain;
+	const reach = grid.border + 1;
+	const near = [];
+	for (const key of keys) {
+		const tx = Math.floor(key / 65536);
+		const ty = key % 65536;
+		const x0 = Math.max(0, Math.floor(grid.bbMin[0] + tx * grid.tileSize - reach));
+		const x1 = Math.min(width - 1, Math.ceil(grid.bbMin[0] + (tx + 1) * grid.tileSize + reach));
+		const z0 = Math.max(0, Math.floor(grid.bbMin[2] + ty * grid.tileSize - reach));
+		const z1 = Math.min(depth - 1, Math.ceil(grid.bbMin[2] + (ty + 1) * grid.tileSize + reach));
+		for (let iz = z0; iz <= z1; iz++) for (let ix = x0; ix <= x1; ix++) near.push(iz * width + ix);
+	}
+	near.sort((a, b) => a - b);
+	const speeds = /* @__PURE__ */ new Map();
+	const vertices = /* @__PURE__ */ new Map();
+	const positions = [];
+	const indices = [];
+	const vertex = (v) => {
+		let at = vertices.get(v);
+		if (at === void 0) {
+			at = vertices.size;
+			vertices.set(v, at);
+			positions.push(v % vertsX, terrain.heights[v], Math.floor(v / vertsX));
+		}
+		return at;
+	};
+	for (let i = 0; i < near.length; i++) {
+		const cell = near[i];
+		if (cell === near[i - 1]) continue;
+		const ix = cell % width;
+		const iz = (cell - ix) / width;
+		if (!walkedCell(terrain, ix, iz)) continue;
+		speeds.set(cell, speedAt(ix + .5, iz + .5));
+		const a = iz * vertsX + ix;
+		const [va, vb, vc, vd] = [
+			vertex(a),
+			vertex(a + 1),
+			vertex(a + vertsX),
+			vertex(a + vertsX + 1)
+		];
+		indices.push(va, vc, vb, vb, vc, vd);
+	}
+	return {
+		build: {
+			positions: Float32Array.from(positions),
+			indices: Uint32Array.from(indices),
+			config
+		},
+		speedOf: (x, z) => speeds.get(Math.floor(z) * width + Math.floor(x)) ?? 1
+	};
+}
+/**
+* More than this share of the tiles reshaped at once is cut whole, and nothing kept apart after. Only a reshape: a
+* slowing layer painted is never cut whole (`groundChanged`), its tiles alone being quicker
+*/
+var MOST_TILES = .5;
+/** The slot of the crowd's obstacle avoidance parameters every agent uses */
+var AVOIDANCE_SLOT = 3;
+/**
+* A crowd on the navmesh with room for `maxAgents` agents, of any radius up to twice the one it was cut for, steering
+* as `avoidance` says
+*/
+function crowdOf(navMesh, maxAgents, agentRadius, avoidance, weighs) {
+	const crowd = new Crowd(navMesh, {
+		maxAgents,
+		maxAgentRadius: Math.max(agentRadius * 2, 1)
+	});
+	crowd.navMeshQuery.defaultQueryHalfExtents = {
+		x: 2,
+		y: 6,
+		z: 2
+	};
+	if (weighs) setAreaCosts(crowd.getFilter(0));
+	const params = new Raw.Module.dtObstacleAvoidanceParams();
+	params.velBias = avoidance.velBias;
+	params.weightDesVel = avoidance.weightDesVel;
+	params.weightCurVel = avoidance.weightCurVel;
+	params.weightSide = avoidance.weightSide;
+	params.weightToi = avoidance.weightToi;
+	params.horizTime = avoidance.horizTime;
+	params.gridSize = avoidance.gridSize;
+	params.adaptiveDivs = avoidance.adaptiveDivs;
+	params.adaptiveRings = avoidance.adaptiveRings;
+	params.adaptiveDepth = avoidance.adaptiveDepth;
+	crowd.raw.setObstacleAvoidanceParams(AVOIDANCE_SLOT, params);
+	Raw.destroy(params);
+	return crowd;
+}
+var RecastNavigation = class RecastNavigation {
+	terrain;
+	navMesh;
+	tileCache;
+	crowd;
+	query;
+	agentRadius;
+	maxAgents;
+	maxObstacles;
+	maxNodes;
+	owned;
+	avoidance;
+	separation;
+	walls;
+	tiles;
+	heightAt;
+	ground;
+	cut;
+	/** One more each time walkable space changes (`version`) */
+	changes = 0;
+	/** What the ground's changes asked and is not done yet: none, mostly */
+	asked;
+	agents = /* @__PURE__ */ new Map();
+	mirrors = /* @__PURE__ */ new Map();
+	/**
+	* The crowd of the agents that walk through others (`setPhasing`), on the same navmesh, made as the first comes:
+	* Detour has no way to keep an agent out of the others' neighbours, so it walks where there are none. Walls,
+	* cliffs and obstacles are the navmesh's, and stop it as they stop anyone
+	*/
+	phasers;
+	/** How many agents the crowd of those that phase has room for now */
+	phasersRoom = 0;
+	obstacles = /* @__PURE__ */ new Map();
+	/** The room the crowd was first made with: a crowd made anew (`reseat`) starts there, as a loaded world's does */
+	firstMaxAgents = 0;
+	obstaclesDirty = false;
+	/** Obstacles are put down many at once (`holdObstacles`): their requests wait in the tile cache to be made into tiles together */
+	holding = false;
+	/** Requests waiting while held, and the columns of the tile grid they touch (x * 65536 + z) */
+	held = 0;
+	heldColumns = /* @__PURE__ */ new Set();
+	/** Points handed to the module, which copies them in: one, and a second for a path's end */
+	scratch = {
+		x: 0,
+		y: 0,
+		z: 0
+	};
+	scratchEnd = {
+		x: 0,
+		y: 0,
+		z: 0
+	};
+	/** How far `closestPoint` looks, set for each ask */
+	closestQuery = { halfExtents: {
+		x: 0,
+		y: 8,
+		z: 0
+	} };
+	/** What `steer` works in each tick, kept: the agents that count, where they are, and a grid of them */
+	near = [];
+	nearX = /* @__PURE__ */ new Float64Array(0);
+	nearZ = /* @__PURE__ */ new Float64Array(0);
+	nearNext = /* @__PURE__ */ new Int32Array(0);
+	nearHeads = /* @__PURE__ */ new Map();
+	/** The tiles made again alone since the ground was last cut whole (`groundChanged`, `reshape` of a part) */
+	overridden;
+	/**
+	* The obstacles about each column of the grid (`columnsOf`), by their keys, in the order they were put down: what a
+	* column made alone is made with. Kept while tiles are made alone, made from `obstacles` as the first is
+	*/
+	byColumn;
+	/** The grid the whole was cut on (`tileGridOf`): a part is made again alone only where the ground is cut on the same */
+	grid;
+	/** Columns of the grid obstacles were put down or taken up on, while tiles are made alone: made again from theirs */
+	requested = /* @__PURE__ */ new Set();
+	constructor(terrain, navMesh, tileCache, crowd, query, agentRadius, maxAgents, maxObstacles, maxNodes, owned, avoidance, separation, walls, tiles, heightAt = (x, z) => terrain.heightAt(x, z), ground, cut) {
+		this.terrain = terrain;
+		this.navMesh = navMesh;
+		this.tileCache = tileCache;
+		this.crowd = crowd;
+		this.query = query;
+		this.agentRadius = agentRadius;
+		this.maxAgents = maxAgents;
+		this.maxObstacles = maxObstacles;
+		this.maxNodes = maxNodes;
+		this.owned = owned;
+		this.avoidance = avoidance;
+		this.separation = separation;
+		this.walls = walls;
+		this.tiles = tiles;
+		this.heightAt = heightAt;
+		this.ground = ground;
+		this.cut = cut;
+		this.firstMaxAgents = maxAgents;
+	}
+	static async create(terrain, options = {}) {
+		const builder = options.builds?.builder;
+		if (builder && builder !== buildNavigationData) return RecastNavigation.made(terrain, options);
+		return inTurn(() => RecastNavigation.made(terrain, options));
+	}
+	static async made(terrain, options) {
+		await initRecast();
+		const cells = terrain.width * terrain.depth;
+		const { agentRadius = .5, maxSlope = 38, maxAgents = 512, maxObstacles = limitFor(cells, 8192), maxNodes = limitFor(cells / 4, 4096), cellSize = .25, surface = "ground", separation = .5, walls = "soft" } = options;
+		const avoidance = Object.freeze({
+			...DEFAULT_AVOIDANCE,
+			...walls === "soft" && SOFT_WALLS,
+			...AVOIDANCE_LEVELS[typeof options.avoidance === "string" ? options.avoidance : "medium"],
+			...typeof options.avoidance === "object" && options.avoidance
+		});
+		const cellHeight = .2;
+		const water = surface === "water";
+		const config = {
+			cs: cellSize,
+			ch: cellHeight,
+			tileSize: 48,
+			walkableSlopeAngle: maxSlope,
+			walkableHeight: Math.ceil(2 / cellHeight),
+			walkableClimb: Math.ceil(.6 / cellHeight),
+			walkableRadius: Math.ceil(agentRadius / cellSize),
+			maxSimplificationError: 1.1,
+			mergeRegionArea: 20,
+			maxVertsPerPoly: 6,
+			detailSampleDist: 4,
+			detailSampleMaxError: .5,
+			expectedLayersPerTile: 1,
+			maxObstacles
+		};
+		const speedAt = water ? void 0 : options.speedAt;
+		const cut = () => {
+			const { positions, indices } = water ? terrain.buildWaterMesh() : terrain.buildMesh(true);
+			const speeds = speedAt && speedsOf(terrain, speedAt);
+			return {
+				build: {
+					positions,
+					indices,
+					config,
+					...speeds && { speeds }
+				},
+				tiles: {
+					size: config.tileSize * cellSize,
+					originX: minOf(positions, indices, 0),
+					originZ: minOf(positions, indices, 2)
+				}
+			};
+		};
+		const first = cut();
+		const data = await navigationData(first.build, options.builds);
+		const process = speedAt ? groundMeshProcess(speedAt) : createDefaultTileCacheMeshProcess();
+		const { navMesh, tileCache, allocator, compressor } = importTileCache(data, process);
+		const query = new NavMeshQuery(navMesh, { maxNodes });
+		query.defaultQueryHalfExtents = {
+			x: 2,
+			y: 6,
+			z: 2
+		};
+		if (speedAt) setAreaCosts(query.defaultFilter);
+		const crowd = crowdOf(navMesh, maxAgents, agentRadius, avoidance, !!speedAt);
+		const navigation = new RecastNavigation(terrain, navMesh, tileCache, crowd, query, agentRadius, maxAgents, maxObstacles, maxNodes, [
+			process,
+			allocator,
+			compressor
+		], avoidance, separation, walls, first.tiles, water ? (x, z) => terrain.waterHeightAt(x, z) : void 0, speedAt && {
+			speedAt,
+			config
+		}, cut);
+		if (first.build.indices.length) navigation.grid = tileGridOf(first.build);
+		return navigation;
+	}
+	/** One more each time walkable space changes: what the ground's changes asked of it done first (`settleGround`) */
+	get version() {
+		if (this.asked) this.settleGround();
+		return this.changes;
+	}
+	/**
+	* The ground it is a navigation of was reshaped (`World.reshapeGround`): cut again from the ground as it is now, on
+	* this thread, as it was cut first (its options, its slow ground); what is in the way put down again where it was, in
+	* the order it was, and every agent moved over as it stood, as a crowd that grows is. Every machine cuts it the same.
+	*
+	* Told the part that changed (`area`, in cells), only the tiles it reaches are cut again (`reshapeTiles`), where the
+	* ground is still cut on the same grid and that is under half of the tiles: the rest of the navmesh, what is in the
+	* way and every agent stay as they are, and an agent whose way went over a tile cut again finds it again, as when a
+	* building goes up on it.
+	*
+	* Not at once: at the first thing asked of it after, or as the tick ends (`settleGround`), with what the other
+	* changes of the ground asked before then (a slowing layer painted on the same part, `groundChanged`), each tile once.
+	* Nothing asked of it sees the ground as it was. True where it has a ground to cut again; one that cannot be cut as it
+	* is now (no water left) is left as it was when the time comes
+	*/
+	reshape(area) {
+		if (!this.cut) return false;
+		const asked = this.ask();
+		const grid = this.grid;
+		if (!area || !grid || asked.whole) {
+			asked.whole = true;
+			return true;
+		}
+		const reach = 2 + grid.border;
+		const column = (x, origin, count) => Math.min(count - 1, Math.max(0, Math.floor((x - origin) / grid.tileSize)));
+		const tx0 = column(area.x - reach, grid.bbMin[0], grid.tileWidth);
+		const tx1 = column(area.x + area.width + reach, grid.bbMin[0], grid.tileWidth);
+		const ty0 = column(area.z - reach, grid.bbMin[2], grid.tileHeight);
+		const ty1 = column(area.z + area.depth + reach, grid.bbMin[2], grid.tileHeight);
+		if ((tx1 - tx0 + 1) * (ty1 - ty0 + 1) > grid.tileWidth * grid.tileHeight * MOST_TILES) asked.whole = true;
+		else for (let tx = tx0; tx <= tx1; tx++) for (let ty = ty0; ty <= ty1; ty++) asked.reshaped.add(tileKey(tx, ty));
+		return true;
+	}
+	/** What the ground's changes ask of it, one more ask */
+	ask() {
+		const asked = this.asked ??= {
+			asks: 0,
+			whole: false,
+			reshaped: /* @__PURE__ */ new Set(),
+			painted: /* @__PURE__ */ new Set()
+		};
+		asked.asks++;
+		return asked;
+	}
+	/**
+	* Does what the ground's changes asked of it and it has not done yet (`reshape`, `groundChanged`), all together: a
+	* tile reached by several once, from the ground as it is now. Each ask was weighed as it came (cut whole, or its
+	* tiles), so that what comes out is what doing them one by one makes, tile for tile: where a part of the ground was
+	* reshaped, the tiles it reaches cut again of the whole ground as it is now, with those a layer was painted on; a
+	* layer painted alone, of the ground about its tiles (`groundPart`). The version goes up once for each ask, as it
+	* would have. Asked before anything else is asked of it, and by the world as each tick ends
+	*/
+	settleGround() {
+		const asked = this.asked;
+		if (!asked) return;
+		this.asked = void 0;
+		const grid = this.grid;
+		if (!asked.whole && grid) {
+			if (asked.reshaped.size) {
+				const { build } = this.cut();
+				if (this.reshapeTiles(build, [...asked.reshaped, ...asked.painted])) {
+					this.changes += asked.asks;
+					return;
+				}
+			} else {
+				const keys = [...asked.painted].sort((a, b) => a - b);
+				const { build, speedOf } = groundPart(this.terrain, this.ground.config, this.ground.speedAt, keys, grid);
+				if (this.retile(build, keys, grid.cut, speedOf)) {
+					this.changes += asked.asks;
+					return;
+				}
+			}
+		}
+		if (this.cutWhole()) this.changes += asked.asks;
+	}
+	/** Cut again whole, of the ground as it is now, what is in the way and every agent put back as they were: false where it cannot be */
+	cutWhole() {
+		if (!this.cut) return false;
+		this.drain();
+		const { build, tiles } = this.cut();
+		let made;
+		try {
+			made = importTileCache(buildNavigationNow(build), this.owned[0]);
+		} catch {
+			return false;
+		}
+		const boxes = [...this.obstacles].flatMap(([key, obstacle]) => obstacle.type === "box" ? [[key, {
+			x: obstacle.position.x,
+			z: obstacle.position.z,
+			hw: obstacle.halfExtents.x - this.agentRadius,
+			hd: obstacle.halfExtents.z - this.agentRadius
+		}]] : []);
+		const agents = [...this.agents.keys()].map((id) => [id, this.saveAgent(id)]);
+		this.dropOverridden();
+		this.grid = build.indices.length ? tileGridOf(build) : void 0;
+		const old = [
+			this.crowd,
+			this.query,
+			this.tileCache,
+			this.navMesh
+		];
+		this.navMesh = made.navMesh;
+		this.tileCache = made.tileCache;
+		this.owned = [
+			this.owned[0],
+			made.allocator,
+			made.compressor
+		];
+		this.tiles = tiles;
+		this.query = new NavMeshQuery(made.navMesh, { maxNodes: this.maxNodes });
+		this.query.defaultQueryHalfExtents = {
+			x: 2,
+			y: 6,
+			z: 2
+		};
+		if (this.ground) setAreaCosts(this.query.defaultFilter);
+		this.crowd = crowdOf(made.navMesh, this.maxAgents, this.agentRadius, this.avoidance, !!this.ground);
+		this.obstacles.clear();
+		this.agents.clear();
+		this.phasers?.destroy();
+		this.phasers = void 0;
+		for (const each of old) each.destroy();
+		this.holding = false;
+		this.held = 0;
+		this.heldColumns.clear();
+		this.obstaclesDirty = false;
+		this.holdObstacles(true);
+		for (const [key, rect] of boxes) this.addObstacle(key, rect);
+		this.holdObstacles(false);
+		for (const [id, save] of agents) this.restoreAgent(id, save);
+		this.remakeMirrors();
+		return true;
+	}
+	/**
+	* A slowing layer of cells changed on these cells (`World.setCells`): the tiles they are in are cut again alone from
+	* the ground as it is now (`retile`), its triangles marked with their cells' speeds as a whole
+	* cut marks them, so that the polygons part where the speed does now and the navmesh is the one a world made or
+	* loaded now cuts whole, tile for tile and area for area: a game saved after it plays out the same loaded. Only the
+	* ground about those tiles is read (`groundPart`). Where the change may have made cells walkable or not
+	* (`walkability`, a thicket), the tiles whose border reaches them too: the ground kept from them by the agents' radius
+	* reaches over the tile's edge. Never cut whole, however many tiles: cutting them alone is quicker, even all of them
+	* (half the time of a whole cut on a 128 x 128 map, which also puts every obstacle and agent back). Not at once: with
+	* what the other changes of the ground asked, before the next thing asked of it or as the tick ends (`settleGround`)
+	*/
+	groundChanged(cells, walkability = false) {
+		if (!this.ground || !cells.length) return;
+		if (!this.grid && this.asked) this.settleGround();
+		const grid = this.grid;
+		if (!grid) return;
+		const { width } = this.terrain;
+		const column = (x, origin, count) => Math.min(count - 1, Math.max(0, Math.floor((x - origin) / grid.tileSize)));
+		const reach = walkability ? grid.border : 0;
+		const tiles = /* @__PURE__ */ new Set();
+		for (const cell of cells) {
+			const x = cell % width;
+			const z = (cell - x) / width;
+			if (!reach) {
+				tiles.add(tileKey(column(x + .5, grid.bbMin[0], grid.tileWidth), column(z + .5, grid.bbMin[2], grid.tileHeight)));
+				continue;
+			}
+			const tx1 = column(x + 1 + reach, grid.bbMin[0], grid.tileWidth);
+			const ty1 = column(z + 1 + reach, grid.bbMin[2], grid.tileHeight);
+			for (let tx = column(x - reach, grid.bbMin[0], grid.tileWidth); tx <= tx1; tx++) for (let ty = column(z - reach, grid.bbMin[2], grid.tileHeight); ty <= ty1; ty++) tiles.add(tileKey(tx, ty));
+		}
+		const asked = this.ask();
+		if (asked.whole) return;
+		for (const key of tiles) asked.painted.add(key);
+	}
+	/** The navmesh's tiles of a column of the grid made again: from its layers made alone where it is one of them */
+	buildTilesAt(key) {
+		const layers = this.overridden?.get(key);
+		if (layers) this.buildColumn(key, layers);
+		else this.tileCache.buildNavMeshTilesAt(Math.floor(key / 65536), key % 65536, this.navMesh);
+	}
+	/** Takes every layer of a column out of the navmesh */
+	removeTilesAt(tx, ty) {
+		for (let layer = 0; layer < 32; layer++) {
+			const ref = this.navMesh.getTileRefAt(tx, ty, layer);
+			if (ref) this.navMesh.removeTile(ref);
+		}
+	}
+	/**
+	* Cuts again only these tiles (their keys: those a part of the ground reshaped reaches, `reshape`, and those a slowing
+	* layer was painted on, `groundChanged`) of the whole ground as it is now (`retile`). False, with nothing changed,
+	* where it cannot be (the ground cut on another grid now): it is cut whole
+	*/
+	reshapeTiles(build, tiles) {
+		const grid = this.grid;
+		if (!grid || !build.indices.length) return false;
+		const now = tileGridOf(build);
+		const same = (a, b) => a.every((value, i) => value === b[i]);
+		if (now.tileWidth !== grid.tileWidth || now.tileHeight !== grid.tileHeight || !same(now.bbMin, grid.bbMin) || !same(now.bbMax, grid.bbMax)) return false;
+		const keys = [...new Set(tiles)].sort((a, b) => a - b);
+		return this.retile(build, keys, now.cut);
+	}
+	/**
+	* Cuts these columns of the grid again alone (their keys, in order), each from the build as a whole cut of it would
+	* make it (`groundTileLayers`; `speedOf` where the build is a part of the ground), and keeps their layers apart from
+	* the whole's tile cache (`overridden`, which Recast cannot take a tile out of): the navmesh's tiles there made again
+	* from them with the obstacles on them, in order (`buildColumn`). Only what these columns need is done, however many
+	* were made alone before. False, with nothing changed, where they could not be made: it is cut whole
+	*/
+	retile(build, keys, cut, speedOf) {
+		const made = groundTileLayers(build, keys, cut, speedOf);
+		if (!made) return false;
+		this.drain();
+		for (let i = 0; this.obstaclesDirty; i++) {
+			if (i > 1e5) throw new Error("Navigation: the obstacles never settled");
+			this.obstaclesDirty = !this.updateTiles();
+		}
+		if (!this.overridden) {
+			this.overridden = /* @__PURE__ */ new Map();
+			this.byColumn = /* @__PURE__ */ new Map();
+			for (const [key, obstacle] of this.obstacles) if (obstacle.type === "box") this.indexObstacle(key, obstacle, true);
+		}
+		for (const key of keys) {
+			this.overridden.set(key, made.get(key));
+			this.buildColumn(key, made.get(key));
+		}
+		return true;
+	}
+	/**
+	* The navmesh's tiles of a column made alone (`retile`) made again from its layers, as the whole's tile cache makes a
+	* tile: through a tile cache of that column alone, in the whole's allocator and compressor, with every obstacle about
+	* it put down on it (Detour carves an obstacle into the tiles it touches as it is put down, so the layers go in
+	* first), a batch at a time as Detour queues them. Every layer of the column taken out of the navmesh first: the
+	* ground as it is now may have fewer than it had. Every layer is made again, each once: those an obstacle touches by
+	* Detour as it puts it down, the rest after (an obstacle `columnsOf` puts about a column may touch none of it)
+	*/
+	buildColumn(key, layers) {
+		const tx = Math.floor(key / 65536);
+		const ty = key % 65536;
+		this.removeTilesAt(tx, ty);
+		if (!layers.length) return;
+		const near = [...this.byColumn?.get(key) ?? []];
+		const tileCache = columnTileCache(this.grid.cut, this.owned[0], {
+			tiles: layers.length,
+			obstacles: Math.max(1, near.length)
+		}, this.owned[1], this.owned[2]);
+		if (!tileCache) throw new Error(`Navigation: a tile cache for the tiles at ${tx}, ${ty} could not be made`);
+		const copies = [];
+		try {
+			for (const bytes of layers) {
+				const data = addTileLayer(tileCache, bytes);
+				if (!data) throw new Error(`Navigation: the tiles at ${tx}, ${ty} could not be made again`);
+				copies.push(data);
+			}
+			if (!near.length) {
+				tileCache.buildNavMeshTilesAt(tx, ty, this.navMesh);
+				return;
+			}
+			const settle = () => {
+				for (let i = 0; !tileCache.update(this.navMesh).upToDate; i++) if (i > 1e5) throw new Error("Navigation: the obstacles never settled");
+			};
+			let queued = 0;
+			for (const each of near) {
+				const obstacle = this.obstacles.get(each);
+				if (queued === MAX_REQUESTS) {
+					settle();
+					queued = 0;
+				}
+				tileCache.addBoxObstacle(obstacle.position, obstacle.halfExtents, obstacle.angle);
+				queued++;
+			}
+			settle();
+			if (layers.some((bytes) => !this.navMesh.getTileRefAt(tx, ty, layerOf(bytes)))) tileCache.buildNavMeshTilesAt(tx, ty, this.navMesh);
+		} finally {
+			tileCache.destroy();
+			for (const each of copies) each.destroy();
+		}
+	}
+	/** An obstacle put in the columns it is about (`byColumn`), or taken out of them */
+	indexObstacle(key, obstacle, add) {
+		const byColumn = this.byColumn;
+		if (!byColumn || obstacle.type !== "box") return;
+		const { position, halfExtents } = obstacle;
+		for (const column of this.columnsOf(position.x, position.z, halfExtents.x, halfExtents.z)) {
+			let keys = byColumn.get(column);
+			if (add) {
+				if (!keys) byColumn.set(column, keys = /* @__PURE__ */ new Set());
+				keys.add(key);
+			} else {
+				keys?.delete(key);
+				if (keys?.size === 0) byColumn.delete(column);
+			}
+		}
+	}
+	/** The tiles made alone let go of: the whole's tile cache is the navmesh's again */
+	dropOverridden() {
+		this.overridden = void 0;
+		this.byColumn = void 0;
+		this.requested.clear();
+	}
+	/**
+	* A step of the whole's tile cache's work on what was put down or taken up. Once it is done, the columns made alone
+	* that it made again from its own layers, or that an obstacle came to or went from (`requested`), are made again from
+	* theirs. Whether the whole's is done
+	*/
+	updateTiles() {
+		const upToDate = this.tileCache.update(this.navMesh).upToDate;
+		const overridden = this.overridden;
+		if (!overridden) return upToDate;
+		if (upToDate && this.requested.size) {
+			const columns = [...this.requested].filter((key) => overridden.has(key)).sort((a, b) => a - b);
+			this.requested.clear();
+			for (const key of columns) this.buildTilesAt(key);
+		}
+		return upToDate;
+	}
+	/** The limits it was made with, from the map's size or the options: obstacles, and the steps of a path search */
+	get limits() {
+		return {
+			maxObstacles: this.maxObstacles,
+			maxNodes: this.maxNodes
+		};
+	}
+	/** How many agents the crowd has room for before it has to make more */
+	get capacity() {
+		return this.maxAgents;
+	}
+	/**
+	* Makes room for twice as many agents. A crowd (Detour's) is made for a number of agents and cannot grow, so a new
+	* one is made and every agent moved over as it is: where it is, how fast it goes, where to
+	*/
+	grow() {
+		const saves = [...this.agents].map(([id, entry]) => [id, entry.phasing ? entry : this.saveAgent(id)]);
+		const old = this.crowd;
+		this.maxAgents *= 2;
+		this.crowd = crowdOf(this.navMesh, this.maxAgents, this.agentRadius, this.avoidance, !!this.ground);
+		this.agents.clear();
+		for (const [id, kept] of saves) if ("agent" in kept) this.agents.set(id, kept);
+		else this.restoreAgent(id, kept);
+		this.remakeMirrors();
+		old.destroy();
+	}
+	/** Makes room for twice as many agents that phase, as `grow` does for the others: their crowd made anew */
+	growPhasers() {
+		const saves = [...this.agents].map(([id, entry]) => [id, entry.phasing ? this.saveAgent(id) : entry]);
+		const old = this.phasers;
+		this.phasersRoom *= 2;
+		this.phasers = crowdOf(this.navMesh, this.phasersRoom, this.agentRadius, this.avoidance, !!this.ground);
+		this.agents.clear();
+		for (const [id, kept] of saves) if ("agent" in kept) this.agents.set(id, kept);
+		else this.restoreAgent(id, kept);
+		old.destroy();
+	}
+	/** The crowd an agent walks on: the one of those that phase, or everyone's */
+	crowdFor(entry) {
+		return entry.phasing ? this.phasers : this.crowd;
+	}
+	toVec3(p, into = this.scratch) {
+		into.x = p.x;
+		into.y = this.heightAt(p.x, p.z);
+		into.z = p.z;
+		return into;
+	}
+	addAgent(id, position, params) {
+		if (this.asked) this.settleGround();
+		this.place(id, position, params, false);
+	}
+	/** An agent put on the crowd, or on the crowd of those that phase (`setPhasing`) */
+	place(id, position, params, phasing) {
+		if (this.agents.has(id)) this.removeAgent(id);
+		const start = this.closestPoint(position, 8) ?? position;
+		const agentParams = {
+			radius: params.radius,
+			height: 2,
+			maxSpeed: params.speed,
+			maxAcceleration: params.speed * 10,
+			collisionQueryRange: params.radius * 8,
+			pathOptimizationRange: params.radius * 30,
+			separationWeight: this.separation,
+			updateFlags: phasing ? GHOST_FLAGS : RESTING_FLAGS,
+			obstacleAvoidanceType: AVOIDANCE_SLOT
+		};
+		if (phasing) agentParams.collisionQueryRange = .01;
+		const agent = phasing ? this.seatPhasing(start, agentParams) : this.seat(start, agentParams);
+		this.agents.set(id, {
+			agent,
+			radius: params.radius,
+			anchored: false,
+			anchorX: start.x,
+			anchorZ: start.z,
+			ghost: false,
+			...phasing && { phasing: true },
+			target: null,
+			flags: phasing ? GHOST_FLAGS : RESTING_FLAGS
+		});
+	}
+	/** An agent put on the crowd of those that phase: made as the first comes, and made bigger as it fills, as `seat` does */
+	seatPhasing(at, params) {
+		if (!this.phasers) {
+			this.phasersRoom = Math.min(this.firstMaxAgents, 64);
+			this.phasers = crowdOf(this.navMesh, this.phasersRoom, this.agentRadius, this.avoidance, !!this.ground);
+		}
+		const agent = this.phasers.addAgent(this.toVec3(at), params);
+		if (agent.agentIndex >= 0) return agent;
+		this.growPhasers();
+		const again = this.phasers.addAgent(this.toVec3(at), params);
+		if (again.agentIndex < 0) throw new Error(`Navigation: the crowd of those that phase has room for ${this.phasersRoom} agents and takes no more`);
+		return again;
+	}
+	/**
+	* An agent walks through every other and every other through it (`BuffDef.phasing`), or no longer does: moved over to
+	* the crowd of those that phase, or back, as it stands (where, how fast, where to)
+	*/
+	setPhasing(id, phasing) {
+		if (this.asked) this.settleGround();
+		const entry = this.agents.get(id);
+		if (!entry || !!entry.phasing === phasing) return;
+		const save = this.saveAgent(id);
+		this.restoreAgent(id, {
+			...save,
+			phasing: phasing || void 0
+		});
+	}
+	/** An agent put on the crowd. A full crowd says so with an index of -1, and an agent like that never moves: room is made, and it goes in again */
+	seat(at, params) {
+		const agent = this.crowd.addAgent(this.toVec3(at), params);
+		if (agent.agentIndex >= 0) return agent;
+		this.grow();
+		const again = this.crowd.addAgent(this.toVec3(at), params);
+		if (again.agentIndex < 0) throw new Error(`Navigation: the crowd has room for ${this.maxAgents} agents and takes no more`);
+		return again;
+	}
+	removeAgent(id) {
+		if (this.asked) this.settleGround();
+		const entry = this.agents.get(id);
+		if (!entry) return;
+		this.crowdFor(entry).removeAgent(entry.agent);
+		this.agents.delete(id);
+	}
+	readMotion(id, out) {
+		if (this.asked) this.settleGround();
+		const entry = this.agents.get(id);
+		if (!entry) return false;
+		const { raw } = entry.agent;
+		out.x = raw.get_npos(0);
+		out.y = raw.get_npos(1);
+		out.z = raw.get_npos(2);
+		out.vx = raw.get_vel(0);
+		out.vz = raw.get_vel(2);
+		return true;
+	}
+	addMirror(id, motion, radius, ghost) {
+		if (this.asked) this.settleGround();
+		this.removeMirror(id);
+		const mirror = this.mirrorAt({
+			x: motion.x,
+			z: motion.z
+		}, radius, ghost);
+		this.mirrors.set(id, mirror);
+		this.moveMirrorTo(mirror, motion);
+	}
+	/** Asleep from the first (Detour's `INVALID`, as an anchored agent is): of the crowd's step it is only ever a neighbour */
+	mirrorAt(at, radius, ghost) {
+		const agent = this.seat(at, {
+			radius,
+			height: 2,
+			maxSpeed: 0,
+			maxAcceleration: 0,
+			collisionQueryRange: .01,
+			pathOptimizationRange: .01,
+			separationWeight: 0,
+			updateFlags: 0,
+			obstacleAvoidanceType: AVOIDANCE_SLOT
+		});
+		agent.raw.state = INVALID;
+		return {
+			agent,
+			radius,
+			anchored: true,
+			anchorX: NaN,
+			anchorZ: NaN,
+			ghost,
+			target: null,
+			flags: 0,
+			y: NaN,
+			vx: NaN,
+			vz: NaN
+		};
+	}
+	moveMirror(id, motion) {
+		if (this.asked) this.settleGround();
+		const mirror = this.mirrors.get(id);
+		if (mirror) this.moveMirrorTo(mirror, motion);
+	}
+	/** Written only where it changed, each number a call into WebAssembly: one standing still costs nothing */
+	moveMirrorTo(mirror, { x, y, z, vx, vz }) {
+		const { raw } = mirror.agent;
+		if (x !== mirror.anchorX || y !== mirror.y || z !== mirror.anchorZ) {
+			mirror.anchorX = x;
+			mirror.y = y;
+			mirror.anchorZ = z;
+			if (!mirror.phasing) {
+				raw.set_npos(0, x);
+				raw.set_npos(1, y);
+				raw.set_npos(2, z);
+			}
+		}
+		if (vx !== mirror.vx || vz !== mirror.vz) {
+			mirror.vx = vx;
+			mirror.vz = vz;
+			raw.set_vel(0, vx);
+			raw.set_vel(2, vz);
+			raw.set_dvel(0, vx);
+			raw.set_dvel(2, vz);
+		}
+	}
+	setMirrorGhost(id, ghost) {
+		if (this.asked) this.settleGround();
+		const mirror = this.mirrors.get(id);
+		if (mirror) mirror.ghost = ghost;
+	}
+	setMirrorPhasing(id, phasing) {
+		if (this.asked) this.settleGround();
+		const mirror = this.mirrors.get(id);
+		if (!mirror || !!mirror.phasing === phasing) return;
+		if (phasing) mirror.phasing = true;
+		else delete mirror.phasing;
+		const { raw } = mirror.agent;
+		raw.set_npos(0, phasing ? PARKED : mirror.anchorX);
+		raw.set_npos(1, mirror.y);
+		raw.set_npos(2, phasing ? PARKED : mirror.anchorZ);
+	}
+	removeMirror(id) {
+		if (this.asked) this.settleGround();
+		const mirror = this.mirrors.get(id);
+		if (!mirror) return;
+		this.crowd.removeAgent(mirror.agent);
+		this.mirrors.delete(id);
+	}
+	/** The mirrors put on a crowd made anew, after its agents and in the order they were, as they stood */
+	remakeMirrors() {
+		const mirrors = [...this.mirrors];
+		this.mirrors.clear();
+		for (const [id, { anchorX: x, y, anchorZ: z, vx, vz, radius, ghost, phasing }] of mirrors) {
+			const mirror = this.mirrorAt({
+				x,
+				z
+			}, radius, ghost);
+			this.mirrors.set(id, mirror);
+			this.moveMirrorTo(mirror, {
+				x,
+				y,
+				z,
+				vx,
+				vz
+			});
+			if (phasing) this.setMirrorPhasing(id, true);
+		}
+	}
+	hasAgent(id) {
+		return this.agents.has(id);
+	}
+	setDestination(id, target) {
+		if (this.asked) this.settleGround();
+		const entry = this.agents.get(id);
+		if (!entry) return false;
+		const snapped = this.closestPoint(target, 6);
+		if (!snapped) return false;
+		this.wake(entry);
+		if (!entry.target && !entry.ghost && !entry.phasing) this.setFlags(entry, DEFAULT_FLAGS);
+		entry.target = snapped;
+		return entry.agent.requestMoveTarget(this.toVec3(snapped));
+	}
+	clearDestination(id) {
+		if (this.asked) this.settleGround();
+		const entry = this.agents.get(id);
+		if (!entry) return;
+		if (entry.target && !entry.ghost && !entry.phasing) this.setFlags(entry, RESTING_FLAGS);
+		entry.target = null;
+		entry.agent.resetMoveTarget();
+	}
+	teleport(id, position) {
+		if (this.asked) this.settleGround();
+		const entry = this.agents.get(id);
+		if (!entry) return;
+		const snapped = this.closestPoint(position, 8) ?? position;
+		entry.agent.teleport(this.toVec3(snapped));
+		entry.anchorX = snapped.x;
+		entry.anchorZ = snapped.z;
+		if (entry.anchored) entry.agent.raw.state = INVALID;
+	}
+	setAnchored(id, anchored) {
+		if (this.asked) this.settleGround();
+		const entry = this.agents.get(id);
+		if (!entry || entry.anchored === anchored) return;
+		if (!anchored) {
+			this.wake(entry);
+			return;
+		}
+		const { agent } = entry;
+		const { raw } = agent;
+		entry.anchored = true;
+		entry.anchorX = raw.get_npos(0);
+		entry.anchorZ = raw.get_npos(2);
+		if (entry.target && !entry.ghost && !entry.phasing) this.setFlags(entry, RESTING_FLAGS);
+		entry.target = null;
+		agent.resetMoveTarget();
+		for (let i = 0; i < 3; i++) raw.set_vel(i, 0);
+		raw.state = INVALID;
+	}
+	/** Lets an anchored agent go: walking again, from where it stood. Detour checks the ground under it on its next step */
+	wake(entry) {
+		if (!entry.anchored) return;
+		entry.anchored = false;
+		entry.agent.raw.state = WALKING;
+	}
+	setGhost(id, ghost) {
+		if (this.asked) this.settleGround();
+		const entry = this.agents.get(id);
+		if (!entry || entry.ghost === ghost) return;
+		entry.ghost = ghost;
+		if (entry.phasing) return;
+		entry.flags = ghost ? GHOST_FLAGS : entry.target ? DEFAULT_FLAGS : RESTING_FLAGS;
+		entry.agent.updateParameters({
+			updateFlags: entry.flags,
+			collisionQueryRange: ghost ? .01 : entry.radius * 8
+		});
+	}
+	setSpeed(id, speed) {
+		if (this.asked) this.settleGround();
+		this.agents.get(id)?.agent.updateParameters({
+			maxSpeed: speed,
+			maxAcceleration: Math.max(speed * 10, BRAKING)
+		});
+	}
+	saveAgent(id) {
+		if (this.asked) this.settleGround();
+		const entry = this.agents.get(id);
+		if (!entry) return void 0;
+		const { agent, radius, target, anchored, ghost } = entry;
+		const p = agent.position();
+		const v = agent.velocity();
+		return {
+			x: p.x,
+			z: p.z,
+			vx: v.x,
+			vz: v.z,
+			radius,
+			speed: agent.maxSpeed,
+			acceleration: agent.maxAcceleration,
+			target: target && {
+				x: target.x,
+				z: target.z
+			},
+			anchored,
+			anchor: anchored ? {
+				x: entry.anchorX,
+				z: entry.anchorZ
+			} : void 0,
+			ghost,
+			...entry.phasing && { phasing: true }
+		};
+	}
+	reseat(agents) {
+		if (this.asked) this.settleGround();
+		const old = this.crowd;
+		this.maxAgents = this.firstMaxAgents;
+		this.crowd = crowdOf(this.navMesh, this.maxAgents, this.agentRadius, this.avoidance, !!this.ground);
+		this.agents.clear();
+		this.mirrors.clear();
+		old.destroy();
+		this.phasers?.destroy();
+		this.phasers = void 0;
+		for (const [id, save] of agents) this.restoreAgent(id, save);
+	}
+	restoreAgent(id, save) {
+		if (this.asked) this.settleGround();
+		this.place(id, {
+			x: save.x,
+			z: save.z
+		}, {
+			radius: save.radius,
+			speed: save.speed
+		}, !!save.phasing);
+		const entry = this.agents.get(id);
+		const { agent } = entry;
+		const at = save.anchored ? save.anchor ?? save : save;
+		agent.teleport({
+			x: at.x,
+			y: this.heightAt(at.x, at.z),
+			z: at.z
+		});
+		entry.anchorX = at.x;
+		entry.anchorZ = at.z;
+		if (save.acceleration !== void 0) agent.updateParameters({ maxAcceleration: save.acceleration });
+		this.setGhost(id, save.ghost);
+		if (save.target) this.setDestination(id, save.target);
+		if (save.anchored) {
+			this.setAnchored(id, true);
+			return;
+		}
+		agent.raw.set_vel(0, save.vx);
+		agent.raw.set_vel(2, save.vz);
+	}
+	settle(version) {
+		this.drain();
+		for (let i = 0; this.obstaclesDirty; i++) {
+			if (i > 1e5) throw new Error("Navigation: the obstacles never settled");
+			this.obstaclesDirty = !this.updateTiles();
+		}
+		this.changes = version;
+		for (let i = 0; i < 1e3 && [...this.agents.values()].some(({ agent }) => PLANNING.has(agent.raw.targetState)); i++) {
+			this.crowd.update(0);
+			this.phasers?.update(0);
+		}
+	}
+	readAgent(id, out) {
+		if (this.asked) this.settleGround();
+		const entry = this.agents.get(id);
+		if (!entry) return false;
+		if (entry.anchored) {
+			out.x = entry.anchorX;
+			out.z = entry.anchorZ;
+			out.vx = 0;
+			out.vz = 0;
+			out.cx = out.nx = entry.anchorX;
+			out.cz = out.nz = entry.anchorZ;
+			return true;
+		}
+		const raw = entry.agent.raw;
+		out.x = raw.get_npos(0);
+		out.z = raw.get_npos(2);
+		out.vx = raw.get_vel(0);
+		out.vz = raw.get_vel(2);
+		const corners = raw.ncorners;
+		if (corners > 0) {
+			out.cx = raw.get_cornerVerts(0);
+			out.cz = raw.get_cornerVerts(2);
+		} else {
+			out.cx = raw.get_targetPos(0);
+			out.cz = raw.get_targetPos(2);
+		}
+		if (corners > 1) {
+			out.nx = raw.get_cornerVerts(3);
+			out.nz = raw.get_cornerVerts(5);
+		} else {
+			out.nx = out.cx;
+			out.nz = out.cz;
+		}
+		return true;
+	}
+	update(dt) {
+		this.drain();
+		if (this.obstaclesDirty) {
+			for (let i = 0; i < 32; i++) if (this.updateTiles()) {
+				this.obstaclesDirty = false;
+				break;
+			}
+			this.changes++;
+		}
+		if (this.walls === "soft") this.steer();
+		this.crowd.update(dt);
+		this.phasers?.update(dt);
+	}
+	/** The flags an agent steers by, set on the crowd only where they change: one call into WebAssembly */
+	setFlags(entry, flags) {
+		if (entry.flags === flags) return;
+		entry.flags = flags;
+		entry.agent.raw.params.updateFlags = flags;
+	}
+	/**
+	* `walls: 'soft'`: an agent walking somewhere steers among velocities (obstacle avoidance) only while another agent
+	* (walking or standing, anchored too, not a ghost) is within its reach, its collision query range (eight of its
+	* radii); otherwise it follows its path, pushed apart from those near it (separation) but never slowed by a wall it
+	* touches. Read from where every agent is as the tick starts, in a grid of cells as large as the longest reach, so
+	* that a game loaded from a save steers as the game it was saved from (Detour's own lists of neighbours are of the
+	* tick before, and a crowd made anew has none)
+	*/
+	steer() {
+		const near = this.near;
+		let count = 0;
+		let walking = 0;
+		let cell = 0;
+		for (const entry of this.agents.values()) {
+			if (entry.ghost || entry.phasing) continue;
+			near[count++] = entry;
+			if (entry.target && !entry.anchored) {
+				walking++;
+				cell = Math.max(cell, entry.radius * 8);
+			}
+		}
+		if (walking > 0) {
+			for (const mirror of this.mirrors.values()) if (!mirror.ghost) near[count++] = mirror;
+		}
+		near.length = count;
+		if (walking === 0) return;
+		if (this.nearX.length < count) {
+			this.nearX = new Float64Array(count * 2);
+			this.nearZ = new Float64Array(count * 2);
+			this.nearNext = new Int32Array(count * 2);
+		}
+		const xs = this.nearX;
+		const zs = this.nearZ;
+		const next = this.nearNext;
+		const heads = this.nearHeads;
+		heads.clear();
+		for (let i = 0; i < count; i++) {
+			const entry = near[i];
+			if (entry.anchored) {
+				xs[i] = entry.anchorX;
+				zs[i] = entry.anchorZ;
+			} else {
+				xs[i] = entry.agent.raw.get_npos(0);
+				zs[i] = entry.agent.raw.get_npos(2);
+			}
+			const key = Math.floor(xs[i] / cell) * 65536 + Math.floor(zs[i] / cell);
+			next[i] = heads.get(key) ?? -1;
+			heads.set(key, i);
+		}
+		for (let i = 0; i < count; i++) {
+			const entry = near[i];
+			if (!entry.target || entry.anchored) continue;
+			const reach = entry.radius * 8;
+			const cx = Math.floor(xs[i] / cell);
+			const cz = Math.floor(zs[i] / cell);
+			let steers = false;
+			for (let dx = -1; dx <= 1 && !steers; dx++) for (let dz = -1; dz <= 1 && !steers; dz++) for (let j = heads.get((cx + dx) * 65536 + cz + dz) ?? -1; j >= 0; j = next[j]) {
+				if (j === i) continue;
+				const ox = xs[j] - xs[i];
+				const oz = zs[j] - zs[i];
+				if (ox * ox + oz * oz < reach * reach) {
+					steers = true;
+					break;
+				}
+			}
+			this.setFlags(entry, steers ? DEFAULT_FLAGS : RESTING_FLAGS);
+		}
+	}
+	addObstacle(key, rect) {
+		if (this.asked) this.settleGround();
+		this.removeObstacle(key);
+		if (this.obstacles.size >= this.maxObstacles) return false;
+		const y = this.terrain.heightAt(rect.x, rect.z);
+		const half = {
+			x: rect.hw + this.agentRadius,
+			y: 4,
+			z: rect.hd + this.agentRadius
+		};
+		this.makeRoom(rect.x, rect.z, half.x, half.z);
+		const result = this.tileCache.addBoxObstacle({
+			x: rect.x,
+			y,
+			z: rect.z
+		}, half, 0);
+		if (!result.success) return false;
+		this.obstacles.set(key, result.obstacle);
+		if (this.overridden) {
+			this.indexObstacle(key, result.obstacle, true);
+			for (const column of this.columnsOf(rect.x, rect.z, half.x, half.z)) this.requested.add(column);
+		}
+		this.flushObstacles();
+		return true;
+	}
+	/**
+	* Holds obstacles back (true) or lets them go (false): while held, a request to put one down or take one up waits in
+	* the tile cache, and they are made into tiles together when let go or at the first thing asked of the navigation
+	* before that, each tile once however many obstacles are on it. The same tiles come of it as of making them one by
+	* one: a wooded tile is made once, not once a tree (RV42). The version goes up for each obstacle all the same
+	*/
+	holdObstacles(hold) {
+		if (this.asked) this.settleGround();
+		if (this.holding === hold) return;
+		this.holding = hold;
+		if (!hold) return this.drain();
+		if (this.obstaclesDirty) {
+			this.held = 1;
+			this.drain();
+			this.obstaclesDirty = true;
+		}
+	}
+	/**
+	* Makes room for one more held request, of an obstacle at (x, z) of these half sizes: the ones held are made into
+	* tiles first when the tile cache would take no more of them (Detour queues 64), or when their tiles together would
+	* be more than it makes again from one batch (64, past which it leaves the rest as they were)
+	*/
+	makeRoom(x, z, hw, hd) {
+		if (!this.holding) return;
+		const columns = this.columnsOf(x, z, hw, hd);
+		let more = 0;
+		for (const column of columns) if (!this.heldColumns.has(column)) more++;
+		if (this.held + 1 > MAX_REQUESTS || this.heldColumns.size + more > MAX_HELD_COLUMNS) this.drain();
+		for (const column of columns) this.heldColumns.add(column);
+	}
+	/**
+	* The columns of the tile grid an obstacle touches, or more: Detour takes a box obstacle's bounds as a square 1.41 times
+	* its longer half side about its middle, here 1.5 times, so that rounding never leaves one out. More, then, and not
+	* Detour's own test (which also weighs each layer's walkable cells and heights): what is done with a column here holds
+	* for one the obstacle does not touch (`buildColumn` makes every layer of it however that falls out)
+	*/
+	columnsOf(x, z, hw, hd) {
+		const { size, originX, originZ } = this.tiles;
+		const reach = 1.5 * Math.max(hw, hd);
+		const x0 = Math.floor((x - reach - originX) / size);
+		const x1 = Math.floor((x + reach - originX) / size);
+		const z0 = Math.floor((z - reach - originZ) / size);
+		const z1 = Math.floor((z + reach - originZ) / size);
+		const columns = [];
+		for (let tx = x0; tx <= x1; tx++) for (let tz = z0; tz <= z1; tz++) columns.push(tx * 65536 + tz);
+		return columns;
+	}
+	/** Every held request made into tiles: the tile cache up to date */
+	drain() {
+		if (this.asked) this.settleGround();
+		if (!this.held) return;
+		this.held = 0;
+		this.heldColumns.clear();
+		for (let i = 0; !this.updateTiles(); i++) if (i > 1e5) throw new Error("Navigation: the obstacles never settled");
+		this.obstaclesDirty = false;
+	}
+	obstacleRoom() {
+		return this.maxObstacles - this.obstacles.size;
+	}
+	removeObstacle(key) {
+		if (this.asked) this.settleGround();
+		const obstacle = this.obstacles.get(key);
+		if (!obstacle) return;
+		if (this.holding && obstacle.type === "box") {
+			const { position, halfExtents } = obstacle;
+			this.makeRoom(position.x, position.z, halfExtents.x, halfExtents.z);
+		}
+		this.tileCache.removeObstacle(obstacle);
+		this.obstacles.delete(key);
+		if (this.overridden && obstacle.type === "box") {
+			this.indexObstacle(key, obstacle, false);
+			const { position, halfExtents } = obstacle;
+			for (const column of this.columnsOf(position.x, position.z, halfExtents.x, halfExtents.z)) this.requested.add(column);
+		}
+		this.flushObstacles();
+	}
+	/**
+	* The tile cache only queues a limited number of requests, so process them as they come: but while they are held
+	* (`holdObstacles`), when they wait to be made into tiles together
+	*/
+	flushObstacles() {
+		if (this.holding) this.held++;
+		else this.obstaclesDirty = !this.updateTiles();
+		this.changes++;
+	}
+	closestPoint(point, searchRadius = 4) {
+		this.drain();
+		const query = this.closestQuery;
+		query.halfExtents.x = searchRadius;
+		query.halfExtents.z = searchRadius;
+		const result = this.query.findClosestPoint(this.toVec3(point), query);
+		if (!result.success || result.polyRef === 0) return null;
+		return {
+			x: result.point.x,
+			z: result.point.z
+		};
+	}
+	findPath(from, to) {
+		this.drain();
+		const result = this.query.computePath(this.toVec3(from), this.toVec3(to, this.scratchEnd));
+		if (!result.success || result.path.length === 0) return null;
+		return result.path.map((p) => ({
+			x: p.x,
+			z: p.z
+		}));
+	}
+	debugGeometry() {
+		this.drain();
+		const drawer = new DebugDrawerUtils();
+		const primitives = drawer.drawNavMesh(this.navMesh);
+		const triangles = [];
+		const lines = [];
+		for (const primitive of primitives) {
+			const target = primitive.type === "tris" ? triangles : primitive.type === "lines" ? lines : null;
+			if (!target) continue;
+			for (const v of primitive.vertices) target.push(v[0], v[1], v[2]);
+		}
+		drawer.dispose();
+		return {
+			triangles: new Float32Array(triangles),
+			lines: new Float32Array(lines)
+		};
+	}
+	dispose() {
+		this.asked = void 0;
+		this.dropOverridden();
+		this.crowd.destroy();
+		this.phasers?.destroy();
+		this.query.destroy();
+		this.tileCache.destroy();
+		this.navMesh.destroy();
+		for (const each of this.owned) {
+			const raw = each instanceof TileCacheMeshProcess ? each.raw : each;
+			if (raw) Raw.destroy(raw);
+		}
+		this.owned = [];
+		this.agents.clear();
+		this.mirrors.clear();
+		this.obstacles.clear();
+	}
+};
+//#endregion
+export { AVOIDANCE_LEVELS, DEFAULT_AVOIDANCE, RecastNavigation, SOFT_WALLS };
+
+//# sourceMappingURL=recast.js.map