@v12-engine/engine 0.1.1 → 0.4.0

package/dist/mapMeasure.js

@@ -0,0 +1,283 @@
+import { hypot } from "./exactMath.js";
+import { footprintOf } from "./defs.js";
+import { BuildGrid } from "./grid.js";
+import { mapTerrain } from "./map/terrain.js";
+import { mapCells } from "./mapCheck/cells.js";
+//#region src/mapMeasure.ts
+function walking(map, registry) {
+	const { width, depth, levels, ramps } = map;
+	const { open } = mapCells(map, registry, mapTerrain(map), true);
+	const cellAt = (point) => {
+		const cx = Math.floor(point.x);
+		const cz = Math.floor(point.z);
+		for (let r = 0; r <= 6; r++) for (let z = cz - r; z <= cz + r; z++) for (let x = cx - r; x <= cx + r; x++) {
+			if (x < 0 || z < 0 || x >= width || z >= depth || Math.max(Math.abs(x - cx), Math.abs(z - cz)) !== r) continue;
+			if (open[z * width + x]) return z * width + x;
+		}
+		return -1;
+	};
+	return {
+		width,
+		depth,
+		open,
+		passable: (a, b) => levels[a] === levels[b] || ramps[a] > 0 || ramps[b] > 0,
+		cellAt
+	};
+}
+/** The way on foot between two cells: A* over the cells, eight ways, corners not cut. Nothing when there is none */
+function walk(walking, from, to) {
+	const { width, depth, open, passable } = walking;
+	if (from < 0 || to < 0) return void 0;
+	const cells = width * depth;
+	const cost = new Float32Array(cells).fill(Infinity);
+	const came = new Int32Array(cells).fill(-1);
+	const closed = new Uint8Array(cells);
+	const tx = to % width;
+	const tz = Math.floor(to / width);
+	const guess = (c) => {
+		const dx = Math.abs(c % width - tx);
+		const dz = Math.abs(Math.floor(c / width) - tz);
+		return Math.max(dx, dz) + (Math.SQRT2 - 1) * Math.min(dx, dz);
+	};
+	const heap = [];
+	const score = new Float32Array(cells);
+	const push = (c) => {
+		heap.push(c);
+		let i = heap.length - 1;
+		while (i > 0) {
+			const parent = i - 1 >> 1;
+			if (score[heap[parent]] <= score[heap[i]]) break;
+			[heap[parent], heap[i]] = [heap[i], heap[parent]];
+			i = parent;
+		}
+	};
+	const pop = () => {
+		const top = heap[0];
+		const last = heap.pop();
+		if (heap.length) {
+			heap[0] = last;
+			let i = 0;
+			for (;;) {
+				const left = i * 2 + 1;
+				const right = left + 1;
+				let least = i;
+				if (left < heap.length && score[heap[left]] < score[heap[least]]) least = left;
+				if (right < heap.length && score[heap[right]] < score[heap[least]]) least = right;
+				if (least === i) break;
+				[heap[least], heap[i]] = [heap[i], heap[least]];
+				i = least;
+			}
+		}
+		return top;
+	};
+	cost[from] = 0;
+	score[from] = guess(from);
+	push(from);
+	while (heap.length) {
+		const c = pop();
+		if (closed[c]) continue;
+		if (c === to) break;
+		closed[c] = 1;
+		const x = c % width;
+		const z = (c - x) / width;
+		for (let dz = -1; dz <= 1; dz++) for (let dx = -1; dx <= 1; dx++) {
+			if (!dx && !dz) continue;
+			const nx = x + dx;
+			const nz = z + dz;
+			if (nx < 0 || nz < 0 || nx >= width || nz >= depth) continue;
+			const n = nz * width + nx;
+			if (!open[n] || closed[n] || !passable(c, n)) continue;
+			if (dx && dz) {
+				const side1 = z * width + nx;
+				const side2 = nz * width + x;
+				if (!open[side1] || !open[side2] || !passable(c, side1) || !passable(c, side2)) continue;
+			}
+			const next = cost[c] + (dx && dz ? Math.SQRT2 : 1);
+			if (next >= cost[n]) continue;
+			cost[n] = next;
+			came[n] = c;
+			score[n] = next + guess(n);
+			push(n);
+		}
+	}
+	if (!Number.isFinite(cost[to])) return void 0;
+	const points = [];
+	for (let c = to; c >= 0; c = came[c]) points.push({
+		x: c % width + .5,
+		z: Math.floor(c / width) + .5
+	});
+	return {
+		length: cost[to],
+		points: points.reverse()
+	};
+}
+/**
+* The way on foot between two points of a map, with what the checks count as in the way. Nothing when there is none
+*
+* @beta
+*/
+function walkBetween(map, registry, from, to) {
+	const cells = walking(map, registry);
+	return walk(cells, cells.cellAt(from), cells.cellAt(to));
+}
+/**
+* How many cells each open cell is from what is not: half the width of the way there. A passage two cells wide has
+* cells 1 from its sides in its middle
+*/
+function clearance(walking) {
+	const { width, depth, open } = walking;
+	const far = new Float32Array(width * depth);
+	for (let c = 0; c < far.length; c++) far[c] = open[c] ? Infinity : 0;
+	const step = (c, x, z, dx, dz, weight) => {
+		const nx = x + dx;
+		const nz = z + dz;
+		const next = nx < 0 || nz < 0 || nx >= width || nz >= depth ? 0 : far[nz * width + nx];
+		if (next + weight < far[c]) far[c] = next + weight;
+	};
+	for (let z = 0; z < depth; z++) for (let x = 0; x < width; x++) {
+		const c = z * width + x;
+		if (!far[c]) continue;
+		step(c, x, z, -1, 0, 1);
+		step(c, x, z, 0, -1, 1);
+		step(c, x, z, -1, -1, Math.SQRT2);
+		step(c, x, z, 1, -1, Math.SQRT2);
+	}
+	for (let z = depth - 1; z >= 0; z--) for (let x = width - 1; x >= 0; x--) {
+		const c = z * width + x;
+		if (!far[c]) continue;
+		step(c, x, z, 1, 0, 1);
+		step(c, x, z, 0, 1, 1);
+		step(c, x, z, 1, 1, Math.SQRT2);
+		step(c, x, z, -1, 1, Math.SQRT2);
+	}
+	return far;
+}
+/**
+* How far around a start counts as its ground, for building and trees
+*
+* @beta
+*/
+var BUILD_REACH = 16;
+/**
+* How much more one start can have of something than another before it is not fair, as a part
+*
+* @internal
+*/
+var FAIR_MARGIN = .15;
+/** The ends of a way, in cells, where the bases stand: the narrowest place is looked for between them */
+var BASE_ROOM = 8;
+/**
+* What a map is like to play on: the way on foot between every two starts, the narrowest place on those ways, and for
+* each start the nearest mine and how much it holds, the ground around it that can be built on, and its trees; side
+* by side, with what one start has much more of than another said. Then what the game measures of its own
+*
+* @beta
+*/
+function measureMap(map, registry) {
+	const cells = walking(map, registry);
+	const terrain = mapTerrain(map);
+	const grid = new BuildGrid(terrain);
+	const { built } = mapCells(map, registry, terrain);
+	const starts = map.players.filter((player) => player.start);
+	const rushes = [];
+	for (let i = 0; i < starts.length; i++) for (let j = i + 1; j < starts.length; j++) {
+		const way = walk(cells, cells.cellAt(starts[i].start), cells.cellAt(starts[j].start));
+		rushes.push({
+			from: starts[i].id,
+			to: starts[j].id,
+			...way && {
+				length: Math.round(way.length * 10) / 10,
+				points: way.points
+			}
+		});
+	}
+	const far = clearance(cells);
+	let narrowest;
+	for (const rush of rushes) {
+		const points = rush.points ?? [];
+		for (let i = BASE_ROOM; i < points.length - BASE_ROOM; i++) {
+			const c = Math.floor(points[i].z) * cells.width + Math.floor(points[i].x);
+			const width = Math.round((far[c] * 2 - 1) * 10) / 10;
+			if (!narrowest || width < narrowest.width) narrowest = {
+				width,
+				at: points[i]
+			};
+		}
+	}
+	const mines = map.objects.filter((object) => {
+		if (!registry.units.has(object.type)) return false;
+		const def = registry.unit(object.type);
+		return def.kind === "resource" && footprintOf(def).w >= 2;
+	});
+	const measures = starts.map((player) => {
+		const start = player.start;
+		const from = cells.cellAt(start);
+		let mine;
+		for (const object of mines) {
+			const way = walk(cells, from, cells.cellAt(object));
+			if (!way || mine && way.length >= mine.distance) continue;
+			const def = registry.unit(object.type);
+			mine = {
+				distance: Math.round(way.length * 10) / 10,
+				amount: object.amount ?? def.resource?.amount ?? 0,
+				at: {
+					x: object.x,
+					z: object.z
+				}
+			};
+		}
+		let buildable = 0;
+		for (let z = Math.floor(start.z - 16); z <= Math.ceil(start.z + 16); z++) for (let x = Math.floor(start.x - 16); x <= Math.ceil(start.x + 16); x++) {
+			if (hypot(x + .5 - start.x, z + .5 - start.z) > 16) continue;
+			if (grid.isBuildable(x, z) && !built[z * map.width + x]) buildable++;
+		}
+		const trees = map.objects.filter((object) => {
+			if (!registry.units.has(object.type) || hypot(object.x - start.x, object.z - start.z) > 16) return false;
+			const def = registry.unit(object.type);
+			return def.kind === "resource" && footprintOf(def).w < 2;
+		}).length;
+		return {
+			player: player.id,
+			name: player.name,
+			...mine && { mine },
+			buildable,
+			trees
+		};
+	});
+	const unfair = [];
+	const compare = (what, value, more = "more") => {
+		const known = measures.map((start) => ({
+			start,
+			value: value(start)
+		})).filter((entry) => entry.value !== void 0);
+		if (known.length < 2) return;
+		const most = known.reduce((a, b) => b.value > a.value ? b : a);
+		const least = known.reduce((a, b) => b.value < a.value ? b : a);
+		if (most.value > least.value * 1.15 && most.value - least.value > 1) unfair.push(`${most.start.name} has ${more} ${what} than ${least.start.name}: ${most.value} against ${least.value}`);
+	};
+	compare("way to their nearest mine", (start) => start.mine?.distance, "a longer");
+	compare("gold in their nearest mine", (start) => start.mine?.amount);
+	compare("ground to build on", (start) => start.buildable);
+	compare("trees near their start", (start) => start.trees);
+	return {
+		rushes: rushes.map(({ points: _, ...rush }) => rush),
+		...narrowest && { narrowest },
+		starts: measures,
+		unfair,
+		game: registry.module?.editor?.measure?.(map, registry) ?? []
+	};
+}
+/**
+* Seconds a unit type takes over a way on foot, at the speed it starts with
+*
+* @beta
+*/
+var walkingTime = (registry, type, length) => {
+	if (!registry.units.has(type)) return void 0;
+	const speed = registry.unit(type).stats.moveSpeed ?? 0;
+	return speed > 0 ? Math.round(length / speed * 10) / 10 : void 0;
+};
+//#endregion
+export { BUILD_REACH, FAIR_MARGIN, measureMap, walkBetween, walkingTime };
+
+//# sourceMappingURL=mapMeasure.js.map

