@v12-engine/engine 0.1.1 → 0.4.0

package/dist/mapCheck/rules/objects.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"objects.js","names":[],"sources":["../../../src/mapCheck/rules/objects.ts"],"sourcesContent":["import { WATER_DEEP } from '../../terrain'\nimport type { MapRule } from '../rule'\n\n/** What is placed and the camps: of types the game has, on the map, out of deep water (but what sails, or flies) */\nexport const objectRules: MapRule = {\n\tid: 'objects',\n\tcheck(map, registry, say, { terrain, onMap }) {\n\t\tfor (const object of map.objects) {\n\t\t\tif (!registry.units.has(object.type)) {\n\t\t\t\tsay({\n\t\t\t\t\tmessage: `\"${object.type}\" is no unit type of the game: it is left out`,\n\t\t\t\t\tat: object,\n\t\t\t\t\trule: 'unknown-type',\n\t\t\t\t\tabout: { object: object.id }\n\t\t\t\t})\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\tif (!onMap(object)) {\n\t\t\t\tsay({\n\t\t\t\t\tmessage: `${registry.unit(object.type).name} stands off the map`,\n\t\t\t\t\terror: true,\n\t\t\t\t\tat: object,\n\t\t\t\t\trule: 'off-map',\n\t\t\t\t\tabout: { object: object.id }\n\t\t\t\t})\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\tconst def = registry.unit(object.type)\n\t\t\t// what flies is over it and what sails is on it: only what walks is wrong there\n\t\t\tif (!def.flying && !def.naval && terrain.waterAt(object.x, object.z) === WATER_DEEP)\n\t\t\t\tsay({ message: `${def.name} stands in deep water`, at: object, rule: 'deep-water', about: { object: object.id } })\n\t\t}\n\t\tfor (const camp of map.camps) {\n\t\t\tconst strangers = camp.units.filter((type) => !type.startsWith('@') && !registry.units.has(type))\n\t\t\tif (strangers.length)\n\t\t\t\tsay({\n\t\t\t\t\tmessage: `A camp has creeps the game does not have: ${strangers.join(', ')}`,\n\t\t\t\t\tat: camp,\n\t\t\t\t\trule: 'unknown-creeps',\n\t\t\t\t\tabout: { camp: camp.id }\n\t\t\t\t})\n\t\t\tif (!onMap(camp)) say({ message: 'A camp stands off the map', error: true, at: camp, rule: 'off-map', about: { camp: camp.id } })\n\t\t}\n\t}\n}\n"],"mappings":";;;AAIA,IAAa,cAAuB;CACnC,IAAI;CACJ,MAAM,KAAK,UAAU,KAAK,EAAE,SAAS,SAAS;EAC7C,KAAK,MAAM,UAAU,IAAI,SAAS;GACjC,IAAI,CAAC,SAAS,MAAM,IAAI,OAAO,IAAI,GAAG;IACrC,IAAI;KACH,SAAS,IAAI,OAAO,KAAK;KACzB,IAAI;KACJ,MAAM;KACN,OAAO,EAAE,QAAQ,OAAO,GAAG;IAC5B,CAAC;IACD;GACD;GACA,IAAI,CAAC,MAAM,MAAM,GAAG;IACnB,IAAI;KACH,SAAS,GAAG,SAAS,KAAK,OAAO,IAAI,CAAC,CAAC,KAAK;KAC5C,OAAO;KACP,IAAI;KACJ,MAAM;KACN,OAAO,EAAE,QAAQ,OAAO,GAAG;IAC5B,CAAC;IACD;GACD;GACA,MAAM,MAAM,SAAS,KAAK,OAAO,IAAI;GAErC,IAAI,CAAC,IAAI,UAAU,CAAC,IAAI,SAAS,QAAQ,QAAQ,OAAO,GAAG,OAAO,CAAC,MAAA,GAClE,IAAI;IAAE,SAAS,GAAG,IAAI,KAAK;IAAwB,IAAI;IAAQ,MAAM;IAAc,OAAO,EAAE,QAAQ,OAAO,GAAG;GAAE,CAAC;EACnH;EACA,KAAK,MAAM,QAAQ,IAAI,OAAO;GAC7B,MAAM,YAAY,KAAK,MAAM,QAAQ,SAAS,CAAC,KAAK,WAAW,GAAG,KAAK,CAAC,SAAS,MAAM,IAAI,IAAI,CAAC;GAChG,IAAI,UAAU,QACb,IAAI;IACH,SAAS,6CAA6C,UAAU,KAAK,IAAI;IACzE,IAAI;IACJ,MAAM;IACN,OAAO,EAAE,MAAM,KAAK,GAAG;GACxB,CAAC;GACF,IAAI,CAAC,MAAM,IAAI,GAAG,IAAI;IAAE,SAAS;IAA6B,OAAO;IAAM,IAAI;IAAM,MAAM;IAAW,OAAO,EAAE,MAAM,KAAK,GAAG;GAAE,CAAC;EACjI;CACD;AACD"}

package/dist/mapCheck/rules/paths.js

@@ -0,0 +1,32 @@
+//#region src/mapCheck/rules/paths.ts
+/** Paths on the map: on it, and what they paint and carve there to be had */
+var pathRules = {
+	id: "paths",
+	check(map, registry, say, { onMap }) {
+		for (const path of map.paths) {
+			const about = { path: path.id };
+			if (path.points.some((point) => !onMap(point))) say({
+				message: `The path ${path.name} goes off the map`,
+				at: path.points[0],
+				rule: "path-off-map",
+				about
+			});
+			for (const tile of [path.paint, path.profile?.ground]) if (tile !== void 0 && !map.tileset.includes(tile) && !registry.tiles.some((def) => def.id === tile)) say({
+				message: `The path ${path.name} paints with ${tile}, which neither the map's tiles nor the game's are`,
+				at: path.points[0],
+				rule: "path-tile-missing",
+				about
+			});
+			if (path.profile && path.points.length < 2) say({
+				message: `The path ${path.name} carves its bed with one point: it carves nothing until it has two`,
+				at: path.points[0],
+				rule: "path-profile-short",
+				about
+			});
+		}
+	}
+};
+//#endregion
+export { pathRules };
+
+//# sourceMappingURL=paths.js.map

