@v12-engine/engine 0.1.1 → 0.4.0

package/dist/navigation/sized.js

@@ -0,0 +1,243 @@
+//#region src/navigation/sized.ts
+/**
+* The ground cut for units of several sizes (S38): a navigation for each, an agent on the one for the biggest size it
+* is not smaller than, so a big unit keeps from walls as far as it needs and a small one still fits through a gap.
+* What is not about an agent (obstacles, where one can stand, a path asked for) goes to each, or to the smallest.
+* Each size has its own crowd (Detour's crowd walks one navmesh), and each agent also stands as a mirror in the crowds
+* of the others (`AgentMirrors`), so that units of different sizes steer round, push and are pushed by each other as
+* on one navigation. The crowds step from the smallest up, each told where the last left its units: the small unit
+* gives way to the big one, and what is left of an overlap is the big one's, so it is not made good twice
+*
+* @internal
+*/
+var SizedNavigation = class {
+	sizes;
+	sizeOf = /* @__PURE__ */ new Map();
+	/** The ids on each size, for telling the others where they went */
+	members;
+	motion = {
+		x: 0,
+		y: 0,
+		z: 0,
+		vx: 0,
+		vz: 0
+	};
+	/**
+	* `sizes` from the smallest up, each with the radius it was cut for, and the radius of the biggest unit it takes
+	* (`upTo`) where that is not the next size's own
+	*/
+	constructor(sizes) {
+		this.sizes = sizes;
+		if (!sizes.length) throw new Error("Navigation: no sizes to cut the ground for");
+		this.members = sizes.map(() => /* @__PURE__ */ new Set());
+	}
+	/** The walkable-space version of the smallest size's navigation, bumped when obstacles are added or removed */
+	get version() {
+		return this.sizes[0].navigation.version;
+	}
+	/**
+	* The size an agent of a radius goes on: the first that takes it (`upTo`), or the biggest it is not smaller than,
+	* the smallest for one smaller than all
+	*/
+	sizeFor(radius) {
+		if (this.sizes.every((size) => size.upTo !== void 0)) {
+			const taken = this.sizes.findIndex((size) => radius <= size.upTo);
+			return taken < 0 ? this.sizes.length - 1 : taken;
+		}
+		let chosen = 0;
+		this.sizes.forEach((size, i) => {
+			if (radius >= size.radius) chosen = i;
+		});
+		return chosen;
+	}
+	of(id) {
+		return this.sizes[this.sizeOf.get(id) ?? 0].navigation;
+	}
+	/** Puts an agent on the size its `params.radius` picks, and adds a mirror of it to every other size's crowd */
+	addAgent(id, position, params) {
+		this.removeAgent(id);
+		this.enrol(id, params.radius);
+		this.of(id).addAgent(id, position, params);
+		this.addMirrors(id, params.radius, false);
+	}
+	enrol(id, radius) {
+		const size = this.sizeFor(radius);
+		this.sizeOf.set(id, size);
+		this.members[size].add(id);
+	}
+	/** An agent's mirror put in the crowd of every other size: out of everyone's way there while it phases */
+	addMirrors(id, radius, ghost, phasing = false) {
+		const own = this.sizeOf.get(id);
+		if (!this.sizes[own].navigation.readMotion(id, this.motion)) return;
+		this.sizes.forEach(({ navigation }, i) => {
+			if (i === own) return;
+			navigation.addMirror(id, this.motion, radius, ghost);
+			if (phasing) navigation.setMirrorPhasing?.(id, true);
+		});
+	}
+	/** Every other size told where an agent is now */
+	tellOthers(id, own) {
+		if (!this.sizes[own].navigation.readMotion(id, this.motion)) return;
+		for (let i = 0; i < this.sizes.length; i++) if (i !== own) this.sizes[i].navigation.moveMirror(id, this.motion);
+	}
+	/** Takes an agent out of its own size's crowd and its mirror out of every other size's; does nothing for an unknown id */
+	removeAgent(id) {
+		const own = this.sizeOf.get(id);
+		if (own === void 0) return;
+		this.sizes.forEach(({ navigation }, i) => {
+			if (i === own) navigation.removeAgent(id);
+			else navigation.removeMirror(id);
+		});
+		this.members[own].delete(id);
+		this.sizeOf.delete(id);
+	}
+	/** Whether an agent of this id is enrolled on a size and present in that size's navigation */
+	hasAgent(id) {
+		return this.sizeOf.has(id) && this.of(id).hasAgent(id);
+	}
+	/** Asks the agent's own size for a path towards `target`; false when nothing walkable is near it */
+	setDestination(id, target) {
+		return this.of(id).setDestination(id, target);
+	}
+	/** Stops the agent's walk on its own size's navigation */
+	clearDestination(id) {
+		this.of(id).clearDestination(id);
+	}
+	/** Moves the agent to `position` on its own size and tells the other sizes' mirrors where it now is */
+	teleport(id, position) {
+		this.of(id).teleport(id, position);
+		const own = this.sizeOf.get(id);
+		if (own !== void 0) this.tellOthers(id, own);
+	}
+	/** Sets whether the agent holds its ground on its own size, and updates its mirrors in the other sizes */
+	setAnchored(id, anchored) {
+		this.of(id).setAnchored(id, anchored);
+		const own = this.sizeOf.get(id);
+		if (own !== void 0) this.tellOthers(id, own);
+	}
+	/** Sets whether the agent ignores other agents, on its own size and on its mirrors in the other sizes */
+	setGhost(id, ghost) {
+		this.of(id).setGhost(id, ghost);
+		const own = this.sizeOf.get(id);
+		this.sizes.forEach(({ navigation }, i) => {
+			if (i !== own) navigation.setMirrorGhost(id, ghost);
+		});
+	}
+	/** Has the agent walk through every other on its own size, and its mirrors out of everyone's way on the others */
+	setPhasing(id, phasing) {
+		const own = this.sizeOf.get(id);
+		if (own === void 0) return;
+		const navigation = this.of(id);
+		if (navigation.setPhasing) navigation.setPhasing(id, phasing);
+		else navigation.setGhost(id, phasing);
+		this.sizes.forEach((size, i) => {
+			if (i !== own) size.navigation.setMirrorPhasing?.(id, phasing);
+		});
+	}
+	/** Sets the agent's top speed on its own size's navigation */
+	setSpeed(id, speed) {
+		this.of(id).setSpeed(id, speed);
+	}
+	/** Reads the agent's state from its own size into `out`; false when the agent is unknown */
+	readAgent(id, out) {
+		return this.sizeOf.has(id) && this.of(id).readAgent(id, out);
+	}
+	/** What a save needs of the agent from its own size, or undefined when there is none of that id */
+	saveAgent(id) {
+		return this.sizeOf.has(id) ? this.of(id).saveAgent(id) : void 0;
+	}
+	/** Puts an agent back from its save on the size its saved radius picks, with its mirrors in the other sizes */
+	restoreAgent(id, save) {
+		this.removeAgent(id);
+		this.enrol(id, save.radius);
+		this.of(id).restoreAgent(id, save);
+		this.addMirrors(id, save.radius, save.ghost, !!save.phasing);
+	}
+	/** Puts the given agents back as a load does, each size anew in the save's order, then all the mirrors in that order */
+	reseat(agents) {
+		this.sizeOf.clear();
+		for (const members of this.members) members.clear();
+		for (const [id, save] of agents) this.enrol(id, save.radius);
+		this.sizes.forEach((size, i) => size.navigation.reseat(agents.filter(([id]) => this.sizeOf.get(id) === i)));
+		for (const [id, save] of agents) this.addMirrors(id, save.radius, save.ghost, !!save.phasing);
+	}
+	/** After a load: settles every size's navigation at `version`, then tells each size where the others' agents are */
+	settle(version) {
+		for (const size of this.sizes) size.navigation.settle(version);
+		this.tellAll();
+	}
+	tellAll() {
+		for (const [id, own] of this.sizeOf) this.tellOthers(id, own);
+	}
+	/** Slow ground weighed again on each size's navigation, where a slowing layer changed */
+	groundChanged(cells, walkability) {
+		for (const size of this.sizes) size.navigation.groundChanged?.(cells, walkability);
+	}
+	/** Each size's navigation cut again of the ground as it is now */
+	reshape(area) {
+		let any = false;
+		for (const size of this.sizes) any = !!size.navigation.reshape?.(area) || any;
+		return any;
+	}
+	/** What the ground's changes asked of each size's navigation done now */
+	settleGround() {
+		for (const size of this.sizes) size.navigation.settleGround?.();
+	}
+	/** Steps each size's crowd from the smallest up, telling the other sizes where its agents went after each step */
+	update(dt) {
+		for (let i = 0; i < this.sizes.length; i++) {
+			this.sizes[i].navigation.update(dt);
+			if (this.sizes.length > 1) for (const id of this.members[i]) this.tellOthers(id, i);
+		}
+	}
+	/** Adds the obstacle to every size; false, with the sizes already done taken back, when any size has no room for it */
+	addObstacle(key, rect) {
+		const added = [];
+		for (const { navigation } of this.sizes) {
+			if (!navigation.addObstacle(key, rect)) {
+				for (const done of added) done.removeObstacle(key);
+				return false;
+			}
+			added.push(navigation);
+		}
+		return true;
+	}
+	/** Removes the obstacle `key` from every size's navigation */
+	removeObstacle(key) {
+		for (const size of this.sizes) size.navigation.removeObstacle(key);
+	}
+	/** Holds back (true) or applies (false) obstacle changes on every size that supports it */
+	holdObstacles(hold) {
+		for (const size of this.sizes) size.navigation.holdObstacles?.(hold);
+	}
+	/** How many more obstacles fit: the smallest room among the sizes */
+	obstacleRoom() {
+		return Math.min(...this.sizes.map((size) => size.navigation.obstacleRoom()));
+	}
+	/** Whether two agents are both enrolled; true for any two since different sizes see each other as mirrors */
+	sameCrowd(a, b) {
+		return this.sizeOf.has(a) && this.sizeOf.has(b);
+	}
+	/** The closest walkable point to `point` on the smallest size, or null when none is within `searchRadius` */
+	closestPoint(point, searchRadius) {
+		return this.sizes[0].navigation.closestPoint(point, searchRadius);
+	}
+	/** A path from `from` to `to` on the smallest size's navigation, or null when there is none */
+	findPath(from, to) {
+		return this.sizes[0].navigation.findPath(from, to);
+	}
+	/** The smallest size's navigation geometry for the debug overlay */
+	debugGeometry() {
+		return this.sizes[0].navigation.debugGeometry();
+	}
+	/** Disposes every size's navigation and forgets which agents are on which size */
+	dispose() {
+		for (const size of this.sizes) size.navigation.dispose();
+		this.sizeOf.clear();
+		for (const members of this.members) members.clear();
+	}
+};
+//#endregion
+export { SizedNavigation };
+
+//# sourceMappingURL=sized.js.map