package/dist/mapMeasure.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapMeasure.js","names":[],"sources":["../src/mapMeasure.ts"],"sourcesContent":["import { footprintOf } from './defs'\nimport type { PlayerId } from './entity'\nimport { BuildGrid, footprintCell } from './grid'\nimport { type GameMap, mapTerrain } from './map'\nimport { mapCells } from './mapCheck'\nimport type { Vec2 } from './math'\nimport type { Registry } from './registry'\nimport { hypot } from './exactMath'\n\n/**\n * A way on foot over a map: its length, and the points it goes through\n *\n * @beta\n */\nexport interface Walk {\n\t/** The length of the way, in cells */\n\tlength: number\n\t/** The points the way goes through, from its start to its end */\n\tpoints: Vec2[]\n}\n\n/** How the cells of a map are walked: which are open, and between which a step is no cliff */\ninterface Walking {\n\twidth: number\n\tdepth: number\n\topen: Uint8Array\n\tpassable(a: number, b: number): boolean\n\t/** The open cell nearest a point, for what stands on cells nothing walks on, or -1 */\n\tcellAt(point: Vec2): number\n}\n\nfunction walking(map: GameMap, registry: Registry): Walking {\n\tconst { width, depth, levels, ramps } = map\n\tconst { open } = mapCells(map, registry, mapTerrain(map), true)\n\tconst cellAt = (point: Vec2) => {\n\t\tconst cx = Math.floor(point.x)\n\t\tconst cz = Math.floor(point.z)\n\t\tfor (let r = 0; r <= 6; r++) {\n\t\t\tfor (let z = cz - r; z <= cz + r; z++) {\n\t\t\t\tfor (let x = cx - r; x <= cx + r; x++) {\n\t\t\t\t\tif (x < 0 || z < 0 || x >= width || z >= depth || Math.max(Math.abs(x - cx), Math.abs(z - cz)) !== r) continue\n\t\t\t\t\tif (open[z * width + x]) return z * width + x\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn -1\n\t}\n\treturn { width, depth, open, passable: (a, b) => levels[a] === levels[b] || ramps[a] > 0 || ramps[b] > 0, cellAt }\n}\n\n/** The way on foot between two cells: A* over the cells, eight ways, corners not cut. Nothing when there is none */\nfunction walk(walking: Walking, from: number, to: number): Walk | undefined {\n\tconst { width, depth, open, passable } = walking\n\tif (from < 0 || to < 0) return undefined\n\tconst cells = width * depth\n\tconst cost = new Float32Array(cells).fill(Infinity)\n\tconst came = new Int32Array(cells).fill(-1)\n\tconst closed = new Uint8Array(cells)\n\tconst tx = to % width\n\tconst tz = Math.floor(to / width)\n\tconst guess = (c: number) => {\n\t\tconst dx = Math.abs((c % width) - tx)\n\t\tconst dz = Math.abs(Math.floor(c / width) - tz)\n\t\treturn Math.max(dx, dz) + (Math.SQRT2 - 1) * Math.min(dx, dz)\n\t}\n\t// a binary heap of cells by cost and guess\n\tconst heap: number[] = []\n\tconst score = new Float32Array(cells)\n\tconst push = (c: number) => {\n\t\theap.push(c)\n\t\tlet i = heap.length - 1\n\t\twhile (i > 0) {\n\t\t\tconst parent = (i - 1) >> 1\n\t\t\tif (score[heap[parent]] <= score[heap[i]]) break\n\t\t\t;[heap[parent], heap[i]] = [heap[i], heap[parent]]\n\t\t\ti = parent\n\t\t}\n\t}\n\tconst pop = () => {\n\t\tconst top = heap[0]\n\t\tconst last = heap.pop()!\n\t\tif (heap.length) {\n\t\t\theap[0] = last\n\t\t\tlet i = 0\n\t\t\tfor (;;) {\n\t\t\t\tconst left = i * 2 + 1\n\t\t\t\tconst right = left + 1\n\t\t\t\tlet least = i\n\t\t\t\tif (left < heap.length && score[heap[left]] < score[heap[least]]) least = left\n\t\t\t\tif (right < heap.length && score[heap[right]] < score[heap[least]]) least = right\n\t\t\t\tif (least === i) break\n\t\t\t\t;[heap[least], heap[i]] = [heap[i], heap[least]]\n\t\t\t\ti = least\n\t\t\t}\n\t\t}\n\t\treturn top\n\t}\n\tcost[from] = 0\n\tscore[from] = guess(from)\n\tpush(from)\n\twhile (heap.length) {\n\t\tconst c = pop()\n\t\tif (closed[c]) continue\n\t\tif (c === to) break\n\t\tclosed[c] = 1\n\t\tconst x = c % width\n\t\tconst z = (c - x) / width\n\t\tfor (let dz = -1; dz <= 1; dz++) {\n\t\t\tfor (let dx = -1; dx <= 1; dx++) {\n\t\t\t\tif (!dx && !dz) continue\n\t\t\t\tconst nx = x + dx\n\t\t\t\tconst nz = z + dz\n\t\t\t\tif (nx < 0 || nz < 0 || nx >= width || nz >= depth) continue\n\t\t\t\tconst n = nz * width + nx\n\t\t\t\tif (!open[n] || closed[n] || !passable(c, n)) continue\n\t\t\t\t// a diagonal step only past two open cells: no cutting the corner of a cliff\n\t\t\t\tif (dx && dz) {\n\t\t\t\t\tconst side1 = z * width + nx\n\t\t\t\t\tconst side2 = nz * width + x\n\t\t\t\t\tif (!open[side1] || !open[side2] || !passable(c, side1) || !passable(c, side2)) continue\n\t\t\t\t}\n\t\t\t\tconst next = cost[c] + (dx && dz ? Math.SQRT2 : 1)\n\t\t\t\tif (next >= cost[n]) continue\n\t\t\t\tcost[n] = next\n\t\t\t\tcame[n] = c\n\t\t\t\tscore[n] = next + guess(n)\n\t\t\t\tpush(n)\n\t\t\t}\n\t\t}\n\t}\n\tif (!Number.isFinite(cost[to])) return undefined\n\tconst points: Vec2[] = []\n\tfor (let c = to; c >= 0; c = came[c]) points.push({ x: (c % width) + 0.5, z: Math.floor(c / width) + 0.5 })\n\treturn { length: cost[to], points: points.reverse() }\n}\n\n/**\n * The way on foot between two points of a map, with what the checks count as in the way. Nothing when there is none\n *\n * @beta\n */\nexport function walkBetween(map: GameMap, registry: Registry, from: Vec2, to: Vec2): Walk | undefined {\n\tconst cells = walking(map, registry)\n\treturn walk(cells, cells.cellAt(from), cells.cellAt(to))\n}\n\n/**\n * How many cells each open cell is from what is not: half the width of the way there. A passage two cells wide has\n * cells 1 from its sides in its middle\n */\nfunction clearance(walking: Walking): Float32Array {\n\tconst { width, depth, open } = walking\n\tconst far = new Float32Array(width * depth)\n\tfor (let c = 0; c < far.length; c++) far[c] = open[c] ? Infinity : 0\n\t// two passes of a chamfer distance, eight ways\n\tconst step = (c: number, x: number, z: number, dx: number, dz: number, weight: number) => {\n\t\tconst nx = x + dx\n\t\tconst nz = z + dz\n\t\tconst next = nx < 0 || nz < 0 || nx >= width || nz >= depth ? 0 : far[nz * width + nx]\n\t\tif (next + weight < far[c]) far[c] = next + weight\n\t}\n\tfor (let z = 0; z < depth; z++) {\n\t\tfor (let x = 0; x < width; x++) {\n\t\t\tconst c = z * width + x\n\t\t\tif (!far[c]) continue\n\t\t\tstep(c, x, z, -1, 0, 1)\n\t\t\tstep(c, x, z, 0, -1, 1)\n\t\t\tstep(c, x, z, -1, -1, Math.SQRT2)\n\t\t\tstep(c, x, z, 1, -1, Math.SQRT2)\n\t\t}\n\t}\n\tfor (let z = depth - 1; z >= 0; z--) {\n\t\tfor (let x = width - 1; x >= 0; x--) {\n\t\t\tconst c = z * width + x\n\t\t\tif (!far[c]) continue\n\t\t\tstep(c, x, z, 1, 0, 1)\n\t\t\tstep(c, x, z, 0, 1, 1)\n\t\t\tstep(c, x, z, 1, 1, Math.SQRT2)\n\t\t\tstep(c, x, z, -1, 1, Math.SQRT2)\n\t\t}\n\t}\n\treturn far\n}\n\n/**\n * What one player's start has around it\n *\n * @beta\n */\nexport interface StartMeasure {\n\t/** The player the start is for */\n\tplayer: PlayerId\n\t/** The start's name, as the map names its player */\n\tname: string\n\t/** The way on foot to the nearest mine, and how much it holds. Nothing without a mine they can walk to */\n\tmine?: { distance: number; amount: number; at: Vec2 }\n\t/** How many cells within `BUILD_REACH` of the start can be built on */\n\tbuildable: number\n\t/** Trees within `BUILD_REACH` of the start */\n\ttrees: number\n}\n\n/**\n * A number of a map a game measures of its own (`MapEditorDef.measure`): the length of the road, for a tower defense\n *\n * @beta\n */\nexport interface GameMeasure {\n\t/** The name of the measure, as the editor shows it */\n\tname: string\n\t/** The measured number or text */\n\tvalue: number | string\n}\n\n/**\n * What a map is like to play on, measured (see `measureMap`)\n *\n * @beta\n */\nexport interface MapReport {\n\t/** The way on foot between every two starts: how far a rush goes. Nothing for starts cut off from each other */\n\trushes: { from: PlayerId; to: PlayerId; length?: number; points?: Vec2[] }[]\n\t/** The narrowest place on the ways between the starts, and how wide it is */\n\tnarrowest?: { width: number; at: Vec2 }\n\t/** The measure of every player's start */\n\tstarts: StartMeasure[]\n\t/** What each start has that another has more than `FAIR_MARGIN` more of: what is not fair */\n\tunfair: string[]\n\t/** The numbers the game measures of its own (`MapEditorDef.measure`) */\n\tgame: GameMeasure[]\n}\n\n/**\n * How far around a start counts as its ground, for building and trees\n *\n * @beta\n */\nexport const BUILD_REACH = 16\n/**\n * How much more one start can have of something than another before it is not fair, as a part\n *\n * @internal\n */\nexport const FAIR_MARGIN = 0.15\n/** The ends of a way, in cells, where the bases stand: the narrowest place is looked for between them */\nconst BASE_ROOM = 8\n\n/**\n * What a map is like to play on: the way on foot between every two starts, the narrowest place on those ways, and for\n * each start the nearest mine and how much it holds, the ground around it that can be built on, and its trees; side\n * by side, with what one start has much more of than another said. Then what the game measures of its own\n *\n * @beta\n */\nexport function measureMap(map: GameMap, registry: Registry): MapReport {\n\tconst cells = walking(map, registry)\n\tconst terrain = mapTerrain(map)\n\tconst grid = new BuildGrid(terrain)\n\tconst { built } = mapCells(map, registry, terrain)\n\tconst starts = map.players.filter((player) => player.start)\n\tconst rushes: MapReport['rushes'] = []\n\tfor (let i = 0; i < starts.length; i++) {\n\t\tfor (let j = i + 1; j < starts.length; j++) {\n\t\t\tconst way = walk(cells, cells.cellAt(starts[i].start!), cells.cellAt(starts[j].start!))\n\t\t\trushes.push({ from: starts[i].id, to: starts[j].id, ...(way && { length: Math.round(way.length * 10) / 10, points: way.points }) })\n\t\t}\n\t}\n\t// the narrowest place on the ways between the bases, not in the bases\n\tconst far = clearance(cells)\n\tlet narrowest: MapReport['narrowest']\n\tfor (const rush of rushes) {\n\t\tconst points = rush.points ?? []\n\t\tfor (let i = BASE_ROOM; i < points.length - BASE_ROOM; i++) {\n\t\t\tconst c = Math.floor(points[i].z) * cells.width + Math.floor(points[i].x)\n\t\t\tconst width = Math.round((far[c] * 2 - 1) * 10) / 10\n\t\t\tif (!narrowest || width < narrowest.width) narrowest = { width, at: points[i] }\n\t\t}\n\t}\n\tconst mines = map.objects.filter((object) => {\n\t\tif (!registry.units.has(object.type)) return false\n\t\tconst def = registry.unit(object.type)\n\t\treturn def.kind === 'resource' && footprintOf(def).w >= 2\n\t})\n\tconst measures: StartMeasure[] = starts.map((player) => {\n\t\tconst start = player.start!\n\t\tconst from = cells.cellAt(start)\n\t\tlet mine: StartMeasure['mine']\n\t\tfor (const object of mines) {\n\t\t\tconst way = walk(cells, from, cells.cellAt(object))\n\t\t\tif (!way || (mine && way.length >= mine.distance)) continue\n\t\t\tconst def = registry.unit(object.type)\n\t\t\tmine = { distance: Math.round(way.length * 10) / 10, amount: object.amount ?? def.resource?.amount ?? 0, at: { x: object.x, z: object.z } }\n\t\t}\n\t\tlet buildable = 0\n\t\tfor (let z = Math.floor(start.z - BUILD_REACH); z <= Math.ceil(start.z + BUILD_REACH); z++) {\n\t\t\tfor (let x = Math.floor(start.x - BUILD_REACH); x <= Math.ceil(start.x + BUILD_REACH); x++) {\n\t\t\t\tif (hypot(x + 0.5 - start.x, z + 0.5 - start.z) > BUILD_REACH) continue\n\t\t\t\tif (grid.isBuildable(x, z) && !built[z * map.width + x]) buildable++\n\t\t\t}\n\t\t}\n\t\tconst trees = map.objects.filter((object) => {\n\t\t\tif (!registry.units.has(object.type) || hypot(object.x - start.x, object.z - start.z) > BUILD_REACH) return false\n\t\t\tconst def = registry.unit(object.type)\n\t\t\treturn def.kind === 'resource' && footprintOf(def).w < 2\n\t\t}).length\n\t\treturn { player: player.id, name: player.name, ...(mine && { mine }), buildable, trees }\n\t})\n\t// what is not fair: one start with much more of something than another\n\tconst unfair: string[] = []\n\tconst compare = (what: string, value: (start: StartMeasure) => number | undefined, more = 'more') => {\n\t\tconst values = measures.map((start) => ({ start, value: value(start) }))\n\t\tconst known = values.filter((entry) => entry.value !== undefined) as { start: StartMeasure; value: number }[]\n\t\tif (known.length < 2) return\n\t\tconst most = known.reduce((a, b) => (b.value > a.value ? b : a))\n\t\tconst least = known.reduce((a, b) => (b.value < a.value ? b : a))\n\t\tif (most.value > least.value * (1 + FAIR_MARGIN) && most.value - least.value > 1) {\n\t\t\tunfair.push(`${most.start.name} has ${more} ${what} than ${least.start.name}: ${most.value} against ${least.value}`)\n\t\t}\n\t}\n\tcompare('way to their nearest mine', (start) => start.mine?.distance, 'a longer')\n\tcompare('gold in their nearest mine', (start) => start.mine?.amount)\n\tcompare('ground to build on', (start) => start.buildable)\n\tcompare('trees near their start', (start) => start.trees)\n\treturn {\n\t\trushes: rushes.map(({ points: _, ...rush }) => rush),\n\t\t...(narrowest && { narrowest }),\n\t\tstarts: measures,\n\t\tunfair,\n\t\tgame: registry.module?.editor?.measure?.(map, registry) ?? []\n\t}\n}\n\n/**\n * Seconds a unit type takes over a way on foot, at the speed it starts with\n *\n * @beta\n */\nexport const walkingTime = (registry: Registry, type: string, length: number): number | undefined => {\n\tif (!registry.units.has(type)) return undefined\n\tconst speed = registry.unit(type).stats.moveSpeed ?? 0\n\treturn speed > 0 ? Math.round((length / speed) * 10) / 10 : undefined\n}\n\n/** The cell of a footprint, for drawing where a mine stands */\nexport const footprintAt = (registry: Registry, type: string, at: Vec2) => {\n\tconst { w, d } = footprintOf(registry.unit(type))\n\treturn footprintCell(at.x, at.z, w, d)\n}\n"],"mappings":"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"}

package/dist/mapMerge.d.ts

@@ -5,6 +5,7 @@ import { type GameMap } from './map';
  * @beta
  */
 export interface MapMerge {
+    /** The map the two versions were merged into */
     map: GameMap;
     /** What both sides changed otherwise, in words: ours was kept for each */
     conflicts: string[];

package/dist/mapMerge.js

@@ -0,0 +1,172 @@
+import { BY_ID as BY_ID$1, LAYERS } from "./map/schema.js";
+import { parseMap, serializeMap } from "./map/file.js";
+//#region src/mapMerge.ts
+/** The parts of a map file that are lists of things with ids, merged thing by thing: the map's table says (`MAP_FIELDS`) */
+var BY_ID = new Set(BY_ID$1);
+/** What they are as text, to be compared: the same value, the same text */
+var same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+/**
+* The three-way choice of one value: what only one side changed is that side's; both alike, either; both otherwise,
+* ours, and a conflict. `undefined` is a value too: a part one side took out
+*/
+function pick(base, ours, theirs) {
+	if (same(ours, theirs)) return {
+		value: ours,
+		conflict: false
+	};
+	if (same(ours, base)) return {
+		value: theirs,
+		conflict: false
+	};
+	if (same(theirs, base)) return {
+		value: ours,
+		conflict: false
+	};
+	return {
+		value: ours,
+		conflict: true
+	};
+}
+/** What a thing of a list is called in what is said: its kind and its id, and its name or type where it has one */
+function nameOf(list, entry, id) {
+	return `${list === "objects" ? "object" : list.replace(/s$/, "")} ${id}${typeof entry?.name === "string" ? ` "${entry.name}"` : typeof entry?.type === "string" ? ` (${entry.type})` : ""}`;
+}
+/** Merges two lists of things by their ids: each thing chosen as a value of its own, in the order of their ids */
+function mergeList(list, base, ours, theirs, conflicts) {
+	const byId = (entries) => new Map(entries.map((entry) => [entry.id, entry]));
+	const [b, o, t] = [
+		byId(base),
+		byId(ours),
+		byId(theirs)
+	];
+	const ids = [.../* @__PURE__ */ new Set([
+		...b.keys(),
+		...o.keys(),
+		...t.keys()
+	])].sort((x, y) => x - y);
+	const merged = [];
+	for (const id of ids) {
+		const chosen = pick(b.get(id), o.get(id), t.get(id));
+		if (chosen.conflict) {
+			const what = nameOf(list, o.get(id) ?? t.get(id), id);
+			conflicts.push(o.has(id) && t.has(id) ? `${what} was changed on both sides: ours is kept` : `${what} was changed on one side and taken out on the other: ours is kept`);
+		}
+		if (chosen.value !== void 0) merged.push(chosen.value);
+	}
+	return merged;
+}
+/** Whether a value is a list of things with ids: what of a map's look is merged thing by thing (its lights, effects, decals) */
+var listOfIds = (value) => Array.isArray(value) && value.every((entry) => !!entry && typeof entry === "object" && typeof entry.id === "number");
+/**
+* Merges what a map looks like (`GameMap.environment`, the client's to read) part by part: a list of things with ids
+* (its lights, effects, decals, sounds) thing by thing, as the map's own lists are, and each other part as a value
+*/
+function mergeEnvironment(base, ours, theirs, conflicts) {
+	const plain = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+	if (![
+		base,
+		ours,
+		theirs
+	].every((value) => value === void 0 || plain(value))) return pick(base, ours, theirs);
+	const [b, o, t] = [
+		base,
+		ours,
+		theirs
+	].map((value) => value ?? {});
+	const merged = {};
+	for (const key of /* @__PURE__ */ new Set([
+		...Object.keys(b),
+		...Object.keys(o),
+		...Object.keys(t)
+	])) {
+		if ([
+			b[key],
+			o[key],
+			t[key]
+		].every((value) => value === void 0 || listOfIds(value))) {
+			const list = mergeList(key, b[key] ?? [], o[key] ?? [], t[key] ?? [], conflicts);
+			if (list.length || o[key] !== void 0) merged[key] = list;
+			continue;
+		}
+		const chosen = pick(b[key], o[key], t[key]);
+		if (chosen.conflict) conflicts.push(`the map's look's ${key} was changed on both sides: ours is kept`);
+		if (chosen.value !== void 0) merged[key] = chosen.value;
+	}
+	return {
+		value: Object.keys(merged).length || ours !== void 0 ? merged : void 0,
+		conflict: false
+	};
+}
+/**
+* Merges two versions of a map from the one they came from: parts and things by their ids (those of its look too: its
+* lights, effects, decals), the ground cell by cell. Never throws for what both changed: ours is kept there, and said
+* (`conflicts`). Maps of different sizes are not merged (ours, and said)
+*
+* @beta
+*/
+function mergeMaps(base, ours, theirs) {
+	const conflicts = [];
+	if (ours.width !== theirs.width || ours.depth !== theirs.depth || base.width !== ours.width || base.depth !== ours.depth) return {
+		map: ours,
+		conflicts: ["the size of the map changed: ours is kept whole"]
+	};
+	const [b, o, t] = [
+		base,
+		ours,
+		theirs
+	].map((map) => serializeMap(map));
+	const merged = { ...o };
+	const keys = /* @__PURE__ */ new Set([
+		...Object.keys(b),
+		...Object.keys(o),
+		...Object.keys(t)
+	]);
+	for (const key of keys) {
+		if (key === "format" || LAYERS.includes(key)) continue;
+		if (BY_ID.has(key) && [
+			b[key] ?? [],
+			o[key] ?? [],
+			t[key] ?? []
+		].every(Array.isArray)) {
+			const list = mergeList(key, b[key] ?? [], o[key] ?? [], t[key] ?? [], conflicts);
+			if (list.length || o[key] !== void 0) merged[key] = list;
+			else delete merged[key];
+			continue;
+		}
+		const chosen = key === "environment" ? mergeEnvironment(b[key], o[key], t[key], conflicts) : pick(b[key], o[key], t[key]);
+		if (chosen.conflict) conflicts.push(`the map's ${key} was changed on both sides: ours is kept`);
+		if (chosen.value === void 0) delete merged[key];
+		else merged[key] = chosen.value;
+	}
+	const map = parseMap(merged);
+	const paintable = same(o.tileset, t.tileset) && same(b.tileset, o.tileset);
+	for (const layer of LAYERS) {
+		if (layer === "tiles" && !paintable) {
+			if (!same(Array.from(ours.tiles), Array.from(theirs.tiles))) conflicts.push("the paint was changed on both sides with different tiles: ours is kept");
+			map.tiles = ours.tiles.slice();
+			continue;
+		}
+		const [from, mine, yours] = [
+			base[layer],
+			ours[layer],
+			theirs[layer]
+		];
+		const into = mine.slice();
+		let both = 0;
+		for (let i = 0; i < into.length; i++) {
+			if (mine[i] === yours[i]) continue;
+			if (mine[i] === from[i]) into[i] = yours[i];
+			else if (yours[i] !== from[i]) both++;
+		}
+		if (both) conflicts.push(`${both} ${layer === "ground" ? "corners of the ground" : `cells of the ${layer === "tiles" ? "paint" : layer}`} were changed on both sides: ours is kept there`);
+		map[layer] = into;
+	}
+	return {
+		map,
+		conflicts
+	};
+}
+//#endregion
+export { mergeMaps };
+
+//# sourceMappingURL=mapMerge.js.map

package/dist/mapMerge.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapMerge.js","names":["ID_LISTS"],"sources":["../src/mapMerge.ts"],"sourcesContent":["import { type GameMap, parseMap, serializeMap } from './map'\nimport { BY_ID as ID_LISTS, LAYERS } from './map/schema'\n\n/*\n * Map files that merge (S26). Git merges a map file line by line, which goes a long way since format 3 (an object to a\n * line, a row of the ground to a line): what it cannot, two changes to the same row or the same object, comes here,\n * as the three files git gives a merge driver (what both came from, ours, theirs). What only one side changed is\n * taken; what both changed alike is taken once; what both changed otherwise is ours, and said, for a person to see to.\n */\n\n/**\n * A merge of two versions of a map from the one they came from\n *\n * @beta\n */\nexport interface MapMerge {\n\t/** The map the two versions were merged into */\n\tmap: GameMap\n\t/** What both sides changed otherwise, in words: ours was kept for each */\n\tconflicts: string[]\n}\n\n/** The parts of a map file that are lists of things with ids, merged thing by thing: the map's table says (`MAP_FIELDS`) */\nconst BY_ID = new Set(ID_LISTS)\n\n/** What they are as text, to be compared: the same value, the same text */\nconst same = (a: unknown, b: unknown) => JSON.stringify(a) === JSON.stringify(b)\n\n/**\n * The three-way choice of one value: what only one side changed is that side's; both alike, either; both otherwise,\n * ours, and a conflict. `undefined` is a value too: a part one side took out\n */\nfunction pick<T>(base: T, ours: T, theirs: T): { value: T; conflict: boolean } {\n\tif (same(ours, theirs)) return { value: ours, conflict: false }\n\tif (same(ours, base)) return { value: theirs, conflict: false }\n\tif (same(theirs, base)) return { value: ours, conflict: false }\n\treturn { value: ours, conflict: true }\n}\n\n/** What a thing of a list is called in what is said: its kind and its id, and its name or type where it has one */\nfunction nameOf(list: string, entry: { id: number; name?: unknown; type?: unknown } | undefined, id: number): string {\n\tconst kind = list === 'objects' ? 'object' : list.replace(/s$/, '')\n\tconst called = typeof entry?.name === 'string' ? ` \"${entry.name}\"` : typeof entry?.type === 'string' ? ` (${entry.type})` : ''\n\treturn `${kind} ${id}${called}`\n}\n\n/** Merges two lists of things by their ids: each thing chosen as a value of its own, in the order of their ids */\nfunction mergeList(list: string, base: unknown[], ours: unknown[], theirs: unknown[], conflicts: string[]): unknown[] {\n\tconst byId = (entries: unknown[]) => new Map(entries.map((entry) => [(entry as { id: number }).id, entry]))\n\tconst [b, o, t] = [byId(base), byId(ours), byId(theirs)]\n\tconst ids = [...new Set([...b.keys(), ...o.keys(), ...t.keys()])].sort((x, y) => x - y)\n\tconst merged: unknown[] = []\n\tfor (const id of ids) {\n\t\tconst chosen = pick(b.get(id), o.get(id), t.get(id))\n\t\tif (chosen.conflict) {\n\t\t\tconst what = nameOf(list, (o.get(id) ?? t.get(id)) as { id: number }, id)\n\t\t\tconflicts.push(\n\t\t\t\to.has(id) && t.has(id)\n\t\t\t\t\t? `${what} was changed on both sides: ours is kept`\n\t\t\t\t\t: `${what} was changed on one side and taken out on the other: ours is kept`\n\t\t\t)\n\t\t}\n\t\tif (chosen.value !== undefined) merged.push(chosen.value)\n\t}\n\treturn merged\n}\n\n/** Whether a value is a list of things with ids: what of a map's look is merged thing by thing (its lights, effects, decals) */\nconst listOfIds = (value: unknown): value is { id: number }[] =>\n\tArray.isArray(value) && value.every((entry) => !!entry && typeof entry === 'object' && typeof (entry as { id?: unknown }).id === 'number')\n\n/**\n * Merges what a map looks like (`GameMap.environment`, the client's to read) part by part: a list of things with ids\n * (its lights, effects, decals, sounds) thing by thing, as the map's own lists are, and each other part as a value\n */\nfunction mergeEnvironment(base: unknown, ours: unknown, theirs: unknown, conflicts: string[]): { value: unknown; conflict: boolean } {\n\tconst plain = (value: unknown): value is Record<string, unknown> => !!value && typeof value === 'object' && !Array.isArray(value)\n\tif (![base, ours, theirs].every((value) => value === undefined || plain(value))) return pick(base, ours, theirs)\n\tconst [b, o, t] = [base, ours, theirs].map((value) => (value ?? {}) as Record<string, unknown>)\n\tconst merged: Record<string, unknown> = {}\n\tfor (const key of new Set([...Object.keys(b), ...Object.keys(o), ...Object.keys(t)])) {\n\t\tif ([b[key], o[key], t[key]].every((value) => value === undefined || listOfIds(value))) {\n\t\t\tconst list = mergeList(key, (b[key] ?? []) as unknown[], (o[key] ?? []) as unknown[], (t[key] ?? []) as unknown[], conflicts)\n\t\t\tif (list.length || o[key] !== undefined) merged[key] = list\n\t\t\tcontinue\n\t\t}\n\t\tconst chosen = pick(b[key], o[key], t[key])\n\t\tif (chosen.conflict) conflicts.push(`the map's look's ${key} was changed on both sides: ours is kept`)\n\t\tif (chosen.value !== undefined) merged[key] = chosen.value\n\t}\n\treturn { value: Object.keys(merged).length || ours !== undefined ? merged : undefined, conflict: false }\n}\n\n/**\n * Merges two versions of a map from the one they came from: parts and things by their ids (those of its look too: its\n * lights, effects, decals), the ground cell by cell. Never throws for what both changed: ours is kept there, and said\n * (`conflicts`). Maps of different sizes are not merged (ours, and said)\n *\n * @beta\n */\nexport function mergeMaps(base: GameMap, ours: GameMap, theirs: GameMap): MapMerge {\n\tconst conflicts: string[] = []\n\tif (ours.width !== theirs.width || ours.depth !== theirs.depth || base.width !== ours.width || base.depth !== ours.depth) {\n\t\treturn { map: ours, conflicts: ['the size of the map changed: ours is kept whole'] }\n\t}\n\tconst [b, o, t] = [base, ours, theirs].map((map) => serializeMap(map) as unknown as Record<string, unknown>)\n\tconst merged: Record<string, unknown> = { ...o }\n\tconst keys = new Set([...Object.keys(b), ...Object.keys(o), ...Object.keys(t)])\n\tfor (const key of keys) {\n\t\tif (key === 'format' || (LAYERS as readonly string[]).includes(key)) continue\n\t\tif (BY_ID.has(key) && [b[key] ?? [], o[key] ?? [], t[key] ?? []].every(Array.isArray)) {\n\t\t\tconst list = mergeList(key, (b[key] ?? []) as unknown[], (o[key] ?? []) as unknown[], (t[key] ?? []) as unknown[], conflicts)\n\t\t\tif (list.length || o[key] !== undefined) merged[key] = list\n\t\t\telse delete merged[key]\n\t\t\tcontinue\n\t\t}\n\t\tconst chosen = key === 'environment' ? mergeEnvironment(b[key], o[key], t[key], conflicts) : pick(b[key], o[key], t[key])\n\t\tif (chosen.conflict) conflicts.push(`the map's ${key} was changed on both sides: ours is kept`)\n\t\tif (chosen.value === undefined) delete merged[key]\n\t\telse merged[key] = chosen.value\n\t}\n\tconst map = parseMap(merged)\n\t// the paint by cell only where both name their tiles alike: an index means another tile otherwise\n\tconst paintable = same(o.tileset, t.tileset) && same(b.tileset, o.tileset)\n\tfor (const layer of LAYERS) {\n\t\tif (layer === 'tiles' && !paintable) {\n\t\t\tif (!same(Array.from(ours.tiles), Array.from(theirs.tiles)))\n\t\t\t\tconflicts.push('the paint was changed on both sides with different tiles: ours is kept')\n\t\t\tmap.tiles = ours.tiles.slice()\n\t\t\tcontinue\n\t\t}\n\t\tconst [from, mine, yours] = [base[layer], ours[layer], theirs[layer]]\n\t\tconst into = mine.slice()\n\t\tlet both = 0\n\t\tfor (let i = 0; i < into.length; i++) {\n\t\t\tif (mine[i] === yours[i]) continue\n\t\t\tif (mine[i] === from[i]) into[i] = yours[i]\n\t\t\telse if (yours[i] !== from[i]) both++\n\t\t}\n\t\tif (both)\n\t\t\tconflicts.push(\n\t\t\t\t`${both} ${layer === 'ground' ? 'corners of the ground' : `cells of the ${layer === 'tiles' ? 'paint' : layer}`} were changed on both sides: ours is kept there`\n\t\t\t)\n\t\t;(map as unknown as Record<string, unknown>)[layer] = into\n\t}\n\treturn { map, conflicts }\n}\n"],"mappings":";;;;AAuBA,IAAM,QAAQ,IAAI,IAAIA,OAAQ;;AAG9B,IAAM,QAAQ,GAAY,MAAe,KAAK,UAAU,CAAC,MAAM,KAAK,UAAU,CAAC;;;;;AAM/E,SAAS,KAAQ,MAAS,MAAS,QAA4C;CAC9E,IAAI,KAAK,MAAM,MAAM,GAAG,OAAO;EAAE,OAAO;EAAM,UAAU;CAAM;CAC9D,IAAI,KAAK,MAAM,IAAI,GAAG,OAAO;EAAE,OAAO;EAAQ,UAAU;CAAM;CAC9D,IAAI,KAAK,QAAQ,IAAI,GAAG,OAAO;EAAE,OAAO;EAAM,UAAU;CAAM;CAC9D,OAAO;EAAE,OAAO;EAAM,UAAU;CAAK;AACtC;;AAGA,SAAS,OAAO,MAAc,OAAmE,IAAoB;CAGpH,OAAO,GAFM,SAAS,YAAY,WAAW,KAAK,QAAQ,MAAM,EAAE,EAEnD,GAAG,KADH,OAAO,OAAO,SAAS,WAAW,KAAK,MAAM,KAAK,KAAK,OAAO,OAAO,SAAS,WAAW,KAAK,MAAM,KAAK,KAAK;AAE9H;;AAGA,SAAS,UAAU,MAAc,MAAiB,MAAiB,QAAmB,WAAgC;CACrH,MAAM,QAAQ,YAAuB,IAAI,IAAI,QAAQ,KAAK,UAAU,CAAE,MAAyB,IAAI,KAAK,CAAC,CAAC;CAC1G,MAAM,CAAC,GAAG,GAAG,KAAK;EAAC,KAAK,IAAI;EAAG,KAAK,IAAI;EAAG,KAAK,MAAM;CAAC;CACvD,MAAM,MAAM,CAAC,mBAAG,IAAI,IAAI;EAAC,GAAG,EAAE,KAAK;EAAG,GAAG,EAAE,KAAK;EAAG,GAAG,EAAE,KAAK;CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,GAAG,MAAM,IAAI,CAAC;CACtF,MAAM,SAAoB,CAAC;CAC3B,KAAK,MAAM,MAAM,KAAK;EACrB,MAAM,SAAS,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,EAAE,CAAC;EACnD,IAAI,OAAO,UAAU;GACpB,MAAM,OAAO,OAAO,MAAO,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,GAAsB,EAAE;GACxE,UAAU,KACT,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,IAClB,GAAG,KAAK,4CACR,GAAG,KAAK,kEACZ;EACD;EACA,IAAI,OAAO,UAAU,KAAA,GAAW,OAAO,KAAK,OAAO,KAAK;CACzD;CACA,OAAO;AACR;;AAGA,IAAM,aAAa,UAClB,MAAM,QAAQ,KAAK,KAAK,MAAM,OAAO,UAAU,CAAC,CAAC,SAAS,OAAO,UAAU,YAAY,OAAQ,MAA2B,OAAO,QAAQ;;;;;AAM1I,SAAS,iBAAiB,MAAe,MAAe,QAAiB,WAA4D;CACpI,MAAM,SAAS,UAAqD,CAAC,CAAC,SAAS,OAAO,UAAU,YAAY,CAAC,MAAM,QAAQ,KAAK;CAChI,IAAI,CAAC;EAAC;EAAM;EAAM;CAAM,CAAC,CAAC,OAAO,UAAU,UAAU,KAAA,KAAa,MAAM,KAAK,CAAC,GAAG,OAAO,KAAK,MAAM,MAAM,MAAM;CAC/G,MAAM,CAAC,GAAG,GAAG,KAAK;EAAC;EAAM;EAAM;CAAM,CAAC,CAAC,KAAK,UAAW,SAAS,CAAC,CAA6B;CAC9F,MAAM,SAAkC,CAAC;CACzC,KAAK,MAAM,uBAAO,IAAI,IAAI;EAAC,GAAG,OAAO,KAAK,CAAC;EAAG,GAAG,OAAO,KAAK,CAAC;EAAG,GAAG,OAAO,KAAK,CAAC;CAAC,CAAC,GAAG;EACrF,IAAI;GAAC,EAAE;GAAM,EAAE;GAAM,EAAE;EAAI,CAAC,CAAC,OAAO,UAAU,UAAU,KAAA,KAAa,UAAU,KAAK,CAAC,GAAG;GACvF,MAAM,OAAO,UAAU,KAAM,EAAE,QAAQ,CAAC,GAAkB,EAAE,QAAQ,CAAC,GAAkB,EAAE,QAAQ,CAAC,GAAiB,SAAS;GAC5H,IAAI,KAAK,UAAU,EAAE,SAAS,KAAA,GAAW,OAAO,OAAO;GACvD;EACD;EACA,MAAM,SAAS,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI;EAC1C,IAAI,OAAO,UAAU,UAAU,KAAK,oBAAoB,IAAI,yCAAyC;EACrG,IAAI,OAAO,UAAU,KAAA,GAAW,OAAO,OAAO,OAAO;CACtD;CACA,OAAO;EAAE,OAAO,OAAO,KAAK,MAAM,CAAC,CAAC,UAAU,SAAS,KAAA,IAAY,SAAS,KAAA;EAAW,UAAU;CAAM;AACxG;;;;;;;;AASA,SAAgB,UAAU,MAAe,MAAe,QAA2B;CAClF,MAAM,YAAsB,CAAC;CAC7B,IAAI,KAAK,UAAU,OAAO,SAAS,KAAK,UAAU,OAAO,SAAS,KAAK,UAAU,KAAK,SAAS,KAAK,UAAU,KAAK,OAClH,OAAO;EAAE,KAAK;EAAM,WAAW,CAAC,iDAAiD;CAAE;CAEpF,MAAM,CAAC,GAAG,GAAG,KAAK;EAAC;EAAM;EAAM;CAAM,CAAC,CAAC,KAAK,QAAQ,aAAa,GAAG,CAAuC;CAC3G,MAAM,SAAkC,EAAE,GAAG,EAAE;CAC/C,MAAM,uBAAO,IAAI,IAAI;EAAC,GAAG,OAAO,KAAK,CAAC;EAAG,GAAG,OAAO,KAAK,CAAC;EAAG,GAAG,OAAO,KAAK,CAAC;CAAC,CAAC;CAC9E,KAAK,MAAM,OAAO,MAAM;EACvB,IAAI,QAAQ,YAAa,OAA6B,SAAS,GAAG,GAAG;EACrE,IAAI,MAAM,IAAI,GAAG,KAAK;GAAC,EAAE,QAAQ,CAAC;GAAG,EAAE,QAAQ,CAAC;GAAG,EAAE,QAAQ,CAAC;EAAC,CAAC,CAAC,MAAM,MAAM,OAAO,GAAG;GACtF,MAAM,OAAO,UAAU,KAAM,EAAE,QAAQ,CAAC,GAAkB,EAAE,QAAQ,CAAC,GAAkB,EAAE,QAAQ,CAAC,GAAiB,SAAS;GAC5H,IAAI,KAAK,UAAU,EAAE,SAAS,KAAA,GAAW,OAAO,OAAO;QAClD,OAAO,OAAO;GACnB;EACD;EACA,MAAM,SAAS,QAAQ,gBAAgB,iBAAiB,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,SAAS,IAAI,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI;EACxH,IAAI,OAAO,UAAU,UAAU,KAAK,aAAa,IAAI,yCAAyC;EAC9F,IAAI,OAAO,UAAU,KAAA,GAAW,OAAO,OAAO;OACzC,OAAO,OAAO,OAAO;CAC3B;CACA,MAAM,MAAM,SAAS,MAAM;CAE3B,MAAM,YAAY,KAAK,EAAE,SAAS,EAAE,OAAO,KAAK,KAAK,EAAE,SAAS,EAAE,OAAO;CACzE,KAAK,MAAM,SAAS,QAAQ;EAC3B,IAAI,UAAU,WAAW,CAAC,WAAW;GACpC,IAAI,CAAC,KAAK,MAAM,KAAK,KAAK,KAAK,GAAG,MAAM,KAAK,OAAO,KAAK,CAAC,GACzD,UAAU,KAAK,wEAAwE;GACxF,IAAI,QAAQ,KAAK,MAAM,MAAM;GAC7B;EACD;EACA,MAAM,CAAC,MAAM,MAAM,SAAS;GAAC,KAAK;GAAQ,KAAK;GAAQ,OAAO;EAAM;EACpE,MAAM,OAAO,KAAK,MAAM;EACxB,IAAI,OAAO;EACX,KAAK,IAAI,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;GACrC,IAAI,KAAK,OAAO,MAAM,IAAI;GAC1B,IAAI,KAAK,OAAO,KAAK,IAAI,KAAK,KAAK,MAAM;QACpC,IAAI,MAAM,OAAO,KAAK,IAAI;EAChC;EACA,IAAI,MACH,UAAU,KACT,GAAG,KAAK,GAAG,UAAU,WAAW,0BAA0B,gBAAgB,UAAU,UAAU,UAAU,QAAQ,gDACjH;EACA,IAA4C,SAAS;CACvD;CACA,OAAO;EAAE;EAAK;CAAU;AACzB"}

package/dist/mapObjectives.js

@@ -0,0 +1,138 @@
+import { defineHook } from "./hooks.js";
+//#region src/mapObjectives.ts
+/**
+* The map objectives pack's id
+*
+* @beta
+*/
+var MAP_OBJECTIVES = "core.mapObjectives";
+/**
+* The key of the map's data its objectives are kept under (`GameMap.data.objectives`)
+*
+* @beta
+*/
+var MAP_OBJECTIVES_KEY = "objectives";
+/** The words of an objective as a file may hold them: a key, or a key with params */
+var isWords = (text) => typeof text === "string" ? text.trim() !== "" : typeof text === "object" && text !== null && typeof text.key === "string" && text.key !== "";
+/**
+* The objectives a map gives (`GameMap.data.objectives`), in the order it gives them: none for a map with none. What is
+* kept there and is no objective (no id, no words) is left out, so that a file changed by hand breaks no rule that reads
+* it; the map's checks say so (`mapObjectives`)
+*
+* @beta
+*/
+function mapObjectivesOf(map) {
+	const kept = map.data[MAP_OBJECTIVES_KEY];
+	if (!Array.isArray(kept)) return [];
+	return kept.filter((each) => typeof each === "object" && each !== null && typeof each.id === "string" && each.id !== "" && isWords(each.text)).map((each) => ({
+		id: each.id,
+		text: each.text,
+		...each.detail !== void 0 && isWords(each.detail) && { detail: each.detail },
+		...each.required !== void 0 && { required: each.required !== false },
+		at: each.at === "rule" ? "rule" : "start"
+	}));
+}
+/**
+* Who is given a map's objective when the rules do not say (`giveMapObjective`): the map's players a person plays, not
+* those it says the computer plays or nobody does (`MapPlayer.controller`), in the order of their ids
+*
+* @beta
+*/
+function mapObjectivePlayers(world) {
+	return [...world.players.values()].filter((player) => !player.neutral && !player.creeps).filter((player) => {
+		const controller = world.map.player(player.id)?.controller;
+		return controller !== "computer" && controller !== "nobody";
+	}).map((player) => player.id).sort((a, b) => a - b);
+}
+/**
+* Gives players an objective of the map's, by its id (`MapObjective`): those given by a rule (`at: 'rule'`), when the
+* rules say. To every player a person plays when `players` is left out (`mapObjectivePlayers`); a player who has it
+* already keeps theirs. Its words' params and its progress go with it, as `world.objectives.add`. Throws for an id the
+* map does not have: an id in the code that is not on the map is a mistake
+*
+* @beta
+*/
+function giveMapObjective(world, id, options = {}) {
+	const def = mapObjectivesOf(world.map).find((objective) => objective.id === id);
+	if (!def) throw new Error(`The map${world.map.name ? ` "${world.map.name}"` : ""} has no objective "${id}"`);
+	const { at: _at, ...objective } = def;
+	const given = [];
+	for (const player of options.players ?? mapObjectivePlayers(world)) {
+		if (world.objectives.has(player, id)) continue;
+		given.push(world.objectives.add(player, objective, {
+			params: options.params,
+			progress: options.progress
+		}));
+	}
+	return given;
+}
+/**
+* What is wrong with a map's objectives (`GameMap.data.objectives`): one with no id or with another's, one with no
+* words, a list that is not one. Each a click away in the Objectives panel
+*
+* @beta
+*/
+function checkMapObjectives(map) {
+	const kept = map.data[MAP_OBJECTIVES_KEY];
+	if (kept === void 0) return [];
+	if (!Array.isArray(kept)) return [{
+		message: "The map’s objectives are not a list",
+		error: true,
+		rule: "objectives"
+	}];
+	const problems = [];
+	const seen = /* @__PURE__ */ new Set();
+	kept.forEach((each, index) => {
+		const id = typeof each?.id === "string" ? each.id : "";
+		const reveal = {
+			panel: "objectives",
+			entry: id || String(index)
+		};
+		if (!id) problems.push({
+			message: `Objective ${index + 1} has no id`,
+			error: true,
+			rule: "objective-id",
+			reveal
+		});
+		else if (seen.has(id)) problems.push({
+			message: `Two objectives have the id "${id}"`,
+			error: true,
+			rule: "objective-id",
+			reveal
+		});
+		seen.add(id);
+		if (!isWords(each?.text)) problems.push({
+			message: `The objective "${id || index + 1}" has no words`,
+			error: true,
+			rule: "objective-text",
+			reveal
+		});
+	});
+	return problems;
+}
+/**
+* Objectives as data on the map (campaign plan EQ3): a map's objectives (`MapObjective`, kept in `GameMap.data.objectives`,
+* written by the editor's Objectives panel) given at the start to every player a person plays, as the world is made
+* from the map; those given by a rule wait for the rules (`giveMapObjective(world, id)`). Done and failed as any
+* objective is (`world.objectives.complete`, `fail`); a game that is won by them has `objectiveVictory` as its
+* `victory`. The map's checks say what is wrong with them (`checkMapObjectives`)
+*
+* @beta
+*/
+function mapObjectives() {
+	return {
+		id: MAP_OBJECTIVES,
+		hooks: [defineHook({
+			hook: "mapStart",
+			id: MAP_OBJECTIVES,
+			run(world) {
+				for (const objective of mapObjectivesOf(world.map)) if (objective.at === "start") giveMapObjective(world, objective.id);
+			}
+		})],
+		check: (map) => checkMapObjectives(map)
+	};
+}
+//#endregion
+export { MAP_OBJECTIVES, MAP_OBJECTIVES_KEY, checkMapObjectives, giveMapObjective, mapObjectivePlayers, mapObjectives, mapObjectivesOf };
+
+//# sourceMappingURL=mapObjectives.js.map