package/dist/mapCheck/rules/paths.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.js","names":[],"sources":["../../../src/mapCheck/rules/paths.ts"],"sourcesContent":["import type { MapRule } from '../rule'\n\n/** Paths on the map: on it, and what they paint and carve there to be had */\nexport const pathRules: MapRule = {\n\tid: 'paths',\n\tcheck(map, registry, say, { onMap }) {\n\t\tfor (const path of map.paths) {\n\t\t\tconst about = { path: path.id }\n\t\t\tif (path.points.some((point) => !onMap(point)))\n\t\t\t\tsay({ message: `The path ${path.name} goes off the map`, at: path.points[0], rule: 'path-off-map', about })\n\t\t\t// a tile neither the map's tileset nor the game has is painted nowhere\n\t\t\tfor (const tile of [path.paint, path.profile?.ground])\n\t\t\t\tif (tile !== undefined && !map.tileset.includes(tile) && !registry.tiles.some((def) => def.id === tile))\n\t\t\t\t\tsay({\n\t\t\t\t\t\tmessage: `The path ${path.name} paints with ${tile}, which neither the map's tiles nor the game's are`,\n\t\t\t\t\t\tat: path.points[0],\n\t\t\t\t\t\trule: 'path-tile-missing',\n\t\t\t\t\t\tabout\n\t\t\t\t\t})\n\t\t\tif (path.profile && path.points.length < 2)\n\t\t\t\tsay({\n\t\t\t\t\tmessage: `The path ${path.name} carves its bed with one point: it carves nothing until it has two`,\n\t\t\t\t\tat: path.points[0],\n\t\t\t\t\trule: 'path-profile-short',\n\t\t\t\t\tabout\n\t\t\t\t})\n\t\t}\n\t}\n}\n"],"mappings":";;AAGA,IAAa,YAAqB;CACjC,IAAI;CACJ,MAAM,KAAK,UAAU,KAAK,EAAE,SAAS;EACpC,KAAK,MAAM,QAAQ,IAAI,OAAO;GAC7B,MAAM,QAAQ,EAAE,MAAM,KAAK,GAAG;GAC9B,IAAI,KAAK,OAAO,MAAM,UAAU,CAAC,MAAM,KAAK,CAAC,GAC5C,IAAI;IAAE,SAAS,YAAY,KAAK,KAAK;IAAoB,IAAI,KAAK,OAAO;IAAI,MAAM;IAAgB;GAAM,CAAC;GAE3G,KAAK,MAAM,QAAQ,CAAC,KAAK,OAAO,KAAK,SAAS,MAAM,GACnD,IAAI,SAAS,KAAA,KAAa,CAAC,IAAI,QAAQ,SAAS,IAAI,KAAK,CAAC,SAAS,MAAM,MAAM,QAAQ,IAAI,OAAO,IAAI,GACrG,IAAI;IACH,SAAS,YAAY,KAAK,KAAK,eAAe,KAAK;IACnD,IAAI,KAAK,OAAO;IAChB,MAAM;IACN;GACD,CAAC;GACH,IAAI,KAAK,WAAW,KAAK,OAAO,SAAS,GACxC,IAAI;IACH,SAAS,YAAY,KAAK,KAAK;IAC/B,IAAI,KAAK,OAAO;IAChB,MAAM;IACN;GACD,CAAC;EACH;CACD;AACD"}

package/dist/mapCheck/rules/players.js

@@ -0,0 +1,20 @@
+import "../../map/types.js";
+import { maxPlayersOf } from "../../game.js";
+//#region src/mapCheck/rules/players.ts
+/** How many players the map has, against what the game allows */
+var playerRules = {
+	id: "players",
+	check(map, registry, say, _context) {
+		const players = map.players.filter((player) => player.id !== 90 && player.id !== 0).length;
+		const most = registry.module ? maxPlayersOf(registry.module) : 32;
+		if (players > most) say({
+			message: `The map has ${players} players, and the game allows ${most}`,
+			error: true,
+			rule: "too-many-players"
+		});
+	}
+};
+//#endregion
+export { playerRules };
+
+//# sourceMappingURL=players.js.map

package/dist/mapCheck/rules/players.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"players.js","names":[],"sources":["../../../src/mapCheck/rules/players.ts"],"sourcesContent":["import { maxPlayersOf } from '../../game'\nimport { MAP_CREEPS, MAP_NEUTRAL, MAX_MAP_PLAYERS } from '../../map'\nimport type { MapRule } from '../rule'\n\n/** How many players the map has, against what the game allows */\nexport const playerRules: MapRule = {\n\tid: 'players',\n\tcheck(map, registry, say, _context) {\n\t\tconst players = map.players.filter((player) => player.id !== MAP_CREEPS && player.id !== MAP_NEUTRAL).length\n\t\tconst most = registry.module ? maxPlayersOf(registry.module) : MAX_MAP_PLAYERS\n\t\tif (players > most) say({ message: `The map has ${players} players, and the game allows ${most}`, error: true, rule: 'too-many-players' })\n\t}\n}\n"],"mappings":";;;;AAKA,IAAa,cAAuB;CACnC,IAAI;CACJ,MAAM,KAAK,UAAU,KAAK,UAAU;EACnC,MAAM,UAAU,IAAI,QAAQ,QAAQ,WAAW,OAAO,OAAA,MAAqB,OAAO,OAAA,CAAkB,CAAC,CAAC;EACtG,MAAM,OAAO,SAAS,SAAS,aAAa,SAAS,MAAM,IAAA;EAC3D,IAAI,UAAU,MAAM,IAAI;GAAE,SAAS,eAAe,QAAQ,gCAAgC;GAAQ,OAAO;GAAM,MAAM;EAAmB,CAAC;CAC1I;AACD"}

package/dist/mapCheck/rules/races.js

@@ -0,0 +1,56 @@
+import { availableTo } from "../../shared.js";
+import "../../races.js";
+//#region src/mapCheck/rules/races.ts
+/**
+* What is wrong with the races of a map: a player fixed to a race the game has not got, or the map offering one, are
+* errors (a world is not made from it); what is placed for a player that their race may not have is a warning. What
+* the map offers is for the players it fixes no race for: one fixed to another is as the map means it
+*/
+function raceProblems(map, registry) {
+	const problems = [];
+	const known = (race) => race === "random" || registry.races.has(race);
+	const none = registry.races.size === 0;
+	for (const race of map.races ?? []) {
+		if (race === "random" || registry.races.has(race)) continue;
+		problems.push({
+			message: `The map offers the race "${race}", which ${none ? "the game does not have: it has no races" : "is no race of the game"}`,
+			error: true,
+			rule: "unknown-race"
+		});
+	}
+	for (const player of map.players) {
+		if (player.race === void 0) continue;
+		if (!known(player.race)) problems.push({
+			message: `${player.name} plays the race "${player.race}", which ${none ? "the game does not have: it has no races" : "is no race of the game"}`,
+			error: true,
+			at: player.start,
+			rule: "unknown-race",
+			about: { player: player.id }
+		});
+	}
+	const fixed = new Map(map.players.filter((player) => player.race && player.race !== "random" && registry.races.has(player.race)).map((player) => [player.id, player]));
+	for (const object of map.objects) {
+		const owner = fixed.get(object.owner);
+		if (!owner || !registry.units.has(object.type)) continue;
+		const def = registry.unit(object.type);
+		if (availableTo(def, owner.race)) continue;
+		problems.push({
+			message: `${def.name} is ${registry.race(def.race).name}, and ${owner.name} plays ${registry.race(owner.race).name}`,
+			at: object,
+			rule: "other-race",
+			about: { object: object.id }
+		});
+	}
+	return problems;
+}
+/** The races of the map, its players and what is placed for them */
+var raceRules = {
+	id: "races",
+	check(map, registry, say) {
+		for (const problem of raceProblems(map, registry)) say(problem);
+	}
+};
+//#endregion
+export { raceRules };
+
+//# sourceMappingURL=races.js.map

package/dist/mapCheck/rules/races.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"races.js","names":[],"sources":["../../../src/mapCheck/rules/races.ts"],"sourcesContent":["import type { GameMap } from '../../map'\nimport type { MapProblem } from '../../mapFields'\nimport { RANDOM_RACE } from '../../races'\nimport type { Registry } from '../../registry'\nimport { availableTo } from '../../shared'\nimport type { MapRule } from '../rule'\n\n/**\n * What is wrong with the races of a map: a player fixed to a race the game has not got, or the map offering one, are\n * errors (a world is not made from it); what is placed for a player that their race may not have is a warning. What\n * the map offers is for the players it fixes no race for: one fixed to another is as the map means it\n */\nfunction raceProblems(map: GameMap, registry: Registry): MapProblem[] {\n\tconst problems: MapProblem[] = []\n\tconst known = (race: string) => race === RANDOM_RACE || registry.races.has(race)\n\tconst none = registry.races.size === 0\n\tfor (const race of map.races ?? []) {\n\t\tif (race === RANDOM_RACE || registry.races.has(race)) continue\n\t\tproblems.push({\n\t\t\tmessage: `The map offers the race \"${race}\", which ${none ? 'the game does not have: it has no races' : 'is no race of the game'}`,\n\t\t\terror: true,\n\t\t\trule: 'unknown-race'\n\t\t})\n\t}\n\tfor (const player of map.players) {\n\t\tif (player.race === undefined) continue\n\t\tif (!known(player.race)) {\n\t\t\tproblems.push({\n\t\t\t\tmessage: `${player.name} plays the race \"${player.race}\", which ${none ? 'the game does not have: it has no races' : 'is no race of the game'}`,\n\t\t\t\terror: true,\n\t\t\t\tat: player.start,\n\t\t\t\trule: 'unknown-race',\n\t\t\t\tabout: { player: player.id }\n\t\t\t})\n\t\t}\n\t}\n\t// what a player whose race is fixed may not have: they could not make it, and it is theirs all the same\n\tconst fixed = new Map(\n\t\tmap.players.filter((player) => player.race && player.race !== RANDOM_RACE && registry.races.has(player.race)).map((player) => [player.id, player])\n\t)\n\tfor (const object of map.objects) {\n\t\tconst owner = fixed.get(object.owner)\n\t\tif (!owner || !registry.units.has(object.type)) continue\n\t\tconst def = registry.unit(object.type)\n\t\tif (availableTo(def, owner.race)) continue\n\t\tproblems.push({\n\t\t\tmessage: `${def.name} is ${registry.race(def.race!).name}, and ${owner.name} plays ${registry.race(owner.race!).name}`,\n\t\t\tat: object,\n\t\t\trule: 'other-race',\n\t\t\tabout: { object: object.id }\n\t\t})\n\t}\n\treturn problems\n}\n\n/** The races of the map, its players and what is placed for them */\nexport const raceRules: MapRule = {\n\tid: 'races',\n\tcheck(map, registry, say) {\n\t\tfor (const problem of raceProblems(map, registry)) say(problem)\n\t}\n}\n"],"mappings":";;;;;;;;AAYA,SAAS,aAAa,KAAc,UAAkC;CACrE,MAAM,WAAyB,CAAC;CAChC,MAAM,SAAS,SAAiB,SAAA,YAAwB,SAAS,MAAM,IAAI,IAAI;CAC/E,MAAM,OAAO,SAAS,MAAM,SAAS;CACrC,KAAK,MAAM,QAAQ,IAAI,SAAS,CAAC,GAAG;EACnC,IAAI,SAAA,YAAwB,SAAS,MAAM,IAAI,IAAI,GAAG;EACtD,SAAS,KAAK;GACb,SAAS,4BAA4B,KAAK,WAAW,OAAO,4CAA4C;GACxG,OAAO;GACP,MAAM;EACP,CAAC;CACF;CACA,KAAK,MAAM,UAAU,IAAI,SAAS;EACjC,IAAI,OAAO,SAAS,KAAA,GAAW;EAC/B,IAAI,CAAC,MAAM,OAAO,IAAI,GACrB,SAAS,KAAK;GACb,SAAS,GAAG,OAAO,KAAK,mBAAmB,OAAO,KAAK,WAAW,OAAO,4CAA4C;GACrH,OAAO;GACP,IAAI,OAAO;GACX,MAAM;GACN,OAAO,EAAE,QAAQ,OAAO,GAAG;EAC5B,CAAC;CAEH;CAEA,MAAM,QAAQ,IAAI,IACjB,IAAI,QAAQ,QAAQ,WAAW,OAAO,QAAQ,OAAO,SAAA,YAAwB,SAAS,MAAM,IAAI,OAAO,IAAI,CAAC,CAAC,CAAC,KAAK,WAAW,CAAC,OAAO,IAAI,MAAM,CAAC,CAClJ;CACA,KAAK,MAAM,UAAU,IAAI,SAAS;EACjC,MAAM,QAAQ,MAAM,IAAI,OAAO,KAAK;EACpC,IAAI,CAAC,SAAS,CAAC,SAAS,MAAM,IAAI,OAAO,IAAI,GAAG;EAChD,MAAM,MAAM,SAAS,KAAK,OAAO,IAAI;EACrC,IAAI,YAAY,KAAK,MAAM,IAAI,GAAG;EAClC,SAAS,KAAK;GACb,SAAS,GAAG,IAAI,KAAK,MAAM,SAAS,KAAK,IAAI,IAAK,CAAC,CAAC,KAAK,QAAQ,MAAM,KAAK,SAAS,SAAS,KAAK,MAAM,IAAK,CAAC,CAAC;GAChH,IAAI;GACJ,MAAM;GACN,OAAO,EAAE,QAAQ,OAAO,GAAG;EAC5B,CAAC;CACF;CACA,OAAO;AACR;;AAGA,IAAa,YAAqB;CACjC,IAAI;CACJ,MAAM,KAAK,UAAU,KAAK;EACzB,KAAK,MAAM,WAAW,aAAa,KAAK,QAAQ,GAAG,IAAI,OAAO;CAC/D;AACD"}

package/dist/mapCheck/rules/random.js

@@ -0,0 +1,47 @@
+import { groupChoices, tableItems } from "../../randomGroups.js";
+//#region src/mapCheck/rules/random.ts
+/** Random groups and item tables: something to draw from, and by names there are */
+var randomRules = {
+	id: "random",
+	check(map, registry, say, _context) {
+		const groups = new Map((map.randomGroups ?? []).map((group) => [group.name, group]));
+		const tables = new Set((map.itemTables ?? []).map((table) => table.name));
+		for (const group of groups.values()) if (!groupChoices(group, registry).length) say({
+			message: `The random group ${group.name} has nothing of the game to draw from`,
+			error: true,
+			rule: "empty-random-group"
+		});
+		for (const table of map.itemTables ?? []) if (!tableItems(table, registry).length) say({
+			message: `The item table ${table.name} has nothing of the game to draw from`,
+			error: true,
+			rule: "empty-item-table"
+		});
+		for (const object of map.objects) {
+			if (object.random && !groups.has(object.random)) say({
+				message: `It is drawn from "${object.random}", which is no random group of the map`,
+				error: true,
+				at: object,
+				rule: "unknown-random-group",
+				about: { object: object.id }
+			});
+			if (object.drops && !tables.has(object.drops)) say({
+				message: `It drops from "${object.drops}", which is no item table of the map`,
+				error: true,
+				at: object,
+				rule: "unknown-item-table",
+				about: { object: object.id }
+			});
+		}
+		for (const camp of map.camps) for (const unit of camp.units) if (unit.startsWith("@") && !groups.has(unit.slice(1))) say({
+			message: `A camp has "${unit}", which is no random group of the map`,
+			error: true,
+			at: camp,
+			rule: "unknown-random-group",
+			about: { camp: camp.id }
+		});
+	}
+};
+//#endregion
+export { randomRules };
+
+//# sourceMappingURL=random.js.map

package/dist/mapCheck/rules/random.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"random.js","names":[],"sources":["../../../src/mapCheck/rules/random.ts"],"sourcesContent":["import { groupChoices, tableItems } from '../../randomGroups'\nimport type { MapRule } from '../rule'\n\n/** Random groups and item tables: something to draw from, and by names there are */\nexport const randomRules: MapRule = {\n\tid: 'random',\n\tcheck(map, registry, say, _context) {\n\t\t// random groups and item tables, by the names that are given and that there are\n\t\tconst groups = new Map((map.randomGroups ?? []).map((group) => [group.name, group]))\n\t\tconst tables = new Set((map.itemTables ?? []).map((table) => table.name))\n\t\tfor (const group of groups.values()) {\n\t\t\tif (!groupChoices(group, registry).length)\n\t\t\t\tsay({ message: `The random group ${group.name} has nothing of the game to draw from`, error: true, rule: 'empty-random-group' })\n\t\t}\n\t\tfor (const table of map.itemTables ?? []) {\n\t\t\tif (!tableItems(table, registry).length)\n\t\t\t\tsay({ message: `The item table ${table.name} has nothing of the game to draw from`, error: true, rule: 'empty-item-table' })\n\t\t}\n\t\tfor (const object of map.objects) {\n\t\t\tif (object.random && !groups.has(object.random))\n\t\t\t\tsay({\n\t\t\t\t\tmessage: `It is drawn from \"${object.random}\", which is no random group of the map`,\n\t\t\t\t\terror: true,\n\t\t\t\t\tat: object,\n\t\t\t\t\trule: 'unknown-random-group',\n\t\t\t\t\tabout: { object: object.id }\n\t\t\t\t})\n\t\t\tif (object.drops && !tables.has(object.drops))\n\t\t\t\tsay({\n\t\t\t\t\tmessage: `It drops from \"${object.drops}\", which is no item table of the map`,\n\t\t\t\t\terror: true,\n\t\t\t\t\tat: object,\n\t\t\t\t\trule: 'unknown-item-table',\n\t\t\t\t\tabout: { object: object.id }\n\t\t\t\t})\n\t\t}\n\t\tfor (const camp of map.camps) {\n\t\t\tfor (const unit of camp.units) {\n\t\t\t\tif (unit.startsWith('@') && !groups.has(unit.slice(1)))\n\t\t\t\t\tsay({\n\t\t\t\t\t\tmessage: `A camp has \"${unit}\", which is no random group of the map`,\n\t\t\t\t\t\terror: true,\n\t\t\t\t\t\tat: camp,\n\t\t\t\t\t\trule: 'unknown-random-group',\n\t\t\t\t\t\tabout: { camp: camp.id }\n\t\t\t\t\t})\n\t\t\t}\n\t\t}\n\t}\n}\n"],"mappings":";;;AAIA,IAAa,cAAuB;CACnC,IAAI;CACJ,MAAM,KAAK,UAAU,KAAK,UAAU;EAEnC,MAAM,SAAS,IAAI,KAAK,IAAI,gBAAgB,CAAC,EAAA,CAAG,KAAK,UAAU,CAAC,MAAM,MAAM,KAAK,CAAC,CAAC;EACnF,MAAM,SAAS,IAAI,KAAK,IAAI,cAAc,CAAC,EAAA,CAAG,KAAK,UAAU,MAAM,IAAI,CAAC;EACxE,KAAK,MAAM,SAAS,OAAO,OAAO,GACjC,IAAI,CAAC,aAAa,OAAO,QAAQ,CAAC,CAAC,QAClC,IAAI;GAAE,SAAS,oBAAoB,MAAM,KAAK;GAAwC,OAAO;GAAM,MAAM;EAAqB,CAAC;EAEjI,KAAK,MAAM,SAAS,IAAI,cAAc,CAAC,GACtC,IAAI,CAAC,WAAW,OAAO,QAAQ,CAAC,CAAC,QAChC,IAAI;GAAE,SAAS,kBAAkB,MAAM,KAAK;GAAwC,OAAO;GAAM,MAAM;EAAmB,CAAC;EAE7H,KAAK,MAAM,UAAU,IAAI,SAAS;GACjC,IAAI,OAAO,UAAU,CAAC,OAAO,IAAI,OAAO,MAAM,GAC7C,IAAI;IACH,SAAS,qBAAqB,OAAO,OAAO;IAC5C,OAAO;IACP,IAAI;IACJ,MAAM;IACN,OAAO,EAAE,QAAQ,OAAO,GAAG;GAC5B,CAAC;GACF,IAAI,OAAO,SAAS,CAAC,OAAO,IAAI,OAAO,KAAK,GAC3C,IAAI;IACH,SAAS,kBAAkB,OAAO,MAAM;IACxC,OAAO;IACP,IAAI;IACJ,MAAM;IACN,OAAO,EAAE,QAAQ,OAAO,GAAG;GAC5B,CAAC;EACH;EACA,KAAK,MAAM,QAAQ,IAAI,OACtB,KAAK,MAAM,QAAQ,KAAK,OACvB,IAAI,KAAK,WAAW,GAAG,KAAK,CAAC,OAAO,IAAI,KAAK,MAAM,CAAC,CAAC,GACpD,IAAI;GACH,SAAS,eAAe,KAAK;GAC7B,OAAO;GACP,IAAI;GACJ,MAAM;GACN,OAAO,EAAE,MAAM,KAAK,GAAG;EACxB,CAAC;CAGL;AACD"}