package/dist/navigation/sized.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sized.js","names":[],"sources":["../../src/navigation/sized.ts"],"sourcesContent":["import type { Rect, Vec2 } from '#engine/math'\nimport type { AgentMirrors, AgentMotion, AgentParams, AgentSave, AgentState, CellArea, NavDebugGeometry, Navigation } from './navigation'\n\n/**\n * The ground cut for units of several sizes (S38): a navigation for each, an agent on the one for the biggest size it\n * is not smaller than, so a big unit keeps from walls as far as it needs and a small one still fits through a gap.\n * What is not about an agent (obstacles, where one can stand, a path asked for) goes to each, or to the smallest.\n * Each size has its own crowd (Detour's crowd walks one navmesh), and each agent also stands as a mirror in the crowds\n * of the others (`AgentMirrors`), so that units of different sizes steer round, push and are pushed by each other as\n * on one navigation. The crowds step from the smallest up, each told where the last left its units: the small unit\n * gives way to the big one, and what is left of an overlap is the big one's, so it is not made good twice\n *\n * @internal\n */\nexport class SizedNavigation implements Navigation {\n\tprivate readonly sizeOf = new Map<number, number>()\n\t/** The ids on each size, for telling the others where they went */\n\tprivate readonly members: Set<number>[]\n\tprivate readonly motion: AgentMotion = { x: 0, y: 0, z: 0, vx: 0, vz: 0 }\n\n\t/**\n\t * `sizes` from the smallest up, each with the radius it was cut for, and the radius of the biggest unit it takes\n\t * (`upTo`) where that is not the next size's own\n\t */\n\tconstructor(\n\t\t/** The per-size navigations from the smallest up, each with the radius it was cut for and the radius of the biggest unit it takes (`upTo`) */\n\t\treadonly sizes: readonly { radius: number; upTo?: number; navigation: Navigation & AgentMirrors }[]\n\t) {\n\t\tif (!sizes.length) throw new Error('Navigation: no sizes to cut the ground for')\n\t\tthis.members = sizes.map(() => new Set())\n\t}\n\n\t/** The walkable-space version of the smallest size's navigation, bumped when obstacles are added or removed */\n\tget version(): number {\n\t\treturn this.sizes[0].navigation.version\n\t}\n\n\t/**\n\t * The size an agent of a radius goes on: the first that takes it (`upTo`), or the biggest it is not smaller than,\n\t * the smallest for one smaller than all\n\t */\n\tsizeFor(radius: number): number {\n\t\tif (this.sizes.every((size) => size.upTo !== undefined)) {\n\t\t\tconst taken = this.sizes.findIndex((size) => radius <= size.upTo!)\n\t\t\treturn taken < 0 ? this.sizes.length - 1 : taken\n\t\t}\n\t\tlet chosen = 0\n\t\tthis.sizes.forEach((size, i) => {\n\t\t\tif (radius >= size.radius) chosen = i\n\t\t})\n\t\treturn chosen\n\t}\n\n\tprivate of(id: number): Navigation {\n\t\treturn this.sizes[this.sizeOf.get(id) ?? 0].navigation\n\t}\n\n\t/** Puts an agent on the size its `params.radius` picks, and adds a mirror of it to every other size's crowd */\n\taddAgent(id: number, position: Vec2, params: AgentParams): void {\n\t\tthis.removeAgent(id)\n\t\tthis.enrol(id, params.radius)\n\t\tthis.of(id).addAgent(id, position, params)\n\t\tthis.addMirrors(id, params.radius, false)\n\t}\n\n\tprivate enrol(id: number, radius: number): void {\n\t\tconst size = this.sizeFor(radius)\n\t\tthis.sizeOf.set(id, size)\n\t\tthis.members[size].add(id)\n\t}\n\n\t/** An agent's mirror put in the crowd of every other size: out of everyone's way there while it phases */\n\tprivate addMirrors(id: number, radius: number, ghost: boolean, phasing = false): void {\n\t\tconst own = this.sizeOf.get(id)!\n\t\tif (!this.sizes[own].navigation.readMotion(id, this.motion)) return\n\t\tthis.sizes.forEach(({ navigation }, i) => {\n\t\t\tif (i === own) return\n\t\t\tnavigation.addMirror(id, this.motion, radius, ghost)\n\t\t\tif (phasing) navigation.setMirrorPhasing?.(id, true)\n\t\t})\n\t}\n\n\t/** Every other size told where an agent is now */\n\tprivate tellOthers(id: number, own: number): void {\n\t\tif (!this.sizes[own].navigation.readMotion(id, this.motion)) return\n\t\tfor (let i = 0; i < this.sizes.length; i++) if (i !== own) this.sizes[i].navigation.moveMirror(id, this.motion)\n\t}\n\n\t/** Takes an agent out of its own size's crowd and its mirror out of every other size's; does nothing for an unknown id */\n\tremoveAgent(id: number): void {\n\t\tconst own = this.sizeOf.get(id)\n\t\tif (own === undefined) return\n\t\tthis.sizes.forEach(({ navigation }, i) => {\n\t\t\tif (i === own) navigation.removeAgent(id)\n\t\t\telse navigation.removeMirror(id)\n\t\t})\n\t\tthis.members[own].delete(id)\n\t\tthis.sizeOf.delete(id)\n\t}\n\n\t/** Whether an agent of this id is enrolled on a size and present in that size's navigation */\n\thasAgent(id: number): boolean {\n\t\treturn this.sizeOf.has(id) && this.of(id).hasAgent(id)\n\t}\n\n\t/** Asks the agent's own size for a path towards `target`; false when nothing walkable is near it */\n\tsetDestination(id: number, target: Vec2): boolean {\n\t\treturn this.of(id).setDestination(id, target)\n\t}\n\n\t/** Stops the agent's walk on its own size's navigation */\n\tclearDestination(id: number): void {\n\t\tthis.of(id).clearDestination(id)\n\t}\n\n\t/** Moves the agent to `position` on its own size and tells the other sizes' mirrors where it now is */\n\tteleport(id: number, position: Vec2): void {\n\t\tthis.of(id).teleport(id, position)\n\t\tconst own = this.sizeOf.get(id)\n\t\tif (own !== undefined) this.tellOthers(id, own)\n\t}\n\n\t/** Sets whether the agent holds its ground on its own size, and updates its mirrors in the other sizes */\n\tsetAnchored(id: number, anchored: boolean): void {\n\t\tthis.of(id).setAnchored(id, anchored)\n\t\tconst own = this.sizeOf.get(id)\n\t\tif (own !== undefined) this.tellOthers(id, own)\n\t}\n\n\t/** Sets whether the agent ignores other agents, on its own size and on its mirrors in the other sizes */\n\tsetGhost(id: number, ghost: boolean): void {\n\t\tthis.of(id).setGhost(id, ghost)\n\t\tconst own = this.sizeOf.get(id)\n\t\tthis.sizes.forEach(({ navigation }, i) => {\n\t\t\tif (i !== own) navigation.setMirrorGhost(id, ghost)\n\t\t})\n\t}\n\n\t/** Has the agent walk through every other on its own size, and its mirrors out of everyone's way on the others */\n\tsetPhasing(id: number, phasing: boolean): void {\n\t\tconst own = this.sizeOf.get(id)\n\t\tif (own === undefined) return\n\t\tconst navigation = this.of(id)\n\t\tif (navigation.setPhasing) navigation.setPhasing(id, phasing)\n\t\telse navigation.setGhost(id, phasing)\n\t\tthis.sizes.forEach((size, i) => {\n\t\t\tif (i !== own) size.navigation.setMirrorPhasing?.(id, phasing)\n\t\t})\n\t}\n\n\t/** Sets the agent's top speed on its own size's navigation */\n\tsetSpeed(id: number, speed: number): void {\n\t\tthis.of(id).setSpeed(id, speed)\n\t}\n\n\t/** Reads the agent's state from its own size into `out`; false when the agent is unknown */\n\treadAgent(id: number, out: AgentState): boolean {\n\t\treturn this.sizeOf.has(id) && this.of(id).readAgent(id, out)\n\t}\n\n\t/** What a save needs of the agent from its own size, or undefined when there is none of that id */\n\tsaveAgent(id: number): AgentSave | undefined {\n\t\treturn this.sizeOf.has(id) ? this.of(id).saveAgent(id) : undefined\n\t}\n\n\t/** Puts an agent back from its save on the size its saved radius picks, with its mirrors in the other sizes */\n\trestoreAgent(id: number, save: AgentSave): void {\n\t\t// its size is in its radius, which the save has\n\t\tthis.removeAgent(id)\n\t\tthis.enrol(id, save.radius)\n\t\tthis.of(id).restoreAgent(id, save)\n\t\tthis.addMirrors(id, save.radius, save.ghost, !!save.phasing)\n\t}\n\n\t/** Puts the given agents back as a load does, each size anew in the save's order, then all the mirrors in that order */\n\treseat(agents: readonly (readonly [id: number, save: AgentSave])[]): void {\n\t\t// each size anew, with its agents in the save's order: its size is in its radius, which the save has\n\t\tthis.sizeOf.clear()\n\t\tfor (const members of this.members) members.clear()\n\t\tfor (const [id, save] of agents) this.enrol(id, save.radius)\n\t\tthis.sizes.forEach((size, i) => size.navigation.reseat(agents.filter(([id]) => this.sizeOf.get(id) === i)))\n\t\t// and then the mirrors, in the same order, each as its own navigation has just put it\n\t\tfor (const [id, save] of agents) this.addMirrors(id, save.radius, save.ghost, !!save.phasing)\n\t}\n\n\t/** After a load: settles every size's navigation at `version`, then tells each size where the others' agents are */\n\tsettle(version: number): void {\n\t\tfor (const size of this.sizes) size.navigation.settle(version)\n\t\tthis.tellAll()\n\t}\n\n\tprivate tellAll(): void {\n\t\tfor (const [id, own] of this.sizeOf) this.tellOthers(id, own)\n\t}\n\n\t/** Slow ground weighed again on each size's navigation, where a slowing layer changed */\n\tgroundChanged(cells: readonly number[], walkability?: boolean): void {\n\t\tfor (const size of this.sizes) size.navigation.groundChanged?.(cells, walkability)\n\t}\n\n\t/** Each size's navigation cut again of the ground as it is now */\n\treshape(area?: CellArea): boolean {\n\t\tlet any = false\n\t\tfor (const size of this.sizes) any = !!size.navigation.reshape?.(area) || any\n\t\treturn any\n\t}\n\n\t/** What the ground's changes asked of each size's navigation done now */\n\tsettleGround(): void {\n\t\tfor (const size of this.sizes) size.navigation.settleGround?.()\n\t}\n\n\t/** Steps each size's crowd from the smallest up, telling the other sizes where its agents went after each step */\n\tupdate(dt: number): void {\n\t\tfor (let i = 0; i < this.sizes.length; i++) {\n\t\t\tthis.sizes[i].navigation.update(dt)\n\t\t\tif (this.sizes.length > 1) for (const id of this.members[i]) this.tellOthers(id, i)\n\t\t}\n\t}\n\n\t/** Adds the obstacle to every size; false, with the sizes already done taken back, when any size has no room for it */\n\taddObstacle(key: number, rect: Rect): boolean {\n\t\t// in the way of every size, or of none: refused by one is taken back from those it went into\n\t\tconst added: Navigation[] = []\n\t\tfor (const { navigation } of this.sizes) {\n\t\t\tif (!navigation.addObstacle(key, rect)) {\n\t\t\t\tfor (const done of added) done.removeObstacle(key)\n\t\t\t\treturn false\n\t\t\t}\n\t\t\tadded.push(navigation)\n\t\t}\n\t\treturn true\n\t}\n\n\t/** Removes the obstacle `key` from every size's navigation */\n\tremoveObstacle(key: number): void {\n\t\tfor (const size of this.sizes) size.navigation.removeObstacle(key)\n\t}\n\n\t/** Holds back (true) or applies (false) obstacle changes on every size that supports it */\n\tholdObstacles(hold: boolean): void {\n\t\tfor (const size of this.sizes) size.navigation.holdObstacles?.(hold)\n\t}\n\n\t/** How many more obstacles fit: the smallest room among the sizes */\n\tobstacleRoom(): number {\n\t\treturn Math.min(...this.sizes.map((size) => size.navigation.obstacleRoom()))\n\t}\n\n\t/** Whether two agents are both enrolled; true for any two since different sizes see each other as mirrors */\n\tsameCrowd(a: number, b: number): boolean {\n\t\t// the one crowd, or each in the other's as a mirror: all the same to who is in whose way\n\t\treturn this.sizeOf.has(a) && this.sizeOf.has(b)\n\t}\n\n\t/** The closest walkable point to `point` on the smallest size, or null when none is within `searchRadius` */\n\tclosestPoint(point: Vec2, searchRadius?: number): Vec2 | null {\n\t\treturn this.sizes[0].navigation.closestPoint(point, searchRadius)\n\t}\n\n\t/** A path from `from` to `to` on the smallest size's navigation, or null when there is none */\n\tfindPath(from: Vec2, to: Vec2): Vec2[] | null {\n\t\treturn this.sizes[0].navigation.findPath(from, to)\n\t}\n\n\t/** The smallest size's navigation geometry for the debug overlay */\n\tdebugGeometry(): NavDebugGeometry {\n\t\treturn this.sizes[0].navigation.debugGeometry()\n\t}\n\n\t/** Disposes every size's navigation and forgets which agents are on which size */\n\tdispose(): void {\n\t\tfor (const size of this.sizes) size.navigation.dispose()\n\t\tthis.sizeOf.clear()\n\t\tfor (const members of this.members) members.clear()\n\t}\n}\n"],"mappings":"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"}

package/dist/nearest.js

@@ -0,0 +1,32 @@
+//#region src/nearest.ts
+/** The id of a set closest to one that is not in it, when one is close enough to have been meant: what a check says was meant */
+function nearestId(id, known) {
+	let best;
+	let least = Math.max(2, Math.floor(id.length / 3)) + 1;
+	for (const other of known) {
+		const distance = editDistance(id.toLowerCase(), other.toLowerCase());
+		if (distance < least) {
+			least = distance;
+			best = other;
+		}
+	}
+	return best;
+}
+/**
+* How many letters have to be changed, added or taken away to make one word of another: what says which id was meant
+*
+* @beta
+*/
+function editDistance(a, b) {
+	let row = Array.from({ length: b.length + 1 }, (_, i) => i);
+	for (let i = 1; i <= a.length; i++) {
+		const next = [i];
+		for (let j = 1; j <= b.length; j++) next[j] = Math.min(row[j] + 1, next[j - 1] + 1, row[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+		row = next;
+	}
+	return row[b.length];
+}
+//#endregion
+export { editDistance, nearestId };
+
+//# sourceMappingURL=nearest.js.map

package/dist/nearest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nearest.js","names":[],"sources":["../src/nearest.ts"],"sourcesContent":["/** The id of a set closest to one that is not in it, when one is close enough to have been meant: what a check says was meant */\nexport function nearestId(id: string, known: Iterable<string>): string | undefined {\n\tlet best: string | undefined\n\tlet least = Math.max(2, Math.floor(id.length / 3)) + 1\n\tfor (const other of known) {\n\t\tconst distance = editDistance(id.toLowerCase(), other.toLowerCase())\n\t\tif (distance < least) {\n\t\t\tleast = distance\n\t\t\tbest = other\n\t\t}\n\t}\n\treturn best\n}\n\n/**\n * How many letters have to be changed, added or taken away to make one word of another: what says which id was meant\n *\n * @beta\n */\nexport function editDistance(a: string, b: string): number {\n\tlet row = Array.from({ length: b.length + 1 }, (_, i) => i)\n\tfor (let i = 1; i <= a.length; i++) {\n\t\tconst next = [i]\n\t\tfor (let j = 1; j <= b.length; j++) next[j] = Math.min(row[j] + 1, next[j - 1] + 1, row[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1))\n\t\trow = next\n\t}\n\treturn row[b.length]\n}\n"],"mappings":";;AACA,SAAgB,UAAU,IAAY,OAA6C;CAClF,IAAI;CACJ,IAAI,QAAQ,KAAK,IAAI,GAAG,KAAK,MAAM,GAAG,SAAS,CAAC,CAAC,IAAI;CACrD,KAAK,MAAM,SAAS,OAAO;EAC1B,MAAM,WAAW,aAAa,GAAG,YAAY,GAAG,MAAM,YAAY,CAAC;EACnE,IAAI,WAAW,OAAO;GACrB,QAAQ;GACR,OAAO;EACR;CACD;CACA,OAAO;AACR;;;;;;AAOA,SAAgB,aAAa,GAAW,GAAmB;CAC1D,IAAI,MAAM,MAAM,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,IAAI,GAAG,MAAM,CAAC;CAC1D,KAAK,IAAI,IAAI,GAAG,KAAK,EAAE,QAAQ,KAAK;EACnC,MAAM,OAAO,CAAC,CAAC;EACf,KAAK,IAAI,IAAI,GAAG,KAAK,EAAE,QAAQ,KAAK,KAAK,KAAK,KAAK,IAAI,IAAI,KAAK,GAAG,KAAK,IAAI,KAAK,GAAG,IAAI,IAAI,MAAM,EAAE,IAAI,OAAO,EAAE,IAAI,KAAK,IAAI,EAAE;EAChI,MAAM;CACP;CACA,OAAO,IAAI,EAAE;AACd"}

package/dist/noise.js

@@ -0,0 +1,59 @@
+import { Rng } from "./rng.js";
+//#region src/noise.ts
+/**
+* Noise that repeats: a lattice of random values that wraps around, read smoothly between them, so that whatever is
+* made of it tiles. Seeded (`Rng`), so the same seed makes the same noise everywhere. What the map generator shapes
+* its ground with; the client makes the ground's textures with the same (`packages/client`, its own copy, so that a
+* worker of the page's loads nothing of the engine)
+*/
+/**
+* A value noise that repeats every `period` cells of its lattice: between 0 and 1, smooth
+*
+* @internal
+*/
+function tilingNoise(period, seed) {
+	const size = Math.max(1, Math.round(period));
+	const rng = new Rng(seed);
+	const values = Float32Array.from({ length: size * size }, () => rng.next());
+	return (u, v) => {
+		const x = u * size;
+		const z = v * size;
+		let x0 = Math.floor(x);
+		let z0 = Math.floor(z);
+		const fx = x - x0;
+		const fz = z - z0;
+		x0 = (x0 % size + size) % size;
+		z0 = (z0 % size + size) % size;
+		const x1 = x0 + 1 === size ? 0 : x0 + 1;
+		const z1 = z0 + 1 === size ? 0 : z0 + 1;
+		const sx = fx * fx * (3 - 2 * fx);
+		const sz = fz * fz * (3 - 2 * fz);
+		const r0 = z0 * size;
+		const r1 = z1 * size;
+		const top = values[r0 + x0] + (values[r0 + x1] - values[r0 + x0]) * sx;
+		return top + (values[r1 + x0] + (values[r1 + x1] - values[r1 + x0]) * sx - top) * sz;
+	};
+}
+/**
+* Several noises, each finer and fainter than the one before: what looks like ground and not like a pattern. 0..1
+*
+* @beta
+*/
+function layeredNoise(seed, periods) {
+	const noises = periods.map((period, i) => tilingNoise(period, seed + i * 101));
+	const weights = periods.map((_, i) => 1 / (1 << i));
+	const total = weights.reduce((sum, weight) => sum + weight, 0);
+	if (noises.length === 1) {
+		const [only] = noises;
+		return (u, v) => only(u, v);
+	}
+	return (u, v) => {
+		let sum = 0;
+		for (let i = 0; i < noises.length; i++) sum += noises[i](u, v) * weights[i];
+		return sum / total;
+	};
+}
+//#endregion
+export { layeredNoise, tilingNoise };
+
+//# sourceMappingURL=noise.js.map

package/dist/noise.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"noise.js","names":[],"sources":["../src/noise.ts"],"sourcesContent":["/**\n * Noise that repeats: a lattice of random values that wraps around, read smoothly between them, so that whatever is\n * made of it tiles. Seeded (`Rng`), so the same seed makes the same noise everywhere. What the map generator shapes\n * its ground with; the client makes the ground's textures with the same (`packages/client`, its own copy, so that a\n * worker of the page's loads nothing of the engine)\n */\nimport { Rng } from './rng'\n\n/**\n * Noise between 0 and 1 at a point, `u` and `v` 0..1 across the picture it repeats over\n *\n * @beta\n */\nexport type Noise2 = (u: number, v: number) => number\n\n/**\n * A value noise that repeats every `period` cells of its lattice: between 0 and 1, smooth\n *\n * @internal\n */\nexport function tilingNoise(period: number, seed: number): Noise2 {\n\tconst size = Math.max(1, Math.round(period))\n\tconst rng = new Rng(seed)\n\tconst values = Float32Array.from({ length: size * size }, () => rng.next())\n\t// written out, with no call in it: read a few hundred thousand times for a map\n\treturn (u, v) => {\n\t\tconst x = u * size\n\t\tconst z = v * size\n\t\tlet x0 = Math.floor(x)\n\t\tlet z0 = Math.floor(z)\n\t\tconst fx = x - x0\n\t\tconst fz = z - z0\n\t\tx0 = ((x0 % size) + size) % size\n\t\tz0 = ((z0 % size) + size) % size\n\t\tconst x1 = x0 + 1 === size ? 0 : x0 + 1\n\t\tconst z1 = z0 + 1 === size ? 0 : z0 + 1\n\t\tconst sx = fx * fx * (3 - 2 * fx)\n\t\tconst sz = fz * fz * (3 - 2 * fz)\n\t\tconst r0 = z0 * size\n\t\tconst r1 = z1 * size\n\t\tconst top = values[r0 + x0] + (values[r0 + x1] - values[r0 + x0]) * sx\n\t\tconst bottom = values[r1 + x0] + (values[r1 + x1] - values[r1 + x0]) * sx\n\t\treturn top + (bottom - top) * sz\n\t}\n}\n\n/**\n * Several noises, each finer and fainter than the one before: what looks like ground and not like a pattern. 0..1\n *\n * @beta\n */\nexport function layeredNoise(seed: number, periods: readonly number[]): Noise2 {\n\tconst noises = periods.map((period, i) => tilingNoise(period, seed + i * 101))\n\tconst weights = periods.map((_, i) => 1 / (1 << i))\n\tconst total = weights.reduce((sum, weight) => sum + weight, 0)\n\tif (noises.length === 1) {\n\t\tconst [only] = noises\n\t\treturn (u, v) => only(u, v)\n\t}\n\treturn (u, v) => {\n\t\tlet sum = 0\n\t\tfor (let i = 0; i < noises.length; i++) sum += noises[i](u, v) * weights[i]\n\t\treturn sum / total\n\t}\n}\n"],"mappings":";;;;;;;;;;;;;AAoBA,SAAgB,YAAY,QAAgB,MAAsB;CACjE,MAAM,OAAO,KAAK,IAAI,GAAG,KAAK,MAAM,MAAM,CAAC;CAC3C,MAAM,MAAM,IAAI,IAAI,IAAI;CACxB,MAAM,SAAS,aAAa,KAAK,EAAE,QAAQ,OAAO,KAAK,SAAS,IAAI,KAAK,CAAC;CAE1E,QAAQ,GAAG,MAAM;EAChB,MAAM,IAAI,IAAI;EACd,MAAM,IAAI,IAAI;EACd,IAAI,KAAK,KAAK,MAAM,CAAC;EACrB,IAAI,KAAK,KAAK,MAAM,CAAC;EACrB,MAAM,KAAK,IAAI;EACf,MAAM,KAAK,IAAI;EACf,MAAO,KAAK,OAAQ,QAAQ;EAC5B,MAAO,KAAK,OAAQ,QAAQ;EAC5B,MAAM,KAAK,KAAK,MAAM,OAAO,IAAI,KAAK;EACtC,MAAM,KAAK,KAAK,MAAM,OAAO,IAAI,KAAK;EACtC,MAAM,KAAK,KAAK,MAAM,IAAI,IAAI;EAC9B,MAAM,KAAK,KAAK,MAAM,IAAI,IAAI;EAC9B,MAAM,KAAK,KAAK;EAChB,MAAM,KAAK,KAAK;EAChB,MAAM,MAAM,OAAO,KAAK,OAAO,OAAO,KAAK,MAAM,OAAO,KAAK,OAAO;EAEpE,OAAO,OADQ,OAAO,KAAK,OAAO,OAAO,KAAK,MAAM,OAAO,KAAK,OAAO,KAChD,OAAO;CAC/B;AACD;;;;;;AAOA,SAAgB,aAAa,MAAc,SAAoC;CAC9E,MAAM,SAAS,QAAQ,KAAK,QAAQ,MAAM,YAAY,QAAQ,OAAO,IAAI,GAAG,CAAC;CAC7E,MAAM,UAAU,QAAQ,KAAK,GAAG,MAAM,KAAK,KAAK,EAAE;CAClD,MAAM,QAAQ,QAAQ,QAAQ,KAAK,WAAW,MAAM,QAAQ,CAAC;CAC7D,IAAI,OAAO,WAAW,GAAG;EACxB,MAAM,CAAC,QAAQ;EACf,QAAQ,GAAG,MAAM,KAAK,GAAG,CAAC;CAC3B;CACA,QAAQ,GAAG,MAAM;EAChB,IAAI,MAAM;EACV,KAAK,IAAI,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK,OAAO,OAAO,EAAE,CAAC,GAAG,CAAC,IAAI,QAAQ;EACzE,OAAO,MAAM;CACd;AACD"}

package/dist/objectives.d.ts

@@ -20,10 +20,14 @@ export interface ObjectiveDef {
 /**
  * Typed help for writing one
  *
- * @beta
+ * @public
  */
 export declare const defineObjective: (def: ObjectiveDef) => ObjectiveDef;
-/** @beta */
+/**
+ * Where an objective stands: `open` while it can still be met, `done` once met, `failed` once it can no longer be
+ *
+ * @beta
+ */
 export type ObjectiveStatus = 'open' | 'done' | 'failed';
 /**
  * An objective of a player, as it stands. Plain data: it is kept in the player's state, and sent to their screen
@@ -31,9 +35,13 @@ export type ObjectiveStatus = 'open' | 'done' | 'failed';
  * @beta
  */
 export interface ObjectiveState {
+    /** The objective's id (`ObjectiveDef.id`), unique among one player's objectives */
     id: string;
+    /** What it says, as a message with its params resolved (`ObjectiveDef.text` plus params given to `Objectives.add`) */
     text: Message;
+    /** Whether the mission needs it (`ObjectiveDef.required`, true when left out): all required done is a victory, one required failed a defeat */
     required: boolean;
+    /** Where it stands now: open, done or failed */
     status: ObjectiveStatus;
     /** How far along it is, for the ones that count: 3 of 10 waves */
     progress?: {
@@ -75,6 +83,7 @@ export declare class Objectives {
     }): void;
     /** A player's objectives, in the order they were given */
     of(player: PlayerId): readonly ObjectiveState[];
+    /** The player's objective of this id; throws when the player has none */
     get(player: PlayerId, id: string): ObjectiveState;
     /** Whether a player has the objective, open or not */
     has(player: PlayerId, id: string): boolean;
@@ -86,7 +95,7 @@ export declare class Objectives {
  * them wins, for their team. Like a melee game, a team whose players are all out loses, and the last team standing
  * wins. A game uses it as its `victory`
  *
- * @beta
+ * @public
  */
 export declare const objectiveVictory: System;
 /** An objective changed, to whose it is */

package/dist/objectives.js

@@ -0,0 +1,144 @@
+import { defineComponent } from "./components.js";
+import { gameOver, objectiveChanged } from "./engineEvents.js";
+import { replicateEvent } from "./replication.js";
+import { toMessage } from "./messages.js";
+import { defeat } from "./systems/victory.js";
+//#region src/objectives.ts
+/**
+* Typed help for writing one
+*
+* @public
+*/
+var defineObjective = (def) => def;
+/** A player's objectives, in the order they were given */
+var objectives = defineComponent({
+	id: "core.objectives",
+	default: () => []
+});
+/**
+* The objectives of the players of a world. What changes in them is the engine's `objectiveChanged` event, which
+* the player is shown, and which a game's listeners and sequences can wait for
+*
+* @beta
+*/
+var Objectives = class {
+	world;
+	constructor(world) {
+		this.world = world;
+	}
+	/** Gives a player an objective, open. Its words' params and its progress can be given with it */
+	add(player, def, options = {}) {
+		const list = this.of(player);
+		if (list.some((objective) => objective.id === def.id)) throw new Error(`Player ${player} has the objective "${def.id}" already`);
+		const text = toMessage(def.text);
+		const objective = {
+			id: def.id,
+			text: options.params ? {
+				key: text.key,
+				params: {
+					...text.params,
+					...options.params
+				}
+			} : text,
+			required: def.required ?? true,
+			status: "open",
+			progress: options.progress && { ...options.progress },
+			...def.detail !== void 0 && { detail: toMessage(def.detail) }
+		};
+		list.push(objective);
+		this.changed(player, objective, void 0);
+		return objective;
+	}
+	/** Done. Only an open one can be */
+	complete(player, id) {
+		this.settle(player, id, "done");
+	}
+	/** Failed, and why when that is worth saying. Only an open one can be */
+	fail(player, id, reason) {
+		this.settle(player, id, "failed", reason === void 0 ? void 0 : toMessage(reason));
+	}
+	/** How far along an open one is. Its words' params can change with it: "wave 3 of 10" */
+	progress(player, id, value, options = {}) {
+		const objective = this.get(player, id);
+		if (objective.status !== "open") return;
+		const max = options.max ?? objective.progress?.max ?? 1;
+		if (objective.progress?.value === value && objective.progress.max === max && !options.params) return;
+		objective.progress = {
+			value,
+			max
+		};
+		if (options.params) objective.text = {
+			key: objective.text.key,
+			params: {
+				...objective.text.params,
+				...options.params
+			}
+		};
+		this.changed(player, objective, "open");
+	}
+	/** A player's objectives, in the order they were given */
+	of(player) {
+		return this.world.player(player).state(objectives);
+	}
+	/** The player's objective of this id; throws when the player has none */
+	get(player, id) {
+		const objective = this.of(player).find((candidate) => candidate.id === id);
+		if (!objective) throw new Error(`Player ${player} has no objective "${id}"`);
+		return objective;
+	}
+	/** Whether a player has the objective, open or not */
+	has(player, id) {
+		return this.of(player).some((objective) => objective.id === id);
+	}
+	settle(player, id, status, reason) {
+		const objective = this.get(player, id);
+		if (objective.status !== "open") return;
+		objective.status = status;
+		if (reason) objective.reason = reason;
+		this.changed(player, objective, "open");
+	}
+	changed(player, objective, was) {
+		this.world.events.emit(objectiveChanged, {
+			player,
+			objective,
+			was
+		});
+	}
+};
+/**
+* The rule of a mission: a player who failed an objective the mission needs is out, and a player who did all of
+* them wins, for their team. Like a melee game, a team whose players are all out loses, and the last team standing
+* wins. A game uses it as its `victory`
+*
+* @public
+*/
+var objectiveVictory = {
+	name: "victory",
+	phase: "cleanup",
+	update(world) {
+		if (world.winner !== null) return;
+		for (const player of world.players.values()) {
+			if (player.neutral || player.defeated) continue;
+			const required = world.objectives.of(player.id).filter((objective) => objective.required);
+			if (required.some((objective) => objective.status === "failed")) defeat(world, player.id);
+			else if (required.length && required.every((objective) => objective.status === "done")) return win(world, player.team);
+		}
+		const standing = /* @__PURE__ */ new Set();
+		for (const player of world.players.values()) if (!player.neutral && !player.defeated) standing.add(player.team);
+		if (standing.size === 1) win(world, [...standing][0]);
+	}
+};
+function win(world, team) {
+	world.winner = team;
+	world.events.emit(gameOver, { winner: team });
+}
+/** An objective changed, to whose it is */
+var toldObjective = replicateEvent(objectiveChanged, "objective", ({ player, objective, was }, view) => player === view.player ? {
+	type: "objective",
+	objective: structuredClone(objective),
+	was
+} : void 0);
+//#endregion
+export { Objectives, defineObjective, objectiveVictory, objectives, toldObjective };
+
+//# sourceMappingURL=objectives.js.map

package/dist/objectives.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"objectives.js","names":["objectiveChangedEvent"],"sources":["../src/objectives.ts"],"sourcesContent":["import { gameOver, objectiveChanged as objectiveChangedEvent } from '#engine/engineEvents'\nimport { defineComponent } from './components'\nimport type { PlayerId } from './entity'\nimport { type Message, type MessageRef, toMessage } from './messages'\nimport type { System } from './registry'\nimport { defeat } from './systems/victory'\nimport type { World } from './world'\nimport { replicateEvent } from './replication'\n\n/**\n * What a player is set to do, in a mission: survive ten waves, keep the hero alive, build a frost tower\n *\n * @beta\n */\nexport interface ObjectiveDef {\n\t/** Shared by every game, like other ids: give it a prefix of the game's (`'td.hold'`) */\n\tid: string\n\t/** What it says, in the words of the game: a message key, with params where it shows numbers */\n\ttext: MessageRef\n\t/** Whether the mission needs it: all of them done is a victory, one failed a defeat. True when left out */\n\trequired?: boolean\n\t/** More about it, in the words of the game: shown under it when the player opens it in the quest panel (campaign plan CP5) */\n\tdetail?: MessageRef\n}\n\n/**\n * Typed help for writing one\n *\n * @public\n */\nexport const defineObjective = (def: ObjectiveDef): ObjectiveDef => def\n\n/**\n * Where an objective stands: `open` while it can still be met, `done` once met, `failed` once it can no longer be\n *\n * @beta\n */\nexport type ObjectiveStatus = 'open' | 'done' | 'failed'\n\n/**\n * An objective of a player, as it stands. Plain data: it is kept in the player's state, and sent to their screen\n *\n * @beta\n */\nexport interface ObjectiveState {\n\t/** The objective's id (`ObjectiveDef.id`), unique among one player's objectives */\n\tid: string\n\t/** What it says, as a message with its params resolved (`ObjectiveDef.text` plus params given to `Objectives.add`) */\n\ttext: Message\n\t/** Whether the mission needs it (`ObjectiveDef.required`, true when left out): all required done is a victory, one required failed a defeat */\n\trequired: boolean\n\t/** Where it stands now: open, done or failed */\n\tstatus: ObjectiveStatus\n\t/** How far along it is, for the ones that count: 3 of 10 waves */\n\tprogress?: { value: number; max: number }\n\t/** Why it failed, for a failed one that says */\n\treason?: Message\n\t/** More about it (`ObjectiveDef.detail`) */\n\tdetail?: Message\n}\n\n/** A player's objectives, in the order they were given */\nexport const objectives = defineComponent<ObjectiveState[]>({ id: 'core.objectives', default: () => [] })\n\n/**\n * The objectives of the players of a world. What changes in them is the engine's `objectiveChanged` event, which\n * the player is shown, and which a game's listeners and sequences can wait for\n *\n * @beta\n */\nexport class Objectives {\n\tconstructor(private readonly world: World) {}\n\n\t/** Gives a player an objective, open. Its words' params and its progress can be given with it */\n\tadd(player: PlayerId, def: ObjectiveDef, options: { params?: Message['params']; progress?: { value: number; max: number } } = {}): ObjectiveState {\n\t\tconst list = this.of(player) as ObjectiveState[]\n\t\tif (list.some((objective) => objective.id === def.id)) throw new Error(`Player ${player} has the objective \"${def.id}\" already`)\n\t\tconst text = toMessage(def.text)\n\t\tconst objective: ObjectiveState = {\n\t\t\tid: def.id,\n\t\t\ttext: options.params ? { key: text.key, params: { ...text.params, ...options.params } } : text,\n\t\t\trequired: def.required ?? true,\n\t\t\tstatus: 'open',\n\t\t\tprogress: options.progress && { ...options.progress },\n\t\t\t...(def.detail !== undefined && { detail: toMessage(def.detail) })\n\t\t}\n\t\tlist.push(objective)\n\t\tthis.changed(player, objective, undefined)\n\t\treturn objective\n\t}\n\n\t/** Done. Only an open one can be */\n\tcomplete(player: PlayerId, id: string): void {\n\t\tthis.settle(player, id, 'done')\n\t}\n\n\t/** Failed, and why when that is worth saying. Only an open one can be */\n\tfail(player: PlayerId, id: string, reason?: MessageRef): void {\n\t\tthis.settle(player, id, 'failed', reason === undefined ? undefined : toMessage(reason))\n\t}\n\n\t/** How far along an open one is. Its words' params can change with it: \"wave 3 of 10\" */\n\tprogress(player: PlayerId, id: string, value: number, options: { max?: number; params?: Message['params'] } = {}): void {\n\t\tconst objective = this.get(player, id)\n\t\tif (objective.status !== 'open') return\n\t\tconst max = options.max ?? objective.progress?.max ?? 1\n\t\tif (objective.progress?.value === value && objective.progress.max === max && !options.params) return\n\t\tobjective.progress = { value, max }\n\t\tif (options.params) objective.text = { key: objective.text.key, params: { ...objective.text.params, ...options.params } }\n\t\tthis.changed(player, objective, 'open')\n\t}\n\n\t/** A player's objectives, in the order they were given */\n\tof(player: PlayerId): readonly ObjectiveState[] {\n\t\treturn this.world.player(player).state(objectives)\n\t}\n\n\t/** The player's objective of this id; throws when the player has none */\n\tget(player: PlayerId, id: string): ObjectiveState {\n\t\tconst objective = this.of(player).find((candidate) => candidate.id === id)\n\t\tif (!objective) throw new Error(`Player ${player} has no objective \"${id}\"`)\n\t\treturn objective\n\t}\n\n\t/** Whether a player has the objective, open or not */\n\thas(player: PlayerId, id: string): boolean {\n\t\treturn this.of(player).some((objective) => objective.id === id)\n\t}\n\n\tprivate settle(player: PlayerId, id: string, status: 'done' | 'failed', reason?: Message): void {\n\t\tconst objective = this.get(player, id)\n\t\tif (objective.status !== 'open') return\n\t\tobjective.status = status\n\t\tif (reason) objective.reason = reason\n\t\tthis.changed(player, objective, 'open')\n\t}\n\n\tprivate changed(player: PlayerId, objective: ObjectiveState, was: ObjectiveStatus | undefined): void {\n\t\tthis.world.events.emit(objectiveChangedEvent, { player, objective, was })\n\t}\n}\n\n/**\n * The rule of a mission: a player who failed an objective the mission needs is out, and a player who did all of\n * them wins, for their team. Like a melee game, a team whose players are all out loses, and the last team standing\n * wins. A game uses it as its `victory`\n *\n * @public\n */\nexport const objectiveVictory: System = {\n\tname: 'victory',\n\tphase: 'cleanup',\n\tupdate(world) {\n\t\tif (world.winner !== null) return\n\t\tfor (const player of world.players.values()) {\n\t\t\tif (player.neutral || player.defeated) continue\n\t\t\tconst required = world.objectives.of(player.id).filter((objective) => objective.required)\n\t\t\tif (required.some((objective) => objective.status === 'failed')) defeat(world, player.id)\n\t\t\telse if (required.length && required.every((objective) => objective.status === 'done')) return win(world, player.team)\n\t\t}\n\t\t// the last team with anyone still in it\n\t\tconst standing = new Set<number>()\n\t\tfor (const player of world.players.values()) if (!player.neutral && !player.defeated) standing.add(player.team)\n\t\tif (standing.size === 1) win(world, [...standing][0])\n\t}\n}\n\nfunction win(world: World, team: number): void {\n\tworld.winner = team\n\tworld.events.emit(gameOver, { winner: team })\n}\n\n/** An objective changed, to whose it is */\nexport const toldObjective = replicateEvent(objectiveChangedEvent, 'objective', ({ player, objective, was }, view) =>\n\tplayer === view.player ? { type: 'objective', objective: structuredClone(objective), was } : undefined\n)\n"],"mappings":"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"}

package/dist/orders/basic.d.ts

@@ -1,6 +1,7 @@
 import { type EntityId } from '#engine/entity';
 import type { Vec2 } from '#engine/math';
 import type { OrderBehavior, OrderInits } from '#engine/registry';
+import { type WaitState } from '#engine/orders/waiting';
 /**
  * What `hold` keeps in its order: what it is fighting, 0 for nothing
  *
@@ -11,11 +12,12 @@ export interface HoldState {
     target?: EntityId;
 }
 /**
- * What `attack` keeps: whether it lost sight and walks to where it last saw its target
+ * What `attack` keeps: whether it lost sight and walks to where it last saw its target, and whether it waits for room
+ * by it (`WaitState`)
  *
  * @beta
  */
-export interface AttackState {
+export interface AttackState extends WaitState {
     /** Walking to where it last saw its target */
     searching?: boolean;
     /** Where it last saw it */
@@ -26,13 +28,11 @@ export interface AttackState {
  *
  * @beta
  */
-export interface AdvanceState {
+export interface AdvanceState extends WaitState {
     /** What it fights, 0 for nothing */
     target?: EntityId;
     /** To walk on again once the fight is over */
     resume?: boolean;
-    /** Held up behind its own, waiting */
-    waiting?: boolean;
     /** The point it last set out for */
     heading?: Vec2;
 }