@v12-engine/engine 0.1.0 → 0.4.0

package/dist/systems/movement.js

@@ -0,0 +1,1247 @@
+import { atan2, hypot } from "../exactMath.js";
+import { closestPointOnRect, dist, rotateTowards } from "../math.js";
+import { distanceToEdge, edgeDistance, fighting, moving } from "../entity.js";
+import { isPhasing } from "../abilities/buffs.js";
+import { spotFor } from "../engagement.js";
+//#region src/systems/movement.ts
+/**
+* How close to a point counts as having reached it
+*
+* @internal
+*/
+var ARRIVE_RANGE = .2;
+/** How fast a unit turns, in radians a second: its type's `turnRate`, else the game's (`RuleSettings.movement.turnRate`) */
+var turnRateOf = (world, entity) => entity.def.turnRate ?? world.settings.movement.turnRate;
+/**
+* Point a unit should walk to in order to reach the target: next to its edge for structures, its spot around it for
+* one fighting it (see `engagement.ts`)
+*/
+function approachPoint(world, entity, target) {
+	if (entity.flying) return target.pos;
+	if (target.def.footprint) return closestPointOnRect(entity.pos, target.rect, entity.def.radius + .15);
+	return entity.get(fighting)?.engaged === target.id ? spotFor(world, entity, target) : target.pos;
+}
+/**
+* How far along its route a unit is sent at a time (`Rules.paths: 'seen'`): as far as it sees, between 4 and 12.
+* The navigation finds its way over that stretch with every building in it; one that changes the way is in sight, so
+* its side sees it, and the route is planned again with it
+*/
+var stretchOf = (entity) => Math.min(Math.max(entity.def.sight ?? 8, 4), 12);
+/** The team whose knowledge a ground unit's route is planned with, or none where routes know everything */
+/** The movement of a unit this system runs for: it picks those that have one, so a unit without is a fault, said as such */
+function movementOf(entity) {
+	const m = entity.get(moving);
+	if (!m) throw new Error(`${entity.def.id} ${entity.id} is moved but has no movement`);
+	return m;
+}
+function sideOf(world, entity) {
+	const paths = world.sidePaths;
+	if (!paths || entity.flying || entity.def.naval) return void 0;
+	const team = world.player(entity.owner).team;
+	return paths.has(team) ? team : void 0;
+}
+/** Plans a unit's route to its goal with what its side knows: none where its side knows no way, or the goal is in sight */
+function planRoute(world, entity, team) {
+	const m = movementOf(entity);
+	const paths = world.sidePaths;
+	if (!paths) return;
+	m.routeVersion = paths.version(team);
+	m.routeAt = 1;
+	if (dist(entity.pos, m.navGoal) <= stretchOf(entity)) {
+		m.route = void 0;
+		return;
+	}
+	const route = paths.route(team, entity.pos, m.navGoal);
+	m.route = route && route.length > 1 ? route.map(({ x, z }) => ({
+		x,
+		z
+	})) : void 0;
+}
+/** How far a point is from a segment */
+function distToSegment(p, a, b) {
+	const dx = b.x - a.x;
+	const dz = b.z - a.z;
+	const length = dx * dx + dz * dz;
+	const t = length > 0 ? Math.min(Math.max(((p.x - a.x) * dx + (p.z - a.z) * dz) / length, 0), 1) : 0;
+	return hypot(p.x - (a.x + dx * t), p.z - (a.z + dz * t));
+}
+/** The point a stretch ahead of a unit along its route; its goal itself once that is within the stretch */
+function stretchPoint(entity) {
+	const m = movementOf(entity);
+	const route = m.route;
+	if (!route) return m.navGoal;
+	let leg = Math.max((m.routeAt ?? 1) - 1, 0);
+	let nearest = Infinity;
+	for (let i = leg; i < route.length - 1; i++) {
+		const d = distToSegment(entity.pos, route[i], route[i + 1]);
+		if (d < nearest - 1e-9) {
+			nearest = d;
+			leg = i;
+		}
+	}
+	const at = Math.min(leg + 1, route.length - 1);
+	m.routeAt = at;
+	let left = stretchOf(entity);
+	let from = entity.pos;
+	for (let i = at; i < route.length; i++) {
+		const length = dist(from, route[i]);
+		if (length >= left) {
+			const t = left / length;
+			return {
+				x: from.x + (route[i].x - from.x) * t,
+				z: from.z + (route[i].z - from.z) * t
+			};
+		}
+		left -= length;
+		from = route[i];
+	}
+	return m.navGoal;
+}
+/** Sends the navigation where the unit is to walk now: its goal, or a stretch along its route */
+function walk(world, entity) {
+	const m = movementOf(entity);
+	const to = m.route ? stretchPoint(entity) : m.navGoal;
+	m.stretch = m.route ? {
+		x: to.x,
+		z: to.z
+	} : void 0;
+	return world.nav.setDestination(entity.id, to);
+}
+/** Sends a walking unit on as it was, after something held it (a builder waiting for room): its stretch, or its goal */
+function walkOn(world, entity) {
+	if (entity.get(moving)?.status === "moving") walk(world, entity);
+}
+function beginMove(world, entity, navGoal) {
+	const m = movementOf(entity);
+	m.bestDistance = Infinity;
+	m.finalFacing = null;
+	m.stalledTime = 0;
+	m.slowTime = 0;
+	m.detour = void 0;
+	delete m.tries;
+	delete m.triedAt;
+	m.navGoal.x = navGoal.x;
+	m.navGoal.z = navGoal.z;
+	m.navVersion = world.nav.version;
+	m.stuck = false;
+	if (m.anchored) {
+		m.anchored = false;
+		world.nav.setAnchored(entity.id, false);
+	}
+	const team = sideOf(world, entity);
+	if (team === void 0) m.route = void 0;
+	else planRoute(world, entity, team);
+	m.status = walk(world, entity) ? "moving" : "failed";
+}
+/**
+* Sends a unit walking to a point, the way around what is in the way. How it goes is in `entity.movement.status`:
+* `moving` on the way, `arrived` once there, `failed` when there is no way there or it got stuck. Held up by others
+* it tries again a few times before it gives up (`MovementState.tries`). An order calls this once and then watches the
+* status; calling it again with the same goal starts the walk over
+*
+* @beta
+*/
+function moveTo(world, entity, goal, options = {}) {
+	const m = entity.get(moving);
+	if (!m || entity.hidden) return;
+	m.goal.x = goal.x;
+	m.goal.z = goal.z;
+	m.goalEntity = 0;
+	m.range = options.range ?? .2;
+	m.groupId = options.groupId ?? 0;
+	m.aside = options.aside || void 0;
+	delete m.asideDepth;
+	if (!options.aside) leavePlace(m);
+	beginMove(world, entity, goal);
+	m.finalFacing = options.facing ?? null;
+}
+/**
+* Walks towards an entity until within `range` of its edge. Safe to call every tick.
+*
+* @beta
+*/
+function moveToEntity(world, entity, target, range) {
+	const m = entity.get(moving);
+	if (!m || entity.hidden) return;
+	if (m.status === "moving" && m.goalEntity === target.id && m.range === range) return;
+	m.goalEntity = target.id;
+	m.range = range;
+	m.groupId = 0;
+	m.aside = void 0;
+	leavePlace(m);
+	beginMove(world, entity, approachPoint(world, entity, target));
+}
+/**
+* Whether the unit is on its way to this very point
+*
+* @internal
+*/
+function isMovingTo(entity, goal) {
+	const m = entity.get(moving);
+	return !!m && m.status === "moving" && m.goalEntity === 0 && m.goal.x === goal.x && m.goal.z === goal.z;
+}
+/**
+* Stops a unit where it is. Its status is `idle` after
+*
+* @beta
+*/
+function halt(world, entity) {
+	const m = entity.get(moving);
+	if (!m) return;
+	if (m.status === "moving") world.nav.clearDestination(entity.id);
+	m.status = "idle";
+	m.goalEntity = 0;
+	m.groupId = 0;
+	m.detour = void 0;
+}
+/** A unit that walks off on a move of its own: it has no place to go back to (`MovementState.place`) */
+function leavePlace(m) {
+	delete m.place;
+	delete m.backTries;
+}
+/**
+* Marks a unit as one of a formation sent to its places (`orderCommand`, with the order's group): it keeps the place it
+* gets to (`MovementState.place`). Without a group, it is of none: given another order, it keeps no place
+*
+* @internal
+*/
+function joinFormation(entity, groupId = 0) {
+	const m = entity.get(moving);
+	if (!m) return;
+	leavePlace(m);
+	if (groupId) m.formation = groupId;
+	else delete m.formation;
+}
+/**
+* Anchored units stand their ground instead of being pushed around by units walking past.
+*
+* @beta
+*/
+function setAnchored(world, entity, anchored) {
+	const m = entity.get(moving);
+	if (!m || m.anchored === anchored) return;
+	if (anchored && m.status === "moving") halt(world, entity);
+	m.anchored = anchored;
+	world.nav.setAnchored(entity.id, anchored);
+}
+/**
+* Ghosts walk through other units. Classic RTS games do this for workers hauling resources so mining never jams.
+*
+* @beta
+*/
+function setGhost(world, entity, ghost) {
+	const m = entity.get(moving);
+	if (!m || m.ghost === ghost) return;
+	m.ghost = ghost;
+	world.nav.setGhost(entity.id, ghost || !world.nav.setPhasing && !!m.phased);
+}
+/**
+* Units that carry a buff that has them walk through others (`BuffDef.phasing`) phase on the navigation while they do
+* (`Navigation.setPhasing`: on a crowd of their own, nobody's neighbour), and are not gone round nor asked aside.
+* Walls, cliffs, buildings and trees are the navigation's ground, and stop them all the same
+*/
+function seeToPhasing(world) {
+	for (const entity of world.index.with(moving)) {
+		const m = entity.get(moving);
+		if (!m) continue;
+		const phasing = entity.buffs.length > 0 && entity.alive && !entity.hidden && isPhasing(world, entity);
+		if (phasing === !!m.phased) continue;
+		if (phasing) m.phased = true;
+		else delete m.phased;
+		if (world.nav.setPhasing) world.nav.setPhasing(entity.id, phasing);
+		else world.nav.setGhost(entity.id, phasing || m.ghost);
+	}
+}
+/**
+* Turns a unit a little towards a point, as far as it turns in `dt` seconds (its type's `turnRate`, else the game's:
+* `RuleSettings.movement.turnRate`). For orders that aim at something
+*
+* @beta
+*/
+function faceTowards(world, entity, point, dt) {
+	const m = entity.get(moving);
+	if (m) m.finalFacing = null;
+	const desired = atan2(point.x - entity.pos.x, point.z - entity.pos.z);
+	entity.facing = rotateTowards(entity.facing, desired, turnRateOf(world, entity) * dt);
+}
+function arrive(world, entity) {
+	world.nav.clearDestination(entity.id);
+	const m = movementOf(entity);
+	m.status = "arrived";
+	m.stalledTime = 0;
+	if (m.groupId && m.formation === m.groupId && !m.aside && !m.goalEntity) {
+		m.place = {
+			x: m.goal.x,
+			z: m.goal.z
+		};
+		if (dist(entity.pos, m.place) <= PLACE_OFF) delete m.backTries;
+	} else if (m.place && dist(entity.pos, m.place) <= PLACE_OFF) delete m.backTries;
+}
+/** True when the unit is bumping into a member of its own group that already reached its spot. */
+function blockedByArrivedGroupMate(world, entity) {
+	const m = movementOf(entity);
+	if (!m.groupId) return false;
+	world.spatial.query(entity.pos.x, entity.pos.z, entity.def.radius + 1, neighbours);
+	for (const other of neighbours) {
+		const om = other.get(moving);
+		if (other === entity || !om || other.flying !== entity.flying) continue;
+		if (om.groupId !== m.groupId || om.status !== "arrived") continue;
+		if (distanceToEdge(entity.pos, other) - entity.def.radius < .25) return true;
+	}
+	return false;
+}
+/** Seconds a unit has to be held up before the ones in its way are asked to move */
+var MAKE_WAY_AFTER = .2;
+/** How many asked aside in turn, each by the one before held up on its step: the first by the mover, the next by it */
+var ASIDE_DEPTH = 3;
+/** Ticks between two requests by the same unit */
+var MAKE_WAY_INTERVAL = 8;
+/** Ticks between two looks ahead by the same unit, for units standing in its way */
+var LOOK_AHEAD_INTERVAL = 4;
+/** Room a unit keeps between itself and the units it goes round, past touching them */
+var DETOUR_CLEARANCE = .3;
+/**
+* How far past the point beside a knot a unit going round it is sent on, towards its corner, once it is nearly there
+* (`DETOUR_PAST_AT`): an agent slows down as it comes to where it was sent, and this way it is on its way again, at
+* speed, before that
+*/
+var DETOUR_PAST = 1.5;
+var DETOUR_PAST_AT = 1.2;
+/** Under this part of its speed, a unit on its way counts as held up */
+var SLOW_PART = .6;
+/** How far round the point ahead a unit held up a while looks for those standing together in its way */
+var HELD_REACH = 10;
+/** Units standing in a knot past this many are not gone round: the way round them is for the path to find */
+var KNOT_MOST = 24;
+/**
+* As many as a unit held up a while takes in, as it looks again (`tryAgain`): then it goes round however many
+* stand together, however long the way round, where there is one
+*/
+var KNOT_HELD = 160;
+/** The most a knot is grown to on this look: `KNOT_MOST`, or `KNOT_HELD` for a unit held up a while */
+var knotMost = KNOT_MOST;
+/**
+* Whether another unit stands in a mover's way: there, standing still, and on the same crowd, where each steers
+* round the other and neither walks through. What moves is steered round by the navigation; what is a ghost is walked
+* through; what flies or sails goes its own way. What the mover walks to, or stands where it is
+* going, is not in its way either: it stops by it, close enough (a follower by the one it follows, a unit sent where
+* another stands), rather than send it off
+*
+* @beta
+*/
+function standsInWay(world, mover, other) {
+	const om = other.get(moving);
+	if (other === mover || !om || other.hidden || !other.alive) return false;
+	if (om.status === "moving" || om.ghost || om.phased) return false;
+	const m = mover.get(moving);
+	if (m?.phased) return false;
+	if (m && (other.id === m.goalEntity || hypot(other.pos.x - m.navGoal.x, other.pos.z - m.navGoal.z) < m.range + mover.def.radius + other.def.radius)) return false;
+	return world.nav.sameCrowd?.(mover.id, other.id) ?? true;
+}
+/** How far a point is from a segment */
+function segmentDistance(px, pz, ax, az, bx, bz) {
+	const dx = bx - ax;
+	const dz = bz - az;
+	const length = dx * dx + dz * dz;
+	const t = length > 0 ? Math.min(Math.max(((px - ax) * dx + (pz - az) * dz) / length, 0), 1) : 0;
+	return hypot(px - (ax + dx * t), pz - (az + dz * t));
+}
+var probe = {
+	x: 0,
+	z: 0
+};
+/** Whether the navigation has walkable ground at a point: its nearest such point is no further than a hair */
+function walkableAt(nav, x, z) {
+	probe.x = x;
+	probe.z = z;
+	const snapped = nav.closestPoint(probe, 1);
+	return !!snapped && hypot(snapped.x - x, snapped.z - z) <= .3;
+}
+/**
+* Where an ally in a mover's way steps to: aside, off the mover's way, the shorter way out of it first. The way is the
+* leg the mover is on, to its corner, and the leg after (`agent.nx`): a step off the first onto the second, round a
+* building's corner, would be no step at all. Where a side is not to be stood on (a wall), the other; where neither,
+* nowhere
+*/
+function asidePoint(world, mover, other, dx, dz, agent) {
+	const rx = other.pos.x - mover.pos.x;
+	const rz = other.pos.z - mover.pos.z;
+	const clear = mover.def.radius + other.def.radius + .5;
+	const offset = rx * dz - rz * dx;
+	const first = Math.abs(offset) > .05 ? Math.sign(offset) : other.id % 2 ? 1 : -1;
+	const nav = world.navFor(other);
+	const { pos } = mover;
+	let taken = null;
+	const free = other.orders.length === 0;
+	for (let pass = 0; pass < 2; pass++) {
+		const side = pass === 0 ? first : -first;
+		for (let step = clear - Math.abs(offset); step <= clear * 3; step += .5) {
+			const x = other.pos.x + dz * side * step;
+			const z = other.pos.z - dx * side * step;
+			if (segmentDistance(x, z, pos.x, pos.z, agent.cx, agent.cz) < clear - .05) continue;
+			if (segmentDistance(x, z, agent.cx, agent.cz, agent.nx, agent.nz) < clear - .05) continue;
+			if (!walkableAt(nav, x, z)) break;
+			if (free && !roomFor(world, other, mover, x, z)) {
+				taken ??= {
+					x,
+					z
+				};
+				continue;
+			}
+			return {
+				x,
+				z
+			};
+		}
+	}
+	return taken;
+}
+var roomNear = [];
+/** Whether a unit stepping aside has room at a point: nobody else stands there, nor steps aside onto it */
+function roomFor(world, entity, mover, x, z) {
+	world.spatial.query(x, z, entity.def.radius + 1, roomNear);
+	for (const other of roomNear) {
+		if (other === entity || other === mover || other.hidden || other.flying !== entity.flying) continue;
+		const om = other.get(moving);
+		if (!om || om.ghost || om.phased) continue;
+		const room = entity.def.radius + other.def.radius - .05;
+		if (om.status !== "moving" && hypot(other.pos.x - x, other.pos.z - z) < room) return false;
+		if (om.aside && om.status === "moving" && hypot(om.goal.x - x, om.goal.z - z) < room) return false;
+	}
+	return true;
+}
+/**
+* Asks an ally standing in a unit's way to step aside, as the rules allow (`RuleSettings.movement.makesWay`, the `makeWay` hook).
+* `direction` is the way the unit is heading, a unit long; `agent` where its path goes, for the step to be off it.
+* True when it goes
+*
+* @beta
+*/
+function stepAside(world, mover, other, direction, agent) {
+	const om = other.get(moving);
+	if (!om || !world.areAllies(mover.owner, other.owner) || !world.settings.movement.makesWay(world, mover, other)) return false;
+	const m = mover.get(moving);
+	if (m?.groupId && (om.groupId === m.groupId || om.formation === m.groupId)) return false;
+	let point = asidePoint(world, mover, other, direction.x, direction.z, agent);
+	if (world.hooks.has("makeWay")) point = world.hooks.run("makeWay", {
+		mover,
+		other,
+		direction,
+		point
+	}).point;
+	if (!point) return false;
+	moveTo(world, other, point, {
+		facing: om.finalFacing ?? other.facing,
+		aside: true
+	});
+	if (m?.aside) om.asideDepth = (m.asideDepth ?? 1) + 1;
+	return true;
+}
+var neighbours = [];
+var inWay = [];
+var knot = [];
+/**
+* What each of `neighbours` is to the unit looking ahead, by its index: not asked yet, clear, standing in its way, or in
+* the knot. In a blob every member of the knot looks over every neighbour: `standsInWay` asked once each, and a mark
+* rather than `knot.includes`, keep that from being a good part of the tick
+*/
+var standing = /* @__PURE__ */ new Uint8Array(256);
+/**
+* Where each of `neighbours` stands and how wide it is, by its index, read off it once as a knot is grown: the knot
+* goes over the neighbours again for each of its members, and numbers side by side are read faster than each unit's
+* place and type are got at again (nobody moves while the knot is grown)
+*/
+var nearX = /* @__PURE__ */ new Float64Array(256);
+var nearZ = /* @__PURE__ */ new Float64Array(256);
+var nearRadius = /* @__PURE__ */ new Float64Array(256);
+/** The index in `neighbours` of each member of the knot, as it is grown from them */
+var knotAt = /* @__PURE__ */ new Int32Array(256);
+/** Those a member of the knot takes in, by their index in `neighbours`, in order */
+var joined = /* @__PURE__ */ new Int32Array(256);
+/**
+* The neighbours filed by cells a metre wide (`fileNear`): the cell of each, and the indices of those in each cell, in
+* order, from `cellStart[cell]` to `cellStart[cell + 1]`; the corner the cells start from, how many there are across
+* and down, and the widest neighbour
+*/
+var cellItems = /* @__PURE__ */ new Int32Array(256);
+var cellStart = /* @__PURE__ */ new Int32Array(257);
+var cellFill = /* @__PURE__ */ new Int32Array(257);
+var nearCell = /* @__PURE__ */ new Int32Array(256);
+var nearMinX = 0;
+var nearMinZ = 0;
+var nearCols = 0;
+var nearRows = 0;
+var nearWidest = 0;
+/**
+* Files the `count` neighbours (`nearX`, `nearZ`, `nearRadius`) by cells a metre wide, for the knot to find those
+* against each member among a few of them. False, and nothing filed, where it would take more cells than it is worth
+* (a few neighbours far apart), or a place or a radius is no number
+*/
+function fileNear(count) {
+	let minX = Infinity;
+	let minZ = Infinity;
+	let maxX = -Infinity;
+	let maxZ = -Infinity;
+	let widest = 0;
+	let sum = 0;
+	for (let j = 0; j < count; j++) {
+		const x = nearX[j];
+		const z = nearZ[j];
+		sum += x + z + nearRadius[j];
+		if (x < minX) minX = x;
+		if (x > maxX) maxX = x;
+		if (z < minZ) minZ = z;
+		if (z > maxZ) maxZ = z;
+		if (nearRadius[j] > widest) widest = nearRadius[j];
+	}
+	const cols = Math.floor(maxX - minX) + 1;
+	const rows = Math.floor(maxZ - minZ) + 1;
+	const cells = cols * rows;
+	if (Number.isNaN(sum) || !(cells <= count * 4)) return false;
+	if (cellStart.length < cells + 1) {
+		cellStart = new Int32Array((cells + 1) * 2);
+		cellFill = new Int32Array((cells + 1) * 2);
+	}
+	cellStart.fill(0, 0, cells + 1);
+	for (let j = 0; j < count; j++) {
+		const cell = Math.floor(nearZ[j] - minZ) * cols + Math.floor(nearX[j] - minX);
+		nearCell[j] = cell;
+		cellStart[cell + 1]++;
+	}
+	for (let cell = 0; cell < cells; cell++) cellStart[cell + 1] += cellStart[cell];
+	cellFill.set(cellStart.subarray(0, cells));
+	for (let j = 0; j < count; j++) cellItems[cellFill[nearCell[j]]++] = j;
+	nearMinX = minX;
+	nearMinZ = minZ;
+	nearCols = cols;
+	nearRows = rows;
+	nearWidest = widest;
+	return true;
+}
+/**
+* Grows the knot of the unit looking ahead (`lookAhead`) from those in its way (`knot`, `knotAt`): each member in turn
+* takes in the neighbours that stand against it, in their order, until the knot is too big to go round. Those against
+* a member are looked for in the cells round it (`fileNear`), as far as it reaches the widest neighbour: one further
+* off touches it not. Where the neighbours are not filed, among them all
+*/
+function growKnot(world, entity, count) {
+	for (let i = 0; i < count; i++) {
+		const other = neighbours[i];
+		nearX[i] = other.pos.x;
+		nearZ[i] = other.pos.z;
+		nearRadius[i] = other.def.radius;
+	}
+	const filed = fileNear(count);
+	for (let i = 0; i < knot.length && knot.length < knotMost; i++) {
+		const member = knotAt[i];
+		const memberX = nearX[member];
+		const memberZ = nearZ[member];
+		const memberRadius = nearRadius[member];
+		let added = 0;
+		const take = (j) => {
+			const mark = standing[j];
+			if (mark === KNOTTED || mark === CLEAR) return;
+			if (hypot(nearX[j] - memberX, nearZ[j] - memberZ) >= memberRadius + nearRadius[j] + .3) return;
+			if (!standsThere(world, entity, j)) return;
+			standing[j] = KNOTTED;
+			let place = added++;
+			for (; place > 0 && joined[place - 1] > j; place--) joined[place] = joined[place - 1];
+			joined[place] = j;
+		};
+		if (filed) {
+			const touch = memberRadius + nearWidest + .3 + .01;
+			const fromCol = Math.max(Math.floor(memberX - touch - nearMinX), 0);
+			const toCol = Math.min(Math.floor(memberX + touch - nearMinX), nearCols - 1);
+			const fromRow = Math.max(Math.floor(memberZ - touch - nearMinZ), 0);
+			const toRow = Math.min(Math.floor(memberZ + touch - nearMinZ), nearRows - 1);
+			for (let row = fromRow; row <= toRow; row++) for (let k = cellStart[row * nearCols + fromCol], end = cellStart[row * nearCols + toCol + 1]; k < end; k++) take(cellItems[k]);
+		} else for (let j = 0; j < count; j++) take(j);
+		for (let k = 0; k < added; k++) {
+			knotAt[knot.length] = joined[k];
+			knot.push(neighbours[joined[k]]);
+		}
+	}
+}
+var UNASKED = 0;
+var CLEAR = 1;
+var STANDING = 2;
+var KNOTTED = 3;
+var direction = {
+	x: 0,
+	z: 0
+};
+var agent = {
+	x: 0,
+	z: 0,
+	vx: 0,
+	vz: 0,
+	cx: 0,
+	cz: 0,
+	nx: 0,
+	nz: 0
+};
+/**
+* Asks friendly units that are standing around in front of a unit to step aside.
+* Avoidance alone cannot get a unit out of a tight group of idle ones: they would have to move, and nothing tells them to.
+*
+* @beta
+*/
+function makeWay(world, entity) {
+	const m = movementOf(entity);
+	if (!world.nav.readAgent(entity.id, agent)) return;
+	const to = m.detour ?? m.navGoal;
+	let dx = to.x - entity.pos.x;
+	let dz = to.z - entity.pos.z;
+	const length = hypot(dx, dz);
+	if (length < .01) return;
+	dx /= length;
+	dz /= length;
+	direction.x = dx;
+	direction.z = dz;
+	world.spatial.query(entity.pos.x, entity.pos.z, entity.def.radius + 1.5, neighbours);
+	let against;
+	for (const other of neighbours) {
+		const rx = other.pos.x - entity.pos.x;
+		const rz = other.pos.z - entity.pos.z;
+		const reach = entity.def.radius + other.def.radius;
+		const ahead = rx * dx + rz * dz;
+		if (ahead < -.1 || ahead > reach + 1) continue;
+		const offset = rx * dz - rz * dx;
+		if (Math.abs(offset) > reach) continue;
+		against ??= [];
+		against.push(other);
+	}
+	if (!against) return;
+	for (const other of against) if (standsInWay(world, entity, other)) stepAside(world, entity, other, direction, agent);
+}
+/** Whether a unit walking a segment would touch any of the knot */
+function segmentClear(radius, ax, az, bx, bz) {
+	for (const other of knot) if (segmentDistance(other.pos.x, other.pos.z, ax, az, bx, bz) < radius + other.def.radius + .05) return false;
+	return true;
+}
+var wayFrom = {
+	x: 0,
+	z: 0
+};
+var wayTo = {
+	x: 0,
+	z: 0
+};
+/**
+* Whether the way from a point to another is straight, as far as the navigation is concerned: its path is no longer
+* than the line, give or take. A way round a knot that bends round a building is no way round the knot
+*/
+function straightWay(nav, fromX, fromZ, toX, toZ) {
+	const from = wayFrom;
+	const to = wayTo;
+	from.x = fromX;
+	from.z = fromZ;
+	to.x = toX;
+	to.z = toZ;
+	const path = nav.findPath(from, to);
+	if (!path || path.length === 0) return false;
+	let length = dist(from, path[0]);
+	for (let i = 1; i < path.length; i++) length += dist(path[i - 1], path[i]);
+	length += dist(path[path.length - 1], to);
+	return length <= dist(from, to) * 1.05 + .3;
+}
+var standingThere = [];
+/**
+* Whether a unit could stand at a point: walkable there, and nobody standing on it, or stepping aside onto it. Null
+* when it could; otherwise the unit in the way there, or the mover itself for ground it cannot walk
+*/
+function standable(world, nav, entity, x, z) {
+	if (!walkableAt(nav, x, z)) return entity;
+	world.spatial.query(x, z, entity.def.radius + 1, standingThere);
+	for (const other of standingThere) {
+		if (other === entity || !other.get(moving) || other.hidden) continue;
+		const room = entity.def.radius + other.def.radius + .05;
+		if (hypot(other.pos.x - x, other.pos.z - z) < room && standsInWay(world, entity, other)) return other;
+		const om = other.get(moving);
+		if (om.aside && om.status === "moving" && hypot(om.goal.x - x, om.goal.z - z) < room) return other;
+	}
+	return null;
+}
+/** Whether the neighbour at `i` stands in the way of the unit looking ahead: asked of `standsInWay` the first time only */
+function standsThere(world, entity, i) {
+	if (standing[i] === UNASKED) standing[i] = standsInWay(world, entity, neighbours[i]) ? STANDING : CLEAR;
+	return standing[i] !== CLEAR;
+}
+/**
+* Looks ahead of a unit on its way for units standing in it (within `RuleSettings.movement.lookAhead`): a way round the knot
+* they make is taken where it is not much longer (`RuleSettings.movement.goesAround`, the `detour` hook); otherwise those of
+* them that make way (`RuleSettings.movement.makesWay`) are asked to step aside before the unit reaches them. The way round is
+* beside the knot, on the side it sticks out less, at the knot's middle; the unit heads there, and on to its path
+* from there. The number of units sent to this per tick is spread by their ids (`LOOK_AHEAD_INTERVAL`)
+*
+* @beta
+*/
+function lookAhead(world, entity, agent) {
+	lookFurther(world, entity, agent, false);
+}
+/**
+* The look ahead (`lookAhead`); `held` for a unit held up a while (`tryAgain`): it looks a few cells ahead, whatever the
+* rules say, takes in the whole knot, however big, and goes round it however long the way round, where there is one
+*/
+function lookFurther(world, entity, agent, held) {
+	const m = movementOf(entity);
+	const look = held ? Math.max(world.settings.movement.lookAhead(world, entity), 3) : world.settings.movement.lookAhead(world, entity);
+	if (look <= 0) return;
+	knotMost = held ? KNOT_HELD : KNOT_MOST;
+	const { pos } = entity;
+	const radius = entity.def.radius;
+	let dx = agent.cx - pos.x;
+	let dz = agent.cz - pos.z;
+	const toCorner = hypot(dx, dz);
+	if (toCorner < radius) return;
+	dx /= toCorner;
+	dz /= toCorner;
+	const reach = Math.min(toCorner, look);
+	world.spatial.query(pos.x + dx * reach / 2, pos.z + dz * reach / 2, reach / 2 + (held ? HELD_REACH : 3), neighbours);
+	const count = neighbours.length;
+	if (standing.length < count) {
+		standing = new Uint8Array(count * 2);
+		nearX = new Float64Array(count * 2);
+		nearZ = new Float64Array(count * 2);
+		nearRadius = new Float64Array(count * 2);
+		knotAt = new Int32Array(count * 2);
+		joined = new Int32Array(count * 2);
+		nearCell = new Int32Array(count * 2);
+		cellItems = new Int32Array(count * 2);
+	}
+	standing.fill(UNASKED, 0, count);
+	inWay.length = 0;
+	knot.length = 0;
+	for (let i = 0; i < count; i++) {
+		const other = neighbours[i];
+		const rx = other.pos.x - pos.x;
+		const rz = other.pos.z - pos.z;
+		const touch = radius + other.def.radius;
+		const ahead = rx * dx + rz * dz;
+		if (ahead < radius || ahead > reach + touch) continue;
+		const offset = rx * dz - rz * dx;
+		if (Math.abs(offset) > touch - .05) continue;
+		if (!standsThere(world, entity, i)) continue;
+		standing[i] = KNOTTED;
+		knotAt[inWay.length] = i;
+		inWay.push(other);
+	}
+	if (inWay.length === 0) return;
+	for (const other of inWay) knot.push(other);
+	if (knot.length < knotMost) growKnot(world, entity, count);
+	let detour = null;
+	if (knot.length < knotMost) {
+		const nav = world.navFor(entity);
+		let aimX = agent.cx;
+		let aimZ = agent.cz;
+		for (let grown = 0; grown < 4 && !detour; grown++) {
+			let left = -Infinity;
+			let right = Infinity;
+			let along = 0;
+			for (const other of knot) {
+				const rx = other.pos.x - pos.x;
+				const rz = other.pos.z - pos.z;
+				const offset = rx * dz - rz * dx;
+				left = Math.max(left, offset + other.def.radius);
+				right = Math.min(right, offset - other.def.radius);
+				along += rx * dx + rz * dz;
+			}
+			along = Math.max(along / knot.length, radius);
+			const leftFirst = Math.abs(left) <= Math.abs(right);
+			let blocker = null;
+			for (let pass = 0; pass < 2; pass++) {
+				const side = leftFirst === (pass === 0) ? left : right;
+				const out = side > 0 ? 1 : -1;
+				for (let push = 0; push < 3 && !detour; push++) {
+					const offset = side + out * (radius + DETOUR_CLEARANCE + push * .5);
+					const x = pos.x + dx * along + dz * offset;
+					const z = pos.z + dz * along - dx * offset;
+					const there = standable(world, nav, entity, x, z);
+					if (there) {
+						if (there !== entity && !knot.includes(there)) blocker ??= there;
+						continue;
+					}
+					if (!segmentClear(radius, pos.x, pos.z, x, z) || !straightWay(nav, pos.x, pos.z, x, z)) continue;
+					if (segmentClear(radius, x, z, agent.cx, agent.cz) && straightWay(nav, x, z, agent.cx, agent.cz)) {
+						aimX = agent.cx;
+						aimZ = agent.cz;
+					} else if ((agent.nx !== agent.cx || agent.nz !== agent.cz) && segmentClear(radius, x, z, agent.nx, agent.nz) && straightWay(nav, x, z, agent.nx, agent.nz)) {
+						aimX = agent.nx;
+						aimZ = agent.nz;
+					} else continue;
+					detour = {
+						x,
+						z
+					};
+				}
+				if (detour) break;
+			}
+			if (!detour && blocker && knot.length < knotMost) knot.push(blocker);
+			else if (!detour) break;
+		}
+		if (detour) {
+			const straight = aimX === agent.cx && aimZ === agent.cz ? toCorner : toCorner + hypot(agent.nx - agent.cx, agent.nz - agent.cz);
+			const longer = hypot(detour.x - pos.x, detour.z - pos.z) + hypot(aimX - detour.x, aimZ - detour.z) - straight;
+			const around = [...knot];
+			if (!held && !world.settings.movement.goesAround(world, entity, around, longer, straight)) detour = null;
+			if (world.hooks.has("detour")) detour = world.hooks.run("detour", {
+				entity,
+				around,
+				straight,
+				longer,
+				point: detour
+			}).point;
+			if (detour) {
+				m.detour = detour;
+				m.detourAim = {
+					x: aimX,
+					z: aimZ
+				};
+				m.detourPast = false;
+				world.nav.setDestination(entity.id, detour);
+				return;
+			}
+		}
+	}
+	direction.x = dx;
+	direction.z = dz;
+	for (const other of [...inWay]) stepAside(world, entity, other, direction, agent);
+}
+/**
+* Over how many ticks the chasers look for new paths after the navigation changed: an eighth of them each tick
+*
+* @beta
+*/
+var REPATH_SPREAD = 8;
+/** Keeps chasers pointed at targets that moved, and lets go of the ones gone out of reach */
+function followTargets(world) {
+	const { nav } = world;
+	for (const entity of world.index.with(moving)) {
+		const m = entity.get(moving);
+		if (!m || m.status !== "moving" || !m.goalEntity) continue;
+		const target = world.get(m.goalEntity);
+		if (!target || target.hidden) {
+			nav.clearDestination(entity.id);
+			m.status = "failed";
+			continue;
+		}
+		const point = approachPoint(world, entity, target);
+		const stale = m.navVersion !== nav.version && (entity.id + world.tick) % 8 === 0;
+		if (dist(point, m.navGoal) > .75 || stale) beginMove(world, entity, point);
+	}
+}
+/** Where the navigation moved each unit to, read back into the world: and from there, how each is getting on */
+function readAgents(world, dt) {
+	for (const entity of world.index.with(moving)) {
+		const m = entity.get(moving);
+		if (!m || !entity.alive || entity.hidden) continue;
+		if (!world.nav.readAgent(entity.id, agent)) continue;
+		moveAlong(world, entity, m, dt);
+	}
+}
+/** A unit the navigation moved (`agent`, just read): where it is, which way it faces, and how it is getting on */
+function moveAlong(world, entity, m, dt) {
+	entity.moveTo(agent.x, agent.z);
+	entity.velocity.x = agent.vx;
+	entity.velocity.z = agent.vz;
+	if (m.status !== "moving") {
+		if (m.place) backToPlace(world, entity, m, dt);
+		return lineUp(world, entity, m, dt);
+	}
+	if (agent.vx * agent.vx + agent.vz * agent.vz > .2) {
+		const desired = atan2(agent.vx, agent.vz);
+		entity.facing = rotateTowards(entity.facing, desired, turnRateOf(world, entity) * dt);
+	}
+	const distance = distanceLeft(world, entity, m);
+	if (distance === void 0) return;
+	if (distance <= m.range) return arrive(world, entity);
+	steerAround(world, entity, m);
+	followRoute(world, entity, m);
+	watchProgress(world, entity, m, distance, dt);
+}
+/** How far off its place in a formation a unit that stands there goes back to it */
+var PLACE_OFF = .35;
+/** Seconds it stands off its place before it goes back: the one it stepped aside for gone by */
+var PLACE_WAIT = .75;
+/** How many times it goes back to its place without getting there before it lets it go: jostling for ever is no good */
+var BACK_TRIES = 5;
+/**
+* A unit of a formation standing off its place (stepped aside for another, or pushed off it) walks back to it once it
+* has stood off it a while (`PLACE_WAIT`), as one of the formation: it swaps, passes on and trades places on the way,
+* and makes its own room by it (`nudge`), but does not try again: held up `HELD_UP` near it, it stops, its place kept.
+* Where another of the formation stands there, off its own, that one keeps this place and this one goes to the
+* other's; where one stands at its own there it waits. After a few walks back (`BACK_TRIES`) without getting there
+* it lets the place go, and stays where it is
+*/
+function backToPlace(world, entity, m, dt) {
+	const place = m.place;
+	if (m.anchored || entity.orders.length > 0 || dist(entity.pos, place) <= PLACE_OFF) return;
+	m.stalledTime += dt;
+	if (m.stalledTime < PLACE_WAIT || (world.tick + entity.id) % LOOK_AHEAD_INTERVAL !== 0) return;
+	m.stalledTime = 0;
+	const tries = (m.backTries ?? 0) + 1;
+	if (tries > BACK_TRIES) return leavePlace(m);
+	const theirs = m.formation !== void 0 ? takeOver(world, entity, place, m.formation) : void 0;
+	if (theirs) m.place = theirs;
+	const to = m.place;
+	if (theirs || !standingOn(world, entity, to)) {
+		if (m.formation !== void 0) toPlace(world, entity, to, m.formation, m.finalFacing ?? entity.facing);
+		else moveTo(world, entity, to, {
+			facing: m.finalFacing ?? entity.facing,
+			aside: true
+		});
+		m.place = to;
+	}
+	if (theirs) delete m.backTries;
+	else m.backTries = tries;
+	if (m.status === "moving") m.asideDepth = ASIDE_DEPTH;
+}
+/** Groups bump into each other on arrival and end up looking anywhere: a unit that stopped turns to face the way it was told */
+function lineUp(world, entity, m, dt) {
+	if (m.finalFacing === null) return;
+	entity.facing = rotateTowards(entity.facing, m.finalFacing, turnRateOf(world, entity) * dt);
+	if (entity.facing === m.finalFacing) m.finalFacing = null;
+}
+/** How far a unit on its way has still to go: to the edge of what it goes to, or to its point. None for a target gone */
+function distanceLeft(world, entity, m) {
+	if (!m.goalEntity) return dist(entity.pos, m.goal);
+	const target = world.get(m.goalEntity);
+	return target ? edgeDistance(entity, target) : void 0;
+}
+/**
+* Round a knot of standing units: sent on past the point beside them as it nears it, and back on its way once it is
+* past that point, or held up there
+*/
+function steerAround(world, entity, m) {
+	if (!m.detour) return;
+	const near = dist(entity.pos, m.detour);
+	const aim = m.detourAim ?? m.navGoal;
+	const passed = (entity.pos.x - m.detour.x) * (aim.x - m.detour.x) + (entity.pos.z - m.detour.z) * (aim.z - m.detour.z) > 0;
+	if (m.detourPast && passed || near <= .5 || m.stalledTime > .5 || (m.slowTime ?? 0) > .3) {
+		m.detour = void 0;
+		walk(world, entity);
+	} else if (!m.detourPast && near <= DETOUR_PAST_AT) {
+		m.detourPast = true;
+		const to = m.detourAim ?? m.stretch ?? m.navGoal;
+		let px = to.x - m.detour.x;
+		let pz = to.z - m.detour.z;
+		const past = hypot(px, pz);
+		if (past > DETOUR_PAST) {
+			px *= DETOUR_PAST / past;
+			pz *= DETOUR_PAST / past;
+		}
+		world.nav.setDestination(entity.id, {
+			x: m.detour.x + px,
+			z: m.detour.z + pz
+		});
+	}
+}
+/**
+* On a route its side planned: planned again once the side knows more (a few units a tick, by their ids), and sent on
+* a stretch further once halfway along the one it is on
+*/
+function followRoute(world, entity, m) {
+	if (m.detour || !(m.route || m.routeVersion !== void 0)) return;
+	const team = sideOf(world, entity);
+	let again = false;
+	if (team !== void 0 && m.routeVersion !== world.sidePaths.version(team) && (entity.id + world.tick) % 8 === 0) {
+		planRoute(world, entity, team);
+		again = true;
+	}
+	if (again || m.stretch && dist(entity.pos, m.stretch) < stretchOf(entity) / 2) {
+		const next = m.route ? stretchPoint(entity) : m.navGoal;
+		if (again || !m.stretch || dist(next, m.stretch) > .5) walk(world, entity);
+	}
+}
+/**
+* Whether a unit on its way gets anywhere: held up by others (asked aside, gone round), stalled (arrived where close is
+* good enough, or given up after a while)
+*/
+function watchProgress(world, entity, m, distance, dt) {
+	const progress = hypot(entity.pos.x - agent.cx, entity.pos.z - agent.cz);
+	if (agent.cx !== m.corner.x || agent.cz !== m.corner.z) {
+		m.corner.x = agent.cx;
+		m.corner.z = agent.cz;
+		m.bestDistance = progress;
+	}
+	m.slowTime = m.speed > 0 && hypot(agent.vx, agent.vz) < m.speed * SLOW_PART && distance > m.range + entity.def.radius * 2 + .3 && m.bestDistance < Infinity ? (m.slowTime ?? 0) + dt : 0;
+	if (!m.detour && !m.aside && (world.tick + entity.id) % LOOK_AHEAD_INTERVAL === 0) lookAhead(world, entity, agent);
+	if (progress < m.bestDistance - .1) {
+		m.bestDistance = progress;
+		m.stalledTime = 0;
+		if (m.tries && distance < (m.triedAt ?? Infinity) - TRIED_FAR) {
+			delete m.tries;
+			delete m.triedAt;
+		}
+		if (!m.aside && (m.slowTime ?? 0) > MAKE_WAY_AFTER && (world.tick + entity.id) % MAKE_WAY_INTERVAL === 0) makeWay(world, entity);
+		return;
+	}
+	m.stalledTime += dt;
+	if ((!m.aside || (m.asideDepth ?? 1) < ASIDE_DEPTH) && m.stalledTime > MAKE_WAY_AFTER && (world.tick + entity.id) % MAKE_WAY_INTERVAL === 0) makeWay(world, entity);
+	if (!m.goalEntity) {
+		const formed = m.groupId && m.formation === m.groupId && !m.aside;
+		if (formed && m.stalledTime > .25 && distance < m.range + 4 && swapPlaces(world, entity, m)) return;
+		if (formed && m.stalledTime > .25 && (world.tick + entity.id) % LOOK_AHEAD_INTERVAL === 0 && passOn(world, entity, m)) return;
+		if (formed && m.stalledTime > .25 && (world.tick + entity.id) % LOOK_AHEAD_INTERVAL === 0 && tradeGoals(world, entity, m)) return;
+		if (formed && m.stalledTime > MAKE_WAY_AFTER && distance < NUDGE_NEAR && (world.tick + entity.id) % MAKE_WAY_INTERVAL === 0) {
+			nudge(world, entity, m);
+			clearPlace(world, entity, m);
+		}
+		const taken = m.aside || m.stalledTime > .25 && distance < m.range + 4 && goalTaken(world, entity, m);
+		if (taken && m.stalledTime > .25 && distance < m.range + 4 && blockedByArrivedGroupMate(world, entity)) arrive(world, entity);
+		else if (taken && m.stalledTime > .6 && distance < 1.25) arrive(world, entity);
+	}
+	if (m.status === "moving" && m.stalledTime > HELD_UP) {
+		if (!m.goalEntity && distance < 3 && (m.aside || m.place || goalTaken(world, entity, m))) arrive(world, entity);
+		else if (!m.aside && (m.tries ?? 0) < TRIES && !wayEndsShort(entity, m) && heldByUnits(world, entity)) tryAgain(world, entity, m, distance);
+		else if (!m.goalEntity && distance < 3) arrive(world, entity);
+		else {
+			world.nav.clearDestination(entity.id);
+			m.status = "failed";
+			m.stuck = true;
+		}
+	}
+}
+/** Seconds a unit on its way gets nowhere before it tries again (`tryAgain`), or, out of tries, gives up */
+var HELD_UP = 3;
+/** How many times a unit held up tries again before it gives up: 4, after 15 seconds held up in all */
+var TRIES = 4;
+/** How much nearer a unit that tried again has to get to have its tries again */
+var TRIED_FAR = 2;
+/**
+* Whether another unit stands where a unit on its way is going: then near is as good as there, rather than push it
+* off (a group sent to one point, a unit sent where another stands)
+*/
+function goalTaken(world, entity, m) {
+	return !!standingOn(world, entity, m.goal, true);
+}
+/**
+* The unit standing on a point, where another would stand, the nearest it: none where nobody does. `sameGoal` counts
+* one on its way to that very point, there already, as standing there: several sent to one point
+*/
+function standingOn(world, entity, point, sameGoal = false) {
+	world.spatial.query(point.x, point.z, entity.def.radius + 1, roomNear);
+	let nearest;
+	let best = Infinity;
+	for (const other of roomNear) {
+		if (other === entity || other.hidden || other.flying !== entity.flying || !other.get(moving)) continue;
+		const om = other.get(moving);
+		const room = entity.def.radius + other.def.radius;
+		if (om.status === "moving" && !(sameGoal && hypot(om.goal.x - point.x, om.goal.z - point.z) < room)) continue;
+		const d = hypot(other.pos.x - point.x, other.pos.z - point.z);
+		if (d < room && d < best) {
+			best = d;
+			nearest = other;
+		}
+	}
+	return nearest;
+}
+/**
+* A unit of a formation held up near its place, with another of the formation standing on it, off its own (it stopped
+* short of it, or stepped aside onto this one): they swap. The one standing there has its place where it stands, and
+* this one goes to the other's. The formation is whole all the same, and neither pushes the other. Only those of a
+* type: a formation that places each by who it is (`FormationDef.points`) keeps them so. True when they do
+*/
+function swapPlaces(world, entity, m) {
+	const theirs = takeOver(world, entity, m.goal, m.groupId);
+	if (!theirs) return false;
+	toPlace(world, entity, theirs, m.groupId, m.finalFacing);
+	return true;
+}
+/**
+* The one of formation `group` standing on a place, off its own, given that place where it stands, as `swapPlaces`
+* has it: its own place, which is the other one's now, or none where nobody such stands there
+*/
+function takeOver(world, entity, place, group) {
+	const other = standingOn(world, entity, place);
+	const om = other?.get(moving);
+	if (!other || !om?.place || om.formation !== group || other.def.id !== entity.def.id || other.orders.length > 0) return;
+	if (dist(other.pos, om.place) <= PLACE_OFF || dist(om.place, place) <= PLACE_OFF) return;
+	const theirs = om.place;
+	om.place = {
+		x: place.x,
+		z: place.z
+	};
+	delete om.backTries;
+	return theirs;
+}
+/** How near its place one of a formation is for those of it it touches, ahead, to make it room (`nudge`) */
+var NUDGE_NEAR = 1.5;
+/** How far they step to make room, from where they stand: back to their places after (`backToPlace`) */
+var NUDGE = .4;
+/**
+* One of a formation held up right by its place, those of it at theirs touching it on the way there: they step a
+* little away from it to make it room, as a crowd parts, and go back to their places once it is in its own. The last
+* of a ring to come finds the gap left for it narrowed by those either side, each stopped up to `ARRIVE_RANGE` short
+*/
+function nudge(world, entity, m) {
+	const dx = m.goal.x - entity.pos.x;
+	const dz = m.goal.z - entity.pos.z;
+	world.spatial.query(entity.pos.x, entity.pos.z, entity.def.radius + 1.5, roomNear);
+	const near = [...roomNear];
+	for (const other of near) {
+		const om = other.get(moving);
+		if (other === entity || !om?.place || om.formation !== m.groupId || om.status === "moving" || other.orders.length > 0 || om.anchored) continue;
+		const rx = other.pos.x - entity.pos.x;
+		const rz = other.pos.z - entity.pos.z;
+		const apart = hypot(rx, rz);
+		if (rx * dx + rz * dz <= 0 || apart - entity.def.radius - other.def.radius > .25 || apart < .01) continue;
+		const x = other.pos.x + rx / apart * NUDGE;
+		const z = other.pos.z + rz / apart * NUDGE;
+		if (!walkableAt(world.navFor(other), x, z)) continue;
+		moveTo(world, other, {
+			x,
+			z
+		}, {
+			facing: om.finalFacing ?? other.facing,
+			aside: true
+		});
+		om.asideDepth = ASIDE_DEPTH;
+	}
+}
+/**
+* One of a formation held up by its place, an ally of none of it standing there: asked aside, as the rules have it
+* (`stepAside`). A formation is laid out where it is sent, whoever stood there
+*/
+function clearPlace(world, entity, m) {
+	const other = standingOn(world, entity, m.goal);
+	if (!other || other.get(moving).formation === m.groupId) return;
+	const dx = m.goal.x - entity.pos.x;
+	const dz = m.goal.z - entity.pos.z;
+	const length = hypot(dx, dz);
+	if (length < .01 || !world.nav.readAgent(entity.id, agent)) return;
+	direction.x = dx / length;
+	direction.z = dz / length;
+	stepAside(world, entity, other, direction, agent);
+}
+/** Sends one of a formation to a place in it, as its order did: it keeps the place once there */
+function toPlace(world, entity, place, groupId, facing) {
+	moveTo(world, entity, place, {
+		groupId,
+		facing: facing ?? void 0
+	});
+	movementOf(entity).formation = groupId;
+}
+/** How much nearer its place the one standing in the way is than the one held up, for it to be passed on (`passOn`) */
+var PASS_NEARER = .25;
+/**
+* A unit of a formation held up by another of it standing at its place, on the way to its own further in: the one
+* standing goes on to that place, nearer it, and this one takes the one it leaves, right by it. The places of a ring
+* deep in the formation are filled through those already standing, a step at a time, rather than each pushing through
+* those that came first. Each pass has the one going on to the place nearer it (`PASS_NEARER`), so that it comes to an
+* end. Only to one of its type, as `swapPlaces`. True when it is passed on
+*/
+function passOn(world, entity, m) {
+	const left = dist(entity.pos, m.goal);
+	world.spatial.query(entity.pos.x, entity.pos.z, entity.def.radius + 1.5, roomNear);
+	let best;
+	let nearest = left - PASS_NEARER;
+	for (const other of roomNear) {
+		const om = other.get(moving);
+		if (other === entity || !om?.place || om.formation !== m.groupId || other.def.id !== entity.def.id || om.status === "moving" || other.orders.length > 0 || om.anchored) continue;
+		if (distanceToEdge(entity.pos, other) - entity.def.radius > .35 || dist(other.pos, om.place) > PLACE_OFF) continue;
+		if (dist(entity.pos, om.place) > entity.def.radius + other.def.radius + .6) continue;
+		const d = dist(other.pos, m.goal);
+		if (d < nearest) {
+			nearest = d;
+			best = other;
+		}
+	}
+	if (!best) return false;
+	const theirs = best.get(moving).place;
+	toPlace(world, best, {
+		x: m.goal.x,
+		z: m.goal.z
+	}, m.groupId, m.finalFacing);
+	toPlace(world, entity, theirs, m.groupId, m.finalFacing);
+	return true;
+}
+/** How much shorter the two ways together are for two of a formation to trade places on the way (`tradeGoals`) */
+var TRADE_SHORTER = .5;
+/**
+* Two of a formation on their way, holding each other up, each nearer the other's place than its own (they meet head
+* on, or cross): they trade places, when the two ways together are shorter by `TRADE_SHORTER`, rather than each push
+* round the other. Only with one of its type that does nothing but walk to its place, as `swapPlaces`. True when they do
+*/
+function tradeGoals(world, entity, m) {
+	const mine = dist(entity.pos, m.goal);
+	world.spatial.query(entity.pos.x, entity.pos.z, entity.def.radius + 1.5, roomNear);
+	let best;
+	let most = TRADE_SHORTER;
+	for (const other of roomNear) {
+		const om = other.get(moving);
+		if (other === entity || !om || om.status !== "moving" || om.aside || om.goalEntity || om.groupId !== m.groupId || om.formation !== m.groupId || other.def.id !== entity.def.id || other.orders.length > 1 || other.orders.length === 1 && other.orders[0].type !== "move" || distanceToEdge(entity.pos, other) - entity.def.radius > .35) continue;
+		const shorter = mine + dist(other.pos, om.goal) - dist(entity.pos, om.goal) - dist(other.pos, m.goal);
+		if (shorter > most) {
+			most = shorter;
+			best = other;
+		}
+	}
+	if (!best) return false;
+	const goal = best.get(moving).goal;
+	const theirs = {
+		x: goal.x,
+		z: goal.z
+	};
+	toPlace(world, best, {
+		x: m.goal.x,
+		z: m.goal.z
+	}, m.groupId, m.finalFacing);
+	toPlace(world, entity, theirs, m.groupId, m.finalFacing);
+	return true;
+}
+/**
+* Whether the unit stands at the end of its path, and that end is short of where it goes: the navigation knows no way
+* further (across a wood, up a cliff). Then trying again is no good
+*/
+function wayEndsShort(entity, m) {
+	const to = m.stretch ?? m.navGoal;
+	return hypot(entity.pos.x - agent.cx, entity.pos.z - agent.cz) < entity.def.radius + .5 && hypot(agent.cx - to.x, agent.cz - to.z) > .5;
+}
+/**
+* Whether others that may yet go are what hold a unit up: one against it that is not anchored (an ally that makes way,
+* one on its way, an enemy that moves on). Not the ground, a wood, nor those holding their ground: trying again is no
+* good against them
+*/
+function heldByUnits(world, entity) {
+	world.spatial.query(entity.pos.x, entity.pos.z, entity.def.radius + 1.5, roomNear);
+	for (const other of roomNear) {
+		const om = other.get(moving);
+		if (other === entity || !om || om.anchored || om.ghost || om.phased || other.hidden || !other.alive || other.flying !== entity.flying) continue;
+		if (distanceToEdge(entity.pos, other) - entity.def.radius < .6) return true;
+	}
+	return false;
+}
+/**
+* A unit held up on its way (`HELD_UP`), where its goal is not taken, tries again rather than give up: it is sent on
+* its way anew, looks round the whole knot it is held up by for a way round, however long, and asks those of it that
+* make way aside. Out of tries (`TRIES`) it gives up: a crowd of others, or enemies, that will not let it through
+*/
+function tryAgain(world, entity, m, distance) {
+	m.tries = (m.tries ?? 0) + 1;
+	m.triedAt = distance;
+	m.stalledTime = 0;
+	m.slowTime = 0;
+	m.detour = void 0;
+	walk(world, entity);
+	if (!world.nav.readAgent(entity.id, agent)) return;
+	m.corner.x = agent.cx;
+	m.corner.z = agent.cz;
+	m.bestDistance = hypot(entity.pos.x - agent.cx, entity.pos.z - agent.cz);
+	lookFurther(world, entity, agent, true);
+	if (!m.detour) makeWay(world, entity);
+}
+var movementSystem = {
+	name: "movement",
+	phase: "move",
+	update(world, dt) {
+		seeToPhasing(world);
+		followTargets(world);
+		world.nav.update(dt);
+		readAgents(world, dt);
+	}
+};
+//#endregion
+export { ARRIVE_RANGE, REPATH_SPREAD, approachPoint, faceTowards, halt, isMovingTo, joinFormation, lookAhead, makeWay, moveTo, moveToEntity, movementSystem, setAnchored, setGhost, standsInWay, stepAside, walkOn };
+
+//# sourceMappingURL=movement.js.map