package/dist/mapCheck/rules/regions.js

@@ -0,0 +1,30 @@
+import { shapeBounds } from "../../areas.js";
+//#region src/mapCheck/rules/regions.ts
+/** Regions on the map */
+var regionRules = {
+	id: "regions",
+	check(map, _registry, say, _context) {
+		const { width, depth } = map;
+		for (const region of map.regions) {
+			const { shape } = region;
+			const reach = shapeBounds(shape);
+			if (reach.x1 <= 0 || reach.z1 <= 0 || reach.x0 >= width || reach.z0 >= depth) say({
+				message: `The region ${region.name} is outside the map`,
+				error: true,
+				at: shape,
+				rule: "region-off-map",
+				about: { region: region.id }
+			});
+			else if (reach.x0 < 0 || reach.z0 < 0 || reach.x1 > width || reach.z1 > depth) say({
+				message: `The region ${region.name} goes past the edge of the map`,
+				at: shape,
+				rule: "region-past-edge",
+				about: { region: region.id }
+			});
+		}
+	}
+};
+//#endregion
+export { regionRules };
+
+//# sourceMappingURL=regions.js.map

package/dist/mapCheck/rules/regions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"regions.js","names":[],"sources":["../../../src/mapCheck/rules/regions.ts"],"sourcesContent":["import { shapeBounds } from '#engine/areas'\nimport type { MapRule } from '../rule'\n\n/** Regions on the map */\nexport const regionRules: MapRule = {\n\tid: 'regions',\n\tcheck(map, _registry, say, _context) {\n\t\tconst { width, depth } = map\n\t\tfor (const region of map.regions) {\n\t\t\tconst { shape } = region\n\t\t\tconst reach = shapeBounds(shape)\n\t\t\tif (reach.x1 <= 0 || reach.z1 <= 0 || reach.x0 >= width || reach.z0 >= depth)\n\t\t\t\tsay({\n\t\t\t\t\tmessage: `The region ${region.name} is outside the map`,\n\t\t\t\t\terror: true,\n\t\t\t\t\tat: shape,\n\t\t\t\t\trule: 'region-off-map',\n\t\t\t\t\tabout: { region: region.id }\n\t\t\t\t})\n\t\t\telse if (reach.x0 < 0 || reach.z0 < 0 || reach.x1 > width || reach.z1 > depth)\n\t\t\t\tsay({\n\t\t\t\t\tmessage: `The region ${region.name} goes past the edge of the map`,\n\t\t\t\t\tat: shape,\n\t\t\t\t\trule: 'region-past-edge',\n\t\t\t\t\tabout: { region: region.id }\n\t\t\t\t})\n\t\t}\n\t}\n}\n"],"mappings":";;;AAIA,IAAa,cAAuB;CACnC,IAAI;CACJ,MAAM,KAAK,WAAW,KAAK,UAAU;EACpC,MAAM,EAAE,OAAO,UAAU;EACzB,KAAK,MAAM,UAAU,IAAI,SAAS;GACjC,MAAM,EAAE,UAAU;GAClB,MAAM,QAAQ,YAAY,KAAK;GAC/B,IAAI,MAAM,MAAM,KAAK,MAAM,MAAM,KAAK,MAAM,MAAM,SAAS,MAAM,MAAM,OACtE,IAAI;IACH,SAAS,cAAc,OAAO,KAAK;IACnC,OAAO;IACP,IAAI;IACJ,MAAM;IACN,OAAO,EAAE,QAAQ,OAAO,GAAG;GAC5B,CAAC;QACG,IAAI,MAAM,KAAK,KAAK,MAAM,KAAK,KAAK,MAAM,KAAK,SAAS,MAAM,KAAK,OACvE,IAAI;IACH,SAAS,cAAc,OAAO,KAAK;IACnC,IAAI;IACJ,MAAM;IACN,OAAO,EAAE,QAAQ,OAAO,GAAG;GAC5B,CAAC;EACH;CACD;AACD"}

package/dist/mapCheck/rules/targets.js

@@ -0,0 +1,31 @@
+import { TARGET_FIELDS, campFields, mapFields, objectFields, playerFields, regionFields, targetName } from "../../mapFields.js";
+//#region src/mapCheck/rules/targets.ts
+/** A field that names a region, a point or a path the map has not (any more) */
+var targetRules = {
+	id: "targets",
+	check(map, registry, say, _context) {
+		const naming = (fields, data, about, at) => {
+			for (const field of fields) {
+				const kind = field.kind;
+				const id = data?.[field.id];
+				if (!TARGET_FIELDS.includes(field.kind) || typeof id !== "number") continue;
+				if (targetName(map, kind, id) === void 0) say({
+					message: `${field.name} names a ${kind} the map does not have`,
+					error: true,
+					rule: "missing-target",
+					...at && { at },
+					...about && { about }
+				});
+			}
+		};
+		for (const object of map.objects) naming(objectFields(registry, object.type), object.data, { object: object.id }, object);
+		for (const camp of map.camps) naming(campFields(registry), camp.data, { camp: camp.id }, camp);
+		for (const region of map.regions) naming(regionFields(registry), region.data, { region: region.id });
+		for (const player of map.players) naming(playerFields(registry), player.data, { player: player.id }, player.start);
+		naming(mapFields(registry), map.data, void 0);
+	}
+};
+//#endregion
+export { targetRules };
+
+//# sourceMappingURL=targets.js.map

package/dist/mapCheck/rules/targets.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"targets.js","names":[],"sources":["../../../src/mapCheck/rules/targets.ts"],"sourcesContent":["import {\n\tcampFields,\n\ttype MapFieldDef,\n\tmapFields,\n\ttype MapTarget,\n\tobjectFields,\n\tplayerFields,\n\tregionFields,\n\tTARGET_FIELDS,\n\ttargetName\n} from '../../mapFields'\nimport type { Vec2 } from '../../math'\nimport type { MapRule } from '../rule'\n\n/** A field that names a region, a point or a path the map has not (any more) */\nexport const targetRules: MapRule = {\n\tid: 'targets',\n\tcheck(map, registry, say, _context) {\n\t\t// a field that names a region, a point or a path the map has not (any more): taken away, or never there\n\t\tconst naming = (fields: readonly MapFieldDef[], data: Record<string, unknown> | undefined, about: MapTarget | undefined, at?: Vec2) => {\n\t\t\tfor (const field of fields) {\n\t\t\t\tconst kind = field.kind as (typeof TARGET_FIELDS)[number]\n\t\t\t\tconst id = data?.[field.id]\n\t\t\t\tif (!(TARGET_FIELDS as readonly string[]).includes(field.kind) || typeof id !== 'number') continue\n\t\t\t\tif (targetName(map, kind, id) === undefined)\n\t\t\t\t\tsay({\n\t\t\t\t\t\tmessage: `${field.name} names a ${kind} the map does not have`,\n\t\t\t\t\t\terror: true,\n\t\t\t\t\t\trule: 'missing-target',\n\t\t\t\t\t\t...(at && { at }),\n\t\t\t\t\t\t...(about && { about })\n\t\t\t\t\t})\n\t\t\t}\n\t\t}\n\t\tfor (const object of map.objects) naming(objectFields(registry, object.type), object.data, { object: object.id }, object)\n\t\tfor (const camp of map.camps) naming(campFields(registry), camp.data, { camp: camp.id }, camp)\n\t\tfor (const region of map.regions) naming(regionFields(registry), region.data, { region: region.id })\n\t\tfor (const player of map.players) naming(playerFields(registry), player.data, { player: player.id }, player.start)\n\t\tnaming(mapFields(registry), map.data, undefined)\n\t}\n}\n"],"mappings":";;;AAeA,IAAa,cAAuB;CACnC,IAAI;CACJ,MAAM,KAAK,UAAU,KAAK,UAAU;EAEnC,MAAM,UAAU,QAAgC,MAA2C,OAA8B,OAAc;GACtI,KAAK,MAAM,SAAS,QAAQ;IAC3B,MAAM,OAAO,MAAM;IACnB,MAAM,KAAK,OAAO,MAAM;IACxB,IAAI,CAAE,cAAoC,SAAS,MAAM,IAAI,KAAK,OAAO,OAAO,UAAU;IAC1F,IAAI,WAAW,KAAK,MAAM,EAAE,MAAM,KAAA,GACjC,IAAI;KACH,SAAS,GAAG,MAAM,KAAK,WAAW,KAAK;KACvC,OAAO;KACP,MAAM;KACN,GAAI,MAAM,EAAE,GAAG;KACf,GAAI,SAAS,EAAE,MAAM;IACtB,CAAC;GACH;EACD;EACA,KAAK,MAAM,UAAU,IAAI,SAAS,OAAO,aAAa,UAAU,OAAO,IAAI,GAAG,OAAO,MAAM,EAAE,QAAQ,OAAO,GAAG,GAAG,MAAM;EACxH,KAAK,MAAM,QAAQ,IAAI,OAAO,OAAO,WAAW,QAAQ,GAAG,KAAK,MAAM,EAAE,MAAM,KAAK,GAAG,GAAG,IAAI;EAC7F,KAAK,MAAM,UAAU,IAAI,SAAS,OAAO,aAAa,QAAQ,GAAG,OAAO,MAAM,EAAE,QAAQ,OAAO,GAAG,CAAC;EACnG,KAAK,MAAM,UAAU,IAAI,SAAS,OAAO,aAAa,QAAQ,GAAG,OAAO,MAAM,EAAE,QAAQ,OAAO,GAAG,GAAG,OAAO,KAAK;EACjH,OAAO,UAAU,QAAQ,GAAG,IAAI,MAAM,KAAA,CAAS;CAChD;AACD"}

package/dist/mapCheck/rules/walking.js

@@ -0,0 +1,45 @@
+import { reachedByDefault } from "../../mapFields.js";
+import { walkingAreas } from "../cells.js";
+//#region src/mapCheck/rules/walking.ts
+/** Who can walk to whom: starts cut off from each other, mines nobody can walk to */
+var walkingRules = {
+	id: "walking",
+	check(map, registry, say, _context) {
+		const starts = map.players.filter((player) => player.start);
+		if (starts.length) {
+			const { at } = walkingAreas(map, registry);
+			const areas = starts.map((player) => at(player.start));
+			starts.forEach((player, i) => {
+				if (!areas[i]) say({
+					message: `${player.name} starts where nothing can walk`,
+					error: true,
+					at: player.start,
+					rule: "start-blocked",
+					about: { player: player.id }
+				});
+				else if (areas.some((other, j) => j !== i && other && other !== areas[i])) say({
+					message: `${player.name} cannot walk to every other start: a cliff, water or what is built is in the way`,
+					at: player.start,
+					rule: "starts-apart",
+					about: { player: player.id }
+				});
+			});
+			const reached = new Set(areas.filter(Boolean));
+			for (const object of map.objects) {
+				if (!registry.units.has(object.type)) continue;
+				const def = registry.unit(object.type);
+				if (!(registry.module?.editor?.reach ?? reachedByDefault)(def)) continue;
+				if (!reached.has(at(object))) say({
+					message: `Nobody can walk to the ${def.name} here`,
+					at: object,
+					rule: "unreachable",
+					about: { object: object.id }
+				});
+			}
+		}
+	}
+};
+//#endregion
+export { walkingRules };
+
+//# sourceMappingURL=walking.js.map

package/dist/mapCheck/rules/walking.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"walking.js","names":[],"sources":["../../../src/mapCheck/rules/walking.ts"],"sourcesContent":["import { reachedByDefault } from '../../mapFields'\nimport { walkingAreas } from '../cells'\nimport type { MapRule } from '../rule'\n\n/** Who can walk to whom: starts cut off from each other, mines nobody can walk to */\nexport const walkingRules: MapRule = {\n\tid: 'walking',\n\tcheck(map, registry, say, _context) {\n\t\t// who can walk to whom: starts that are cut off from each other, mines nobody can walk to\n\t\tconst starts = map.players.filter((player) => player.start)\n\t\tif (starts.length) {\n\t\t\tconst { at } = walkingAreas(map, registry)\n\t\t\tconst areas = starts.map((player) => at(player.start!))\n\t\t\tstarts.forEach((player, i) => {\n\t\t\t\tif (!areas[i])\n\t\t\t\t\tsay({\n\t\t\t\t\t\tmessage: `${player.name} starts where nothing can walk`,\n\t\t\t\t\t\terror: true,\n\t\t\t\t\t\tat: player.start,\n\t\t\t\t\t\trule: 'start-blocked',\n\t\t\t\t\t\tabout: { player: player.id }\n\t\t\t\t\t})\n\t\t\t\telse if (areas.some((other, j) => j !== i && other && other !== areas[i])) {\n\t\t\t\t\tsay({\n\t\t\t\t\t\tmessage: `${player.name} cannot walk to every other start: a cliff, water or what is built is in the way`,\n\t\t\t\t\t\tat: player.start,\n\t\t\t\t\t\trule: 'starts-apart',\n\t\t\t\t\t\tabout: { player: player.id }\n\t\t\t\t\t})\n\t\t\t\t}\n\t\t\t})\n\t\t\tconst reached = new Set(areas.filter(Boolean))\n\t\t\tfor (const object of map.objects) {\n\t\t\t\tif (!registry.units.has(object.type)) continue\n\t\t\t\tconst def = registry.unit(object.type)\n\t\t\t\t// what is mined, not what is cut, unless the game says: trees stand where they stand\n\t\t\t\tif (!(registry.module?.editor?.reach ?? reachedByDefault)(def)) continue\n\t\t\t\tif (!reached.has(at(object)))\n\t\t\t\t\tsay({ message: `Nobody can walk to the ${def.name} here`, at: object, rule: 'unreachable', about: { object: object.id } })\n\t\t\t}\n\t\t}\n\t}\n}\n"],"mappings":";;;;AAKA,IAAa,eAAwB;CACpC,IAAI;CACJ,MAAM,KAAK,UAAU,KAAK,UAAU;EAEnC,MAAM,SAAS,IAAI,QAAQ,QAAQ,WAAW,OAAO,KAAK;EAC1D,IAAI,OAAO,QAAQ;GAClB,MAAM,EAAE,OAAO,aAAa,KAAK,QAAQ;GACzC,MAAM,QAAQ,OAAO,KAAK,WAAW,GAAG,OAAO,KAAM,CAAC;GACtD,OAAO,SAAS,QAAQ,MAAM;IAC7B,IAAI,CAAC,MAAM,IACV,IAAI;KACH,SAAS,GAAG,OAAO,KAAK;KACxB,OAAO;KACP,IAAI,OAAO;KACX,MAAM;KACN,OAAO,EAAE,QAAQ,OAAO,GAAG;IAC5B,CAAC;SACG,IAAI,MAAM,MAAM,OAAO,MAAM,MAAM,KAAK,SAAS,UAAU,MAAM,EAAE,GACvE,IAAI;KACH,SAAS,GAAG,OAAO,KAAK;KACxB,IAAI,OAAO;KACX,MAAM;KACN,OAAO,EAAE,QAAQ,OAAO,GAAG;IAC5B,CAAC;GAEH,CAAC;GACD,MAAM,UAAU,IAAI,IAAI,MAAM,OAAO,OAAO,CAAC;GAC7C,KAAK,MAAM,UAAU,IAAI,SAAS;IACjC,IAAI,CAAC,SAAS,MAAM,IAAI,OAAO,IAAI,GAAG;IACtC,MAAM,MAAM,SAAS,KAAK,OAAO,IAAI;IAErC,IAAI,EAAE,SAAS,QAAQ,QAAQ,SAAS,iBAAA,CAAkB,GAAG,GAAG;IAChE,IAAI,CAAC,QAAQ,IAAI,GAAG,MAAM,CAAC,GAC1B,IAAI;KAAE,SAAS,0BAA0B,IAAI,KAAK;KAAQ,IAAI;KAAQ,MAAM;KAAe,OAAO,EAAE,QAAQ,OAAO,GAAG;IAAE,CAAC;GAC3H;EACD;CACD;AACD"}

package/dist/mapCheck.d.ts

@@ -6,7 +6,7 @@ export { mapCells } from './mapCheck/cells';
 export type { MapCheckContext, MapRule } from './mapCheck/rule';
 /**
  * The engine's checks of a map, in the order they run: players, what is placed, random groups, names, regions, paths,
- * walking, races, the fields that name things
+ * walking, races, the fields that name things, the styles of grass painted
  *
  * @beta
  */
@@ -18,6 +18,6 @@ export declare const MAP_RULES: readonly MapRule[];
  * a game view's own, as the editor runs them); then the game's own (`MapEditorDef.check`). Errors keep it from being
  * played; the rest are warnings. Runs without the editor, for a test that goes over every map of a project
  *
- * @beta
+ * @public
  */
 export declare function checkMap(map: GameMap, registry: Registry, more?: readonly MapRule[]): MapProblem[];

package/dist/mapCheck.js

@@ -0,0 +1,63 @@
+import { mapTerrain } from "./map/terrain.js";
+import { playerRules } from "./mapCheck/rules/players.js";
+import { objectRules } from "./mapCheck/rules/objects.js";
+import { randomRules } from "./mapCheck/rules/random.js";
+import { nameRules } from "./mapCheck/rules/names.js";
+import { regionRules } from "./mapCheck/rules/regions.js";
+import { pathRules } from "./mapCheck/rules/paths.js";
+import { mapCells } from "./mapCheck/cells.js";
+import { walkingRules } from "./mapCheck/rules/walking.js";
+import { raceRules } from "./mapCheck/rules/races.js";
+import { targetRules } from "./mapCheck/rules/targets.js";
+import { foliageRules } from "./mapCheck/rules/foliage.js";
+//#region src/mapCheck.ts
+/**
+* The engine's checks of a map, in the order they run: players, what is placed, random groups, names, regions, paths,
+* walking, races, the fields that name things, the styles of grass painted
+*
+* @beta
+*/
+var MAP_RULES = [
+	playerRules,
+	objectRules,
+	randomRules,
+	nameRules,
+	regionRules,
+	pathRules,
+	walkingRules,
+	raceRules,
+	targetRules,
+	foliageRules
+];
+/**
+* What is wrong with a map, before it is played: what the game does not have, names used twice or named and not
+* there, what stands off the map or in deep water, starts that cannot reach each other on foot, mines nobody can walk
+* to, regions outside the map (`MAP_RULES`); then the checks given (`more`: the client's of what the map looks like,
+* a game view's own, as the editor runs them); then the game's own (`MapEditorDef.check`). Errors keep it from being
+* played; the rest are warnings. Runs without the editor, for a test that goes over every map of a project
+*
+* @public
+*/
+function checkMap(map, registry, more = []) {
+	const problems = [];
+	const { width, depth } = map;
+	let terrain;
+	const context = {
+		get terrain() {
+			return terrain ??= mapTerrain(map);
+		},
+		onMap: (p) => p.x >= 0 && p.z >= 0 && p.x <= width && p.z <= depth
+	};
+	const say = (problem) => void problems.push(problem);
+	for (const rule of [...MAP_RULES, ...more]) rule.check(map, registry, say, context);
+	const own = (registry.assembly?.check?.(map, registry) ?? []).map((problem) => ({
+		rule: "game",
+		...problem
+	}));
+	const silenced = /* @__PURE__ */ new Set([...registry.module?.editor?.silence ?? [], ...map.silence ?? []]);
+	return [...problems, ...own].filter((problem) => !problem.rule || !silenced.has(problem.rule));
+}
+//#endregion
+export { MAP_RULES, checkMap, mapCells };
+
+//# sourceMappingURL=mapCheck.js.map

package/dist/mapCheck.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapCheck.js","names":[],"sources":["../src/mapCheck.ts"],"sourcesContent":["/*\n * The checks of a map before it is played (design review E8b): the engine's (`MAP_RULES`, one file each in\n * `mapCheck/rules`), those given beside them (the client's of a map's looks, a game's view's own), then the game's own\n * (`MapEditorDef.check`), less what the map and the game silence\n */\nimport { type GameMap, mapTerrain } from './map'\nimport type { MapProblem } from './mapFields'\nimport type { Vec2 } from './math'\nimport type { Registry } from './registry'\nimport type { Terrain } from './terrain'\nimport type { MapCheckContext, MapRule } from './mapCheck/rule'\nimport { playerRules } from './mapCheck/rules/players'\nimport { objectRules } from './mapCheck/rules/objects'\nimport { randomRules } from './mapCheck/rules/random'\nimport { nameRules } from './mapCheck/rules/names'\nimport { regionRules } from './mapCheck/rules/regions'\nimport { pathRules } from './mapCheck/rules/paths'\nimport { walkingRules } from './mapCheck/rules/walking'\nimport { raceRules } from './mapCheck/rules/races'\nimport { targetRules } from './mapCheck/rules/targets'\nimport { foliageRules } from './mapCheck/rules/foliage'\n\nexport { mapCells } from './mapCheck/cells'\nexport type { MapCheckContext, MapRule } from './mapCheck/rule'\n\n/**\n * The engine's checks of a map, in the order they run: players, what is placed, random groups, names, regions, paths,\n * walking, races, the fields that name things, the styles of grass painted\n *\n * @beta\n */\nexport const MAP_RULES: readonly MapRule[] = [\n\tplayerRules,\n\tobjectRules,\n\trandomRules,\n\tnameRules,\n\tregionRules,\n\tpathRules,\n\twalkingRules,\n\traceRules,\n\ttargetRules,\n\tfoliageRules\n]\n\n/**\n * What is wrong with a map, before it is played: what the game does not have, names used twice or named and not\n * there, what stands off the map or in deep water, starts that cannot reach each other on foot, mines nobody can walk\n * to, regions outside the map (`MAP_RULES`); then the checks given (`more`: the client's of what the map looks like,\n * a game view's own, as the editor runs them); then the game's own (`MapEditorDef.check`). Errors keep it from being\n * played; the rest are warnings. Runs without the editor, for a test that goes over every map of a project\n *\n * @public\n */\nexport function checkMap(map: GameMap, registry: Registry, more: readonly MapRule[] = []): MapProblem[] {\n\tconst problems: MapProblem[] = []\n\tconst { width, depth } = map\n\tlet terrain: Terrain | undefined\n\tconst context: MapCheckContext = {\n\t\tget terrain() {\n\t\t\treturn (terrain ??= mapTerrain(map))\n\t\t},\n\t\tonMap: (p: Vec2) => p.x >= 0 && p.z >= 0 && p.x <= width && p.z <= depth\n\t}\n\tconst say = (problem: MapProblem) => void problems.push(problem)\n\tfor (const rule of [...MAP_RULES, ...more]) rule.check(map, registry, say, context)\n\t// the game's own, each said to be the game's where it names no rule of its own; then what the map and the game silence\n\tconst own = (registry.assembly?.check?.(map, registry) ?? []).map((problem) => ({ rule: 'game', ...problem }))\n\tconst silenced = new Set([...(registry.module?.editor?.silence ?? []), ...(map.silence ?? [])])\n\treturn [...problems, ...own].filter((problem) => !problem.rule || !silenced.has(problem.rule))\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AA+BA,IAAa,YAAgC;CAC5C;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACD;;;;;;;;;;AAWA,SAAgB,SAAS,KAAc,UAAoB,OAA2B,CAAC,GAAiB;CACvG,MAAM,WAAyB,CAAC;CAChC,MAAM,EAAE,OAAO,UAAU;CACzB,IAAI;CACJ,MAAM,UAA2B;EAChC,IAAI,UAAU;GACb,OAAQ,YAAY,WAAW,GAAG;EACnC;EACA,QAAQ,MAAY,EAAE,KAAK,KAAK,EAAE,KAAK,KAAK,EAAE,KAAK,SAAS,EAAE,KAAK;CACpE;CACA,MAAM,OAAO,YAAwB,KAAK,SAAS,KAAK,OAAO;CAC/D,KAAK,MAAM,QAAQ,CAAC,GAAG,WAAW,GAAG,IAAI,GAAG,KAAK,MAAM,KAAK,UAAU,KAAK,OAAO;CAElF,MAAM,OAAO,SAAS,UAAU,QAAQ,KAAK,QAAQ,KAAK,CAAC,EAAA,CAAG,KAAK,aAAa;EAAE,MAAM;EAAQ,GAAG;CAAQ,EAAE;CAC7G,MAAM,2BAAW,IAAI,IAAI,CAAC,GAAI,SAAS,QAAQ,QAAQ,WAAW,CAAC,GAAI,GAAI,IAAI,WAAW,CAAC,CAAE,CAAC;CAC9F,OAAO,CAAC,GAAG,UAAU,GAAG,GAAG,CAAC,CAAC,QAAQ,YAAY,CAAC,QAAQ,QAAQ,CAAC,SAAS,IAAI,QAAQ,IAAI,CAAC;AAC9F"}

package/dist/mapFields.d.ts

@@ -29,12 +29,16 @@ export type MapTarget = {
     decal: number;
 } | {
     sound: number;
+} | {
+    waterfall: number;
 } | {
     mistArea: number;
 } | {
     weatherArea: number;
 } | {
     cloudPatch: number;
+} | {
+    pictureZone: number;
 } | {
     player: number;
 } | {
@@ -52,7 +56,9 @@ export type MapTarget = {
 export interface MapThing {
     /** Its own among the things of its kind */
     id: number;
+    /** Where the thing stands on the map's x axis, in cells */
     x: number;
+    /** Where the thing stands on the map's z axis, in cells */
     z: number;
     /** The way it faces, in radians. 0 when left out */
     facing?: number;
@@ -77,6 +83,7 @@ export declare function mapThings(map: {
  * @beta
  */
 export interface MapProblem {
+    /** What is wrong, in words, as the editor and the lobby show it */
     message: string;
     /** It cannot be played like this. A warning when left out: it can, but probably should not */
     error?: boolean;
@@ -206,12 +213,16 @@ export type MapRefTarget = {
     decal: number;
 } | {
     sound: number;
+} | {
+    waterfall: number;
 } | {
     mistArea: number;
 } | {
     weatherArea: number;
 } | {
     cloudPatch: number;
+} | {
+    pictureZone: number;
 } | {
     thing: number;
     kind: string;
@@ -226,6 +237,7 @@ export interface MapRefUse {
     what: string;
     /** Where: the map's name, a group's, a prefab's, a cinematic's id, a wave's */
     where: string;
+    /** What on the map the use points at, for the editor to select */
     target?: MapRefTarget;
 }
 /**
@@ -234,7 +246,9 @@ export interface MapRefUse {
  * @beta
  */
 export interface MapPaletteGroup {
+    /** The group's name in the palette */
     name: string;
+    /** The unit types in the group */
     types: UnitTypeDef[];
     /**
      * Whose what is put down from it is, by player id (`MAP_CREEPS`, `MAP_NEUTRAL`): the player picked above it when
@@ -250,9 +264,11 @@ export interface MapPaletteGroup {
  * @beta
  */
 export interface MapEraseKind {
+    /** The id of the kind, which `MapEditorDef.erase` lists it by */
     id: string;
     /** What the brush's choice calls it */
     name: string;
+    /** Whether a unit type is of this kind: the erase brush takes the objects it says yes to */
     takes: (def: UnitTypeDef) => boolean;
 }
 /**
@@ -276,7 +292,7 @@ export declare const TARGET_FIELDS: readonly ['region', 'point', 'path'];
  * A field of a game's own on what is placed on a map: the wave a spawner sends, whether a gate starts open, what a
  * guard does. The editor shows it in the inspector for what it is a field of, and keeps what it was set to with the
  * object (`MapObject.data`). The engine does nothing with it: the `mapObject` hook hands it to the game as the world
- * is made, which is where the game says what it means. Given in `GameModule.editor.fields`
+ * is made, which is where the game says what it means. Given in `Rules.editor.fields`
  *
  * @beta
  */
@@ -292,6 +308,7 @@ export interface MapFieldDef {
      * one group two a line, under its name. Alone when left out
      */
     group?: string;
+    /** What sort of value the field holds, which the inspector edits it with (`MapFieldKind`) */
     kind: MapFieldKind;
     /**
      * What it is a field of: objects of these unit types, or of the types a function says yes to (every hero, every
@@ -303,7 +320,9 @@ export interface MapFieldDef {
     default?: unknown;
     /** For a number: the least and the most it can be, and what the arrows step by */
     min?: number;
+    /** For a number field: the most it can be */
     max?: number;
+    /** For a number field: what the arrows step it by */
     step?: number;
     /** For a choice: what there is to choose from, as data or worked out from the game */
     options?: readonly MapFieldOption[] | ((registry: Registry) => readonly MapFieldOption[]);
@@ -347,7 +366,11 @@ export declare const regionFields: (registry: Registry) => MapFieldDef[];
  * @beta
  */
 export declare const mapFields: (registry: Registry) => MapFieldDef[];
-/** @beta */
+/**
+ * The game's fields for players (`for: 'player'`) of a registry, as `MapFieldDef`s
+ *
+ * @beta
+ */
 export declare const playerFields: (registry: Registry) => MapFieldDef[];
 /**
  * What a choice field can be set to, as values with what each is called