@v12-engine/engine 0.1.0 → 0.4.0

package/dist/mapFields.js

@@ -0,0 +1,134 @@
+import { footprintOf } from "./defs.js";
+//#region src/mapFields.ts
+/**
+* The things of a kind of a game's own on a map (`MapThing`), as the map keeps them: none for a kind it has nothing
+* of. What is kept under that name and is no thing (no id, no place) is left out, so that a file changed by hand breaks
+* no rule that reads it
+*
+* @beta
+*/
+function mapThings(map, kind) {
+	const kept = map.data[kind];
+	if (!Array.isArray(kept)) return [];
+	return kept.filter((thing) => typeof thing === "object" && thing !== null && Number.isInteger(thing.id) && Number.isFinite(thing.x) && Number.isFinite(thing.z));
+}
+/**
+* What the starts must reach when a game does not say: what is mined, not what is cut
+*
+* @internal
+*/
+var reachedByDefault = (def) => def.kind === "resource" && footprintOf(def).w >= 2;
+/**
+* The heights the ground goes from and to when a game does not say
+*
+* @beta
+*/
+var DEFAULT_HEIGHTS = [-4, 16];
+/** The kinds of field that name a thing of the map, by its id */
+var TARGET_FIELDS = [
+	"region",
+	"point",
+	"path"
+];
+/**
+* Typed help for writing a field
+*
+* @beta
+*/
+var defineMapField = (def) => def;
+/** The game's fields: its own (`Rules.editor.fields`) and those of the components it lists (`Component.field`), under the component's id */
+var fieldsOf = (registry) => {
+	const own = registry.module?.editor?.fields ?? [];
+	let all;
+	for (const component of registry.listedComponents()) if (component.field) (all ??= [...own]).push({
+		...component.field,
+		id: component.id
+	});
+	return all ?? own;
+};
+/**
+* The game's fields for a placed object, by the type it is of. None for a type the game does not have
+*
+* @beta
+*/
+function objectFields(registry, type) {
+	if (!registry.units.has(type)) return [];
+	const def = registry.unit(type);
+	return fieldsOf(registry).filter((field) => typeof field.for === "function" ? field.for(def) : Array.isArray(field.for) && field.for.includes(type));
+}
+/**
+* The game's fields for a camp
+*
+* @beta
+*/
+var campFields = (registry) => fieldsOf(registry).filter((field) => field.for === "camp");
+/**
+* The game's fields for a region
+*
+* @beta
+*/
+var regionFields = (registry) => fieldsOf(registry).filter((field) => field.for === "region");
+/**
+* The fields of the map itself, and of its players
+*
+* @beta
+*/
+var mapFields = (registry) => fieldsOf(registry).filter((field) => field.for === "map");
+/**
+* The game's fields for players (`for: 'player'`) of a registry, as `MapFieldDef`s
+*
+* @beta
+*/
+var playerFields = (registry) => fieldsOf(registry).filter((field) => field.for === "player");
+/**
+* What a choice field can be set to, as values with what each is called
+*
+* @beta
+*/
+function fieldOptions(registry, field) {
+	return (typeof field.options === "function" ? field.options(registry) : field.options ?? []).map((option) => typeof option === "string" ? {
+		value: option,
+		label: option
+	} : option);
+}
+/** What the fields of something placed are, with what was not set at its default: what the game is handed */
+function fieldValues(fields, data, map) {
+	const values = { ...data };
+	for (const field of fields) {
+		if (values[field.id] === void 0 && field.default !== void 0) values[field.id] = field.default;
+		if (map && TARGET_FIELDS.includes(field.kind) && typeof values[field.id] === "number") values[field.id] = targetName(map, field.kind, values[field.id]);
+	}
+	return values;
+}
+/** The name of a region, a point or a path of a map by its id: undefined for one the map has not (any more) */
+function targetName(map, kind, id) {
+	return (kind === "region" ? map.regions : kind === "point" ? map.points : map.paths).find((thing) => thing.id === id)?.name;
+}
+/**
+* The game's fields of an object or a camp of a map, as the game is handed them
+*
+* @internal
+*/
+var mapObjectData = (registry, object, map) => fieldValues(objectFields(registry, object.type), object.data, map);
+/**
+* The game's fields of a camp, with the values it kept and the defaults for the rest; what the `mapCamp` hook hands the game
+*
+* @internal
+*/
+var mapCampData = (registry, camp, map) => fieldValues(campFields(registry), camp.data, map);
+/**
+* The game's fields of a region, with the values it kept and the defaults for the rest; what the `mapRegion` hook hands the game
+*
+* @internal
+*/
+var mapRegionData = (registry, region, map) => fieldValues(regionFields(registry), region.data, map);
+/**
+* The game's fields of a player, with the values it kept and the defaults for the rest; what the game reads as `world.map.player(id).data`
+*
+* @internal
+*/
+var mapPlayerData = (registry, player, map) => fieldValues(playerFields(registry), player.data, map);
+//#endregion
+export { DEFAULT_HEIGHTS, TARGET_FIELDS, campFields, defineMapField, fieldOptions, fieldValues, mapCampData, mapFields, mapObjectData, mapPlayerData, mapRegionData, mapThings, objectFields, playerFields, reachedByDefault, regionFields, targetName };
+
+//# sourceMappingURL=mapFields.js.map

package/dist/mapFields.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapFields.js","names":[],"sources":["../src/mapFields.ts"],"sourcesContent":["import { footprintOf, type UnitTypeDef } from './defs'\nimport type { GameMap, MapCamp, MapObject, MapPlayer, MapRegion } from './map'\nimport type { GameMeasure } from './mapMeasure'\nimport type { Vec2 } from './math'\nimport type { Registry } from './registry'\n\n/**\n * A thing on a map, by its kind and id: what a problem is about, which the editor selects. `thing` is one of a kind of\n * the game's own (`MapThing`), with the kind's name\n *\n * @beta\n */\nexport type MapTarget =\n\t| { object: number }\n\t| { camp: number }\n\t| { region: number }\n\t| { point: number }\n\t| { path: number }\n\t| { doodad: number }\n\t| { light: number }\n\t| { effect: number }\n\t| { decal: number }\n\t| { sound: number }\n\t| { waterfall: number }\n\t| { mistArea: number }\n\t| { weatherArea: number }\n\t| { cloudPatch: number }\n\t| { pictureZone: number }\n\t| { player: number }\n\t| { thing: number; kind: string }\n\n/**\n * A thing of a kind of a game's own on a map: something the game's editor puts down for its rules to read (a spawner,\n * a waypoint, ground kept clear), where the engine's own kinds (objects, camps, regions, points, paths, doodads) do\n * not say it. Kept with the map under the kind's name (`GameMap.data[kind]`, a list of them), which the engine never\n * looks inside: the rules read them (`world.map.things(kind)`, `mapThings`)\n *\n * @beta\n */\nexport interface MapThing {\n\t/** Its own among the things of its kind */\n\tid: number\n\t/** Where the thing stands on the map's x axis, in cells */\n\tx: number\n\t/** Where the thing stands on the map's z axis, in cells */\n\tz: number\n\t/** The way it faces, in radians. 0 when left out */\n\tfacing?: number\n\t/** A name of its own, to find it by: no two things of a map have the same, whatever they are */\n\tname?: string\n\t/** The game's own fields of it, by their ids: what was set, without what is at its default */\n\tdata?: Record<string, unknown>\n}\n\n/**\n * The things of a kind of a game's own on a map (`MapThing`), as the map keeps them: none for a kind it has nothing\n * of. What is kept under that name and is no thing (no id, no place) is left out, so that a file changed by hand breaks\n * no rule that reads it\n *\n * @beta\n */\nexport function mapThings(map: { data: Record<string, unknown> }, kind: string): MapThing[] {\n\tconst kept = map.data[kind]\n\tif (!Array.isArray(kept)) return []\n\treturn kept.filter(\n\t\t(thing): thing is MapThing =>\n\t\t\ttypeof thing === 'object' &&\n\t\t\tthing !== null &&\n\t\t\tNumber.isInteger((thing as MapThing).id) &&\n\t\t\tNumber.isFinite((thing as MapThing).x) &&\n\t\t\tNumber.isFinite((thing as MapThing).z)\n\t)\n}\n\n/**\n * Something wrong with a map, as a game sees it: said before the map is played\n *\n * @beta\n */\nexport interface MapProblem {\n\t/** What is wrong, in words, as the editor and the lobby show it */\n\tmessage: string\n\t/** It cannot be played like this. A warning when left out: it can, but probably should not */\n\terror?: boolean\n\t/** Where on the map it is, for the editor to show */\n\tat?: Vec2\n\t/**\n\t * The rule it breaks, by id (`off-map`, `deep-water`…, or a game's own): what silences it, for a map\n\t * (`GameMap.silence`) or a game (`MapEditorDef.silence`). A game's own check that says none is `game`\n\t */\n\trule?: string\n\t/** What it is about: a click on it in the editor selects it */\n\tabout?: MapTarget\n\t/**\n\t * Where it is shown when it is about something of a panel's rather than the map's (a clip of a cinematic): a click on\n\t * it opens that panel at that entry (`editor.panels.reveal(panel, entry)`, as the search of everything does)\n\t */\n\treveal?: { panel: string; entry: string }\n}\n\n/**\n * What a game brings to the map editor, beyond its units: the fields of its own, what can be scattered, its players,\n * and what it takes for a map to be one of its maps. Each that is decided from something can be given as a function\n *\n * @beta\n */\nexport interface MapEditorDef {\n\t/** Fields of the game's own on what is placed on a map, shown in the inspector (see `defineMapField`) */\n\tfields?: MapFieldDef[]\n\t/**\n\t * Unit types the scatter brush puts down many of at once, like a forest. Resources one cell big when left out:\n\t * trees. What is scattered belongs to nobody\n\t */\n\tscatter?: string[] | ((registry: Registry) => string[])\n\t/** Whether the game has creep camps to place. It does when it has a unit type with a bounty, when left out */\n\tcamps?: boolean\n\t/**\n\t * The players of every map of the game, when the game decides who they are, as a tower defense does: the editor\n\t * shows those and only lets their starts be set. Open slots to add and take away when left out\n\t */\n\tplayers?: MapPlayer[] | ((map: GameMap) => MapPlayer[])\n\t/** A line under the players, saying what the game makes of them: who is the player, who gets a base */\n\tplayersNote?: string\n\t/**\n\t * What is wrong with a map as a map of this game: no start for anyone, no way through. Errors keep it from being\n\t * played from the editor; warnings are said\n\t */\n\tcheck?: (map: GameMap, registry: Registry) => MapProblem[]\n\t/** The editor's checks the game does not want, by their rules' ids (`MapProblem.rule`), for every map of it */\n\tsilence?: string[]\n\t/** What the game measures of a map of its own, for the editor's report (`measureMap`): the length of the road */\n\tmeasure?: (map: GameMap, registry: Registry) => GameMeasure[]\n\t/**\n\t * The palette's groups of unit types, each saying whose what is put down from it is and whether it makes camps.\n\t * Units, heroes, buildings, resources (nobody's) and creeps (the creeps', making camps) when left out\n\t */\n\tpalette?: (registry: Registry) => MapPaletteGroup[]\n\t/**\n\t * What the erase brush can be set to take, besides everything and camps. Units, buildings, resources and trees (a\n\t * resource one cell big) when left out\n\t */\n\terase?: MapEraseKind[]\n\t/**\n\t * What the starts must be able to walk to, which the checks look for (`unreachable`): a resource two cells big or\n\t * more when left out, a gold mine and not a tree\n\t */\n\treach?: (def: UnitTypeDef) => boolean\n\t/** The lowest and the highest the ground is raised to. -4 to 16 when left out */\n\theights?: readonly [number, number]\n\t/**\n\t * Where else the game names a thing of a map (a unit type in its waves, a region in a mission's goals): what the\n\t * editor lists under Used by and selects with Find references, beyond what it finds on the map itself (placed\n\t * objects, camps, random groups, the game's fields, prefabs, cinematics). Given the thing asked about and the map\n\t *\n\t * @beta\n\t */\n\treferences?: (ref: MapRef, map: GameMap, registry: Registry) => MapRefUse[]\n}\n\n/**\n * Something of a game or a map that others name: a unit type, a doodad's model, a prefab, a region, a point or a path\n * (by name), a thing named on the map, a cinematic, a file of the game's\n *\n * @beta\n */\nexport type MapRef =\n\t| { type: string }\n\t| { model: string }\n\t| { prefab: string }\n\t| { region: string }\n\t| { point: string }\n\t| { path: string }\n\t| { name: string }\n\t| { cinematic: string }\n\t| { asset: string }\n\n/**\n * What on the map a use is: what a click on it selects\n *\n * @beta\n */\nexport type MapRefTarget =\n\t| { object: number }\n\t| { camp: number }\n\t| { region: number }\n\t| { point: number }\n\t| { path: number }\n\t| { doodad: number }\n\t| { light: number }\n\t| { effect: number }\n\t| { decal: number }\n\t| { sound: number }\n\t| { waterfall: number }\n\t| { mistArea: number }\n\t| { weatherArea: number }\n\t| { cloudPatch: number }\n\t| { pictureZone: number }\n\t| { thing: number; kind: string }\n\n/**\n * One place a thing is named: what names it, where, and what on the map that is\n *\n * @beta\n */\nexport interface MapRefUse {\n\t/** What names it: `placed`, `camp`, `random group`, `field Spawns`, `prefab`, `cinematic`, or the game's own word */\n\twhat: string\n\t/** Where: the map's name, a group's, a prefab's, a cinematic's id, a wave's */\n\twhere: string\n\t/** What on the map the use points at, for the editor to select */\n\ttarget?: MapRefTarget\n}\n\n/**\n * A group of the palette (`MapEditorDef.palette`)\n *\n * @beta\n */\nexport interface MapPaletteGroup {\n\t/** The group's name in the palette */\n\tname: string\n\t/** The unit types in the group */\n\ttypes: UnitTypeDef[]\n\t/**\n\t * Whose what is put down from it is, by player id (`MAP_CREEPS`, `MAP_NEUTRAL`): the player picked above it when\n\t * left out, and nobody for a resource\n\t */\n\towner?: number\n\t/** Its units are what camps are made of: the camp tool picks from them */\n\tcamps?: boolean\n}\n\n/**\n * A kind of thing the erase brush can be set to take (`MapEditorDef.erase`)\n *\n * @beta\n */\nexport interface MapEraseKind {\n\t/** The id of the kind, which `MapEditorDef.erase` lists it by */\n\tid: string\n\t/** What the brush's choice calls it */\n\tname: string\n\t/** Whether a unit type is of this kind: the erase brush takes the objects it says yes to */\n\ttakes: (def: UnitTypeDef) => boolean\n}\n\n/**\n * What the starts must reach when a game does not say: what is mined, not what is cut\n *\n * @internal\n */\nexport const reachedByDefault = (def: UnitTypeDef): boolean => def.kind === 'resource' && footprintOf(def).w >= 2\n\n/**\n * The heights the ground goes from and to when a game does not say\n *\n * @beta\n */\nexport const DEFAULT_HEIGHTS: readonly [number, number] = [-4, 16]\n\n/** What a field of a game's own holds, and so how the editor lets it be set */\n/**\n * What a field holds: a number, words, yes or no, one of a few, a unit type, a player; a region, a point or a path of\n * the map (kept by id, so that a rename does not lose it; handed to the game by name); a colour (`[r, g, b]`, 0 to 1);\n * a list of words; a vector on the ground (`{ x, z }`)\n *\n * @beta\n */\nexport type MapFieldKind = 'number' | 'text' | 'toggle' | 'choice' | 'unit' | 'player' | 'region' | 'point' | 'path' | 'color' | 'list' | 'vector'\n\n/** The kinds of field that name a thing of the map, by its id */\nexport const TARGET_FIELDS = ['region', 'point', 'path'] as const\n\n/**\n * 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\n * 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\n * object (`MapObject.data`). The engine does nothing with it: the `mapObject` hook hands it to the game as the world\n * is made, which is where the game says what it means. Given in `Rules.editor.fields`\n *\n * @beta\n */\nexport interface MapFieldDef {\n\t/** The key it is kept under. Shared by the fields of every mod on the game: give a mod's a prefix */\n\tid: string\n\t/** What the inspector calls it */\n\tname: string\n\t/** A line more, shown when the pointer rests on it */\n\thint?: string\n\t/**\n\t * The fields it is laid out beside in the inspector, by a name they share (`'Position'`): the consecutive fields of\n\t * one group two a line, under its name. Alone when left out\n\t */\n\tgroup?: string\n\t/** What sort of value the field holds, which the inspector edits it with (`MapFieldKind`) */\n\tkind: MapFieldKind\n\t/**\n\t * What it is a field of: objects of these unit types, or of the types a function says yes to (every hero, every\n\t * building that trains something); or camps, or regions; or the map itself (kept in `GameMap.data`, read as\n\t * `world.map.data`), or its players (`MapPlayer.data`, read as `world.map.player(id).data`)\n\t */\n\tfor: string[] | ((def: UnitTypeDef) => boolean) | 'camp' | 'region' | 'map' | 'player'\n\t/** What it is when nothing was set. The game is given this then, and the file does not hold it */\n\tdefault?: unknown\n\t/** For a number: the least and the most it can be, and what the arrows step by */\n\tmin?: number\n\t/** For a number field: the most it can be */\n\tmax?: number\n\t/** For a number field: what the arrows step it by */\n\tstep?: number\n\t/** For a choice: what there is to choose from, as data or worked out from the game */\n\toptions?: readonly MapFieldOption[] | ((registry: Registry) => readonly MapFieldOption[])\n}\n\n/**\n * One of the things a choice field can be: the value kept, and what the inspector calls it when that is not the value\n *\n * @beta\n */\nexport type MapFieldOption = string | { value: string; label: string }\n\n/**\n * Typed help for writing a field\n *\n * @beta\n */\nexport const defineMapField = (def: MapFieldDef): MapFieldDef => def\n\n/** The game's fields: its own (`Rules.editor.fields`) and those of the components it lists (`Component.field`), under the component's id */\nconst fieldsOf = (registry: Registry): readonly MapFieldDef[] => {\n\tconst own = registry.module?.editor?.fields ?? []\n\tlet all: MapFieldDef[] | undefined\n\tfor (const component of registry.listedComponents()) {\n\t\tif (component.field) (all ??= [...own]).push({ ...component.field, id: component.id })\n\t}\n\treturn all ?? own\n}\n\n/**\n * The game's fields for a placed object, by the type it is of. None for a type the game does not have\n *\n * @beta\n */\nexport function objectFields(registry: Registry, type: string): MapFieldDef[] {\n\tif (!registry.units.has(type)) return []\n\tconst def = registry.unit(type)\n\treturn fieldsOf(registry).filter((field) =>\n\t\ttypeof field.for === 'function' ? field.for(def) : Array.isArray(field.for) && field.for.includes(type)\n\t)\n}\n\n/**\n * The game's fields for a camp\n *\n * @beta\n */\nexport const campFields = (registry: Registry): MapFieldDef[] => fieldsOf(registry).filter((field) => field.for === 'camp')\n\n/**\n * The game's fields for a region\n *\n * @beta\n */\nexport const regionFields = (registry: Registry): MapFieldDef[] => fieldsOf(registry).filter((field) => field.for === 'region')\n\n/**\n * The fields of the map itself, and of its players\n *\n * @beta\n */\nexport const mapFields = (registry: Registry): MapFieldDef[] => fieldsOf(registry).filter((field) => field.for === 'map')\n/**\n * The game's fields for players (`for: 'player'`) of a registry, as `MapFieldDef`s\n *\n * @beta\n */\nexport const playerFields = (registry: Registry): MapFieldDef[] => fieldsOf(registry).filter((field) => field.for === 'player')\n\n/**\n * What a choice field can be set to, as values with what each is called\n *\n * @beta\n */\nexport function fieldOptions(registry: Registry, field: MapFieldDef): { value: string; label: string }[] {\n\tconst options = typeof field.options === 'function' ? field.options(registry) : (field.options ?? [])\n\treturn options.map((option) => (typeof option === 'string' ? { value: option, label: option } : option))\n}\n\n/** What the fields of something placed are, with what was not set at its default: what the game is handed */\nexport function fieldValues(fields: readonly MapFieldDef[], data: Record<string, unknown> | undefined, map?: GameMap): Record<string, unknown> {\n\t// what is kept with it and is no field (any more) comes along too: a game may read what an older version of it wrote\n\tconst values: Record<string, unknown> = { ...data }\n\tfor (const field of fields) {\n\t\tif (values[field.id] === undefined && field.default !== undefined) values[field.id] = field.default\n\t\t// a region, a point or a path is kept by id, and handed to the game by its name: what the game finds it by\n\t\tif (map && (TARGET_FIELDS as readonly string[]).includes(field.kind) && typeof values[field.id] === 'number')\n\t\t\tvalues[field.id] = targetName(map, field.kind as (typeof TARGET_FIELDS)[number], values[field.id] as number)\n\t}\n\treturn values\n}\n\n/** The name of a region, a point or a path of a map by its id: undefined for one the map has not (any more) */\nexport function targetName(map: GameMap, kind: (typeof TARGET_FIELDS)[number], id: number): string | undefined {\n\tconst list = kind === 'region' ? map.regions : kind === 'point' ? map.points : map.paths\n\treturn list.find((thing) => thing.id === id)?.name\n}\n\n/**\n * The game's fields of an object or a camp of a map, as the game is handed them\n *\n * @internal\n */\nexport const mapObjectData = (registry: Registry, object: MapObject, map?: GameMap): Record<string, unknown> =>\n\tfieldValues(objectFields(registry, object.type), object.data, map)\n/**\n * The game's fields of a camp, with the values it kept and the defaults for the rest; what the `mapCamp` hook hands the game\n *\n * @internal\n */\nexport const mapCampData = (registry: Registry, camp: MapCamp, map?: GameMap): Record<string, unknown> =>\n\tfieldValues(campFields(registry), camp.data, map)\n/**\n * The game's fields of a region, with the values it kept and the defaults for the rest; what the `mapRegion` hook hands the game\n *\n * @internal\n */\nexport const mapRegionData = (registry: Registry, region: MapRegion, map?: GameMap): Record<string, unknown> =>\n\tfieldValues(regionFields(registry), region.data, map)\n/**\n * The game's fields of a player, with the values it kept and the defaults for the rest; what the game reads as `world.map.player(id).data`\n *\n * @internal\n */\nexport const mapPlayerData = (registry: Registry, player: MapPlayer, map?: GameMap): Record<string, unknown> =>\n\tfieldValues(playerFields(registry), player.data, map)\n"],"mappings":"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"}

package/dist/mapFile.js

@@ -0,0 +1,176 @@
+import { BY_ID, fieldsOf } from "./map/schema.js";
+import { serializeMap } from "./map/file.js";
+//#region src/mapFile.ts
+/** The order the parts of a map come in in its file. What is not listed comes after, by name */
+var PARTS = [
+	"format",
+	"name",
+	"description",
+	"author",
+	"meantFor",
+	"loading",
+	"explored",
+	"silence",
+	"game",
+	"width",
+	"depth",
+	"cliffHeight",
+	"data",
+	"editor",
+	"players",
+	"regions",
+	"points",
+	"paths",
+	"doodads",
+	"cameras",
+	"randomGroups",
+	"itemTables",
+	"definitions",
+	"forces",
+	"races",
+	"environment",
+	"day",
+	"camps",
+	"objects",
+	"tileset",
+	"preview"
+];
+/** The layers come last: lines nobody reads, a row of the ground to each (the map's table says which: `MAP_FIELDS`) */
+var LAYERS = [...fieldsOf("layer", "layers").map((field) => field.key)];
+/** Lists with one entry to a line, in the order of their ids */
+var LISTS = new Set(BY_ID);
+/** The order of what an entry holds. What is not listed comes after, by name */
+var FIELDS = [
+	"id",
+	"name",
+	"type",
+	"owner",
+	"team",
+	"color",
+	"race",
+	"start",
+	"x",
+	"z",
+	"facing",
+	"scale",
+	"look",
+	"units",
+	"shape",
+	"points",
+	"width",
+	"paint",
+	"keepClear",
+	"profile",
+	"health",
+	"mana",
+	"level",
+	"abilities",
+	"items",
+	"amount",
+	"underConstruction",
+	"lifetime",
+	"orders",
+	"data"
+];
+/** The keys of something in a set order: those listed first, in that order, then the rest by name */
+function inOrder(value, first) {
+	const keys = Object.keys(value);
+	return [...first.filter((key) => keys.includes(key)), ...keys.filter((key) => !first.includes(key)).sort()];
+}
+var entryText = (entry) => `{ ${inOrder(entry, FIELDS).filter((key) => entry[key] !== void 0).map((key) => `${JSON.stringify(key)}: ${JSON.stringify(entry[key])}`).join(", ")} }`;
+/**
+* A map as the text of its file, written to be read by a person comparing two versions of it: every part on a line
+* of its own in a set order, one object to a line in the order of their ids with what each holds in a set order
+* too, and the layers last. Moving one object changes one line, whatever was done before
+*
+* @beta
+*/
+function mapText(map) {
+	const file = serializeMap(map);
+	return `{\n${inOrder(file, [...PARTS, ...LAYERS]).sort((a, b) => Number(LAYERS.includes(a)) - Number(LAYERS.includes(b))).map((key) => {
+		const value = file[key];
+		if (key === "cells" && value && typeof value === "object") return `\t"cells": {\n${Object.entries(value).map(([id, rows]) => `\t\t${JSON.stringify(id)}: [\n${rows.map((row) => `\t\t\t${JSON.stringify(row)}`).join(",\n")}\n\t\t]`).join(",\n")}\n\t}`;
+		if (LAYERS.includes(key) && Array.isArray(value)) return `\t${JSON.stringify(key)}: [\n${value.map((row) => `\t\t${JSON.stringify(row)}`).join(",\n")}\n\t]`;
+		if (!LISTS.has(key) || !Array.isArray(value)) return `\t${JSON.stringify(key)}: ${JSON.stringify(value)}`;
+		if (!value.length) return `\t${JSON.stringify(key)}: []`;
+		const entries = [...value].sort((a, b) => a.id - b.id);
+		return `\t${JSON.stringify(key)}: [\n${entries.map((entry) => `\t\t${entryText(entry)}`).join(",\n")}\n\t]`;
+	}).join(",\n")}\n}\n`;
+}
+/**
+* What a map file is called, without what comes after the first dot: the name of the map in small letters, with a
+* dash for whatever is not a letter or a number. `The Pass!` is `the-pass`
+*
+* @beta
+*/
+function mapFileStem(name) {
+	return name.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "map";
+}
+/** A stem as the start of the name of a type: `the-pass` is `ThePass` */
+var typeName = (stem) => {
+	const name = stem.replace(/(^|-)([a-z0-9])/g, (_, __, letter) => letter.toUpperCase());
+	return /^[0-9]/.test(name) ? `Map${name}` : name;
+};
+/** A name as TypeScript writes text, in single quotes as the rest of the code has it. Whatever is in it stays inside */
+var quoted = (name) => `'${JSON.stringify(name).slice(1, -1).replace(/\\"/g, "\"").replace(/'/g, "\\'")}'`;
+/** The names as a type: one to a line, so that naming one more thing changes one line */
+var union = (names) => names.length ? [...names].sort().map((name) => `\n\t| ${quoted(name)}`).join("") : " never";
+/**
+* The names of what is on a map as TypeScript, for a game's code to use: `world.named<RoadNames>('gaet')` does not
+* compile. The editor writes it next to the map (`road.names.ts` for `road.vgmap.json`), anew with every save
+*
+* @beta
+*/
+function mapNamesSource(stem, map) {
+	const type = typeName(stem);
+	const objects = map.objects.flatMap((object) => object.name ? [object.name] : []);
+	const camps = map.camps.flatMap((camp) => camp.name ? [camp.name] : []);
+	const regions = map.regions.map((region) => region.name);
+	const points = map.points.map((point) => point.name);
+	const paths = map.paths.map((path) => path.name);
+	const lights = namesIn(map.environment, "lights");
+	const effects = namesIn(map.environment, "fx");
+	return [
+		`// Written by the map editor with ${stem}.vgmap.json, anew with every save: not to be changed by hand`,
+		"",
+		`/** What is named on the map, for \`world.named<${type}Names>(...)\` */`,
+		`export type ${type}Names =${union(objects)}`,
+		"",
+		`/** The camps that are named on the map, for \`campNamed(world, ...)\` */`,
+		`export type ${type}Camps =${union(camps)}`,
+		"",
+		`/** The regions of the map, for \`world.areas\` and \`enteredArea\` */`,
+		`export type ${type}Regions =${union(regions)}`,
+		"",
+		`/** The points of the map, for \`world.map.point(...)\` */`,
+		`export type ${type}Points =${union(points)}`,
+		"",
+		`/** The paths of the map, for \`world.map.path(...)\` */`,
+		`export type ${type}Paths =${union(paths)}`,
+		"",
+		`/** The lights of the map that are named, for \`client.lights.named(...)\` */`,
+		`export type ${type}Lights =${union(lights)}`,
+		"",
+		`/** The effects of the map that are named, for \`client.mapFx.named(...)\` */`,
+		`export type ${type}Fx =${union(effects)}`,
+		"",
+		`/** The ids of the regions, points and paths by name: what a field that names one keeps (it is handed the name) */`,
+		`export const ${type}Ids = ${idsOf(map)} as const`,
+		""
+	].join("\n");
+}
+/** The names of the things of a list of a map's environment that have one (`lights`, `fx`), as plain data */
+function namesIn(environment, list) {
+	const things = environment?.[list];
+	if (!Array.isArray(things)) return [];
+	return things.flatMap((thing) => typeof thing?.name === "string" && thing.name ? [thing.name] : []);
+}
+/** The ids of a map's regions, points and paths by name, as the text of an object */
+function idsOf(map) {
+	const part = (things) => `{ ${things.map((thing) => `${JSON.stringify(thing.name)}: ${thing.id}`).join(", ")} }`;
+	return `{ regions: ${part(map.regions)}, points: ${part(map.points)}, paths: ${part(map.paths)} }`;
+}
+//#endregion
+export { mapFileStem, mapNamesSource, mapText };
+
+//# sourceMappingURL=mapFile.js.map

package/dist/mapFile.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapFile.js","names":[],"sources":["../src/mapFile.ts"],"sourcesContent":["import { type GameMap, type MapFile, serializeMap } from './map'\nimport { BY_ID, fieldsOf } from './map/schema'\n\n/** The order the parts of a map come in in its file. What is not listed comes after, by name */\nconst PARTS: (keyof MapFile)[] = [\n\t'format',\n\t'name',\n\t'description',\n\t'author',\n\t'meantFor',\n\t'loading',\n\t'explored',\n\t'silence',\n\t'game',\n\t'width',\n\t'depth',\n\t'cliffHeight',\n\t'data',\n\t'editor',\n\t'players',\n\t'regions',\n\t'points',\n\t'paths',\n\t'doodads',\n\t'cameras',\n\t'randomGroups',\n\t'itemTables',\n\t'definitions',\n\t'forces',\n\t'races',\n\t'environment',\n\t'day',\n\t'camps',\n\t'objects',\n\t'tileset',\n\t'preview'\n]\n/** The layers come last: lines nobody reads, a row of the ground to each (the map's table says which: `MAP_FIELDS`) */\nconst LAYERS: (keyof MapFile)[] = [...fieldsOf('layer', 'layers').map((field) => field.key as keyof MapFile)]\n/** Lists with one entry to a line, in the order of their ids */\nconst LISTS = new Set<string>(BY_ID)\n/** The order of what an entry holds. What is not listed comes after, by name */\nconst FIELDS = [\n\t'id',\n\t'name',\n\t'type',\n\t'owner',\n\t'team',\n\t'color',\n\t'race',\n\t'start',\n\t'x',\n\t'z',\n\t'facing',\n\t'scale',\n\t'look',\n\t'units',\n\t'shape',\n\t'points',\n\t'width',\n\t'paint',\n\t'keepClear',\n\t'profile',\n\t'health',\n\t'mana',\n\t'level',\n\t'abilities',\n\t'items',\n\t'amount',\n\t'underConstruction',\n\t'lifetime',\n\t'orders',\n\t'data'\n]\n\n/** The keys of something in a set order: those listed first, in that order, then the rest by name */\nfunction inOrder(value: object, first: readonly string[]): string[] {\n\tconst keys = Object.keys(value)\n\tconst listed = first.filter((key) => keys.includes(key))\n\treturn [...listed, ...keys.filter((key) => !first.includes(key)).sort()]\n}\n\nconst entryText = (entry: Record<string, unknown>): string =>\n\t`{ ${inOrder(entry, FIELDS)\n\t\t.filter((key) => entry[key] !== undefined)\n\t\t.map((key) => `${JSON.stringify(key)}: ${JSON.stringify(entry[key])}`)\n\t\t.join(', ')} }`\n\n/**\n * A map as the text of its file, written to be read by a person comparing two versions of it: every part on a line\n * of its own in a set order, one object to a line in the order of their ids with what each holds in a set order\n * too, and the layers last. Moving one object changes one line, whatever was done before\n *\n * @beta\n */\nexport function mapText(map: GameMap): string {\n\tconst file = serializeMap(map) as unknown as Record<string, unknown>\n\tconst lines = inOrder(file, [...PARTS, ...LAYERS])\n\t\t// the rest, which this version does not know, goes between what it knows and the layers\n\t\t.sort((a, b) => Number(LAYERS.includes(a as keyof MapFile)) - Number(LAYERS.includes(b as keyof MapFile)))\n\t\t.map((key) => {\n\t\t\tconst value = file[key]\n\t\t\t// the game's layers of cells: a row to a line, as the layers of the ground\n\t\t\tif (key === 'cells' && value && typeof value === 'object')\n\t\t\t\treturn `\\t\"cells\": {\\n${Object.entries(value as Record<string, string[]>)\n\t\t\t\t\t.map(([id, rows]) => `\\t\\t${JSON.stringify(id)}: [\\n${rows.map((row) => `\\t\\t\\t${JSON.stringify(row)}`).join(',\\n')}\\n\\t\\t]`)\n\t\t\t\t\t.join(',\\n')}\\n\\t}`\n\t\t\t// a layer of the ground: a row to a line, so that a change to one row changes one line, which git merges\n\t\t\tif (LAYERS.includes(key as keyof MapFile) && Array.isArray(value))\n\t\t\t\treturn `\\t${JSON.stringify(key)}: [\\n${value.map((row) => `\\t\\t${JSON.stringify(row)}`).join(',\\n')}\\n\\t]`\n\t\t\tif (!LISTS.has(key) || !Array.isArray(value)) return `\\t${JSON.stringify(key)}: ${JSON.stringify(value)}`\n\t\t\tif (!value.length) return `\\t${JSON.stringify(key)}: []`\n\t\t\tconst entries = [...(value as { id: number }[])].sort((a, b) => a.id - b.id)\n\t\t\treturn `\\t${JSON.stringify(key)}: [\\n${entries.map((entry) => `\\t\\t${entryText(entry as unknown as Record<string, unknown>)}`).join(',\\n')}\\n\\t]`\n\t\t})\n\treturn `{\\n${lines.join(',\\n')}\\n}\\n`\n}\n\n/**\n * What a map file is called, without what comes after the first dot: the name of the map in small letters, with a\n * dash for whatever is not a letter or a number. `The Pass!` is `the-pass`\n *\n * @beta\n */\nexport function mapFileStem(name: string): string {\n\treturn (\n\t\tname\n\t\t\t.trim()\n\t\t\t.toLowerCase()\n\t\t\t.replace(/[^a-z0-9]+/g, '-')\n\t\t\t.replace(/^-|-$/g, '') || 'map'\n\t)\n}\n\n/** A stem as the start of the name of a type: `the-pass` is `ThePass` */\nconst typeName = (stem: string) => {\n\tconst name = stem.replace(/(^|-)([a-z0-9])/g, (_, __, letter: string) => letter.toUpperCase())\n\t// a type does not start with a number\n\treturn /^[0-9]/.test(name) ? `Map${name}` : name\n}\n\n/** A name as TypeScript writes text, in single quotes as the rest of the code has it. Whatever is in it stays inside */\nconst quoted = (name: string) => `'${JSON.stringify(name).slice(1, -1).replace(/\\\\\"/g, '\"').replace(/'/g, \"\\\\'\")}'`\n\n/** The names as a type: one to a line, so that naming one more thing changes one line */\nconst union = (names: string[]) =>\n\tnames.length\n\t\t? [...names]\n\t\t\t\t.sort()\n\t\t\t\t.map((name) => `\\n\\t| ${quoted(name)}`)\n\t\t\t\t.join('')\n\t\t: ' never'\n\n/**\n * The names of what is on a map as TypeScript, for a game's code to use: `world.named<RoadNames>('gaet')` does not\n * compile. The editor writes it next to the map (`road.names.ts` for `road.vgmap.json`), anew with every save\n *\n * @beta\n */\nexport function mapNamesSource(stem: string, map: GameMap): string {\n\tconst type = typeName(stem)\n\tconst objects = map.objects.flatMap((object) => (object.name ? [object.name] : []))\n\tconst camps = map.camps.flatMap((camp) => (camp.name ? [camp.name] : []))\n\tconst regions = map.regions.map((region) => region.name)\n\tconst points = map.points.map((point) => point.name)\n\tconst paths = map.paths.map((path) => path.name)\n\t// what the client draws (its lights and effects) by name, as plain data: the engine knows nothing more of them\n\tconst lights = namesIn(map.environment, 'lights')\n\tconst effects = namesIn(map.environment, 'fx')\n\treturn [\n\t\t`// Written by the map editor with ${stem}.vgmap.json, anew with every save: not to be changed by hand`,\n\t\t'',\n\t\t`/** What is named on the map, for \\`world.named<${type}Names>(...)\\` */`,\n\t\t`export type ${type}Names =${union(objects)}`,\n\t\t'',\n\t\t`/** The camps that are named on the map, for \\`campNamed(world, ...)\\` */`,\n\t\t`export type ${type}Camps =${union(camps)}`,\n\t\t'',\n\t\t`/** The regions of the map, for \\`world.areas\\` and \\`enteredArea\\` */`,\n\t\t`export type ${type}Regions =${union(regions)}`,\n\t\t'',\n\t\t`/** The points of the map, for \\`world.map.point(...)\\` */`,\n\t\t`export type ${type}Points =${union(points)}`,\n\t\t'',\n\t\t`/** The paths of the map, for \\`world.map.path(...)\\` */`,\n\t\t`export type ${type}Paths =${union(paths)}`,\n\t\t'',\n\t\t`/** The lights of the map that are named, for \\`client.lights.named(...)\\` */`,\n\t\t`export type ${type}Lights =${union(lights)}`,\n\t\t'',\n\t\t`/** The effects of the map that are named, for \\`client.mapFx.named(...)\\` */`,\n\t\t`export type ${type}Fx =${union(effects)}`,\n\t\t'',\n\t\t`/** The ids of the regions, points and paths by name: what a field that names one keeps (it is handed the name) */`,\n\t\t`export const ${type}Ids = ${idsOf(map)} as const`,\n\t\t''\n\t].join('\\n')\n}\n\n/** The names of the things of a list of a map's environment that have one (`lights`, `fx`), as plain data */\nfunction namesIn(environment: object | undefined, list: string): string[] {\n\tconst things = (environment as Record<string, unknown> | undefined)?.[list]\n\tif (!Array.isArray(things)) return []\n\treturn things.flatMap((thing) =>\n\t\ttypeof (thing as { name?: unknown })?.name === 'string' && (thing as { name: string }).name ? [(thing as { name: string }).name] : []\n\t)\n}\n\n/** The ids of a map's regions, points and paths by name, as the text of an object */\nfunction idsOf(map: GameMap): string {\n\tconst part = (things: readonly { id: number; name: string }[]) =>\n\t\t`{ ${things.map((thing) => `${JSON.stringify(thing.name)}: ${thing.id}`).join(', ')} }`\n\treturn `{ regions: ${part(map.regions)}, points: ${part(map.points)}, paths: ${part(map.paths)} }`\n}\n"],"mappings":"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"}

package/dist/mapMeasure.d.ts

@@ -8,7 +8,9 @@ import type { Registry } from './registry';
  * @beta
  */
 export interface Walk {
+    /** The length of the way, in cells */
     length: number;
+    /** The points the way goes through, from its start to its end */
     points: Vec2[];
 }
 /**
@@ -23,7 +25,9 @@ export declare function walkBetween(map: GameMap, registry: Registry, from: Vec2
  * @beta
  */
 export interface StartMeasure {
+    /** The player the start is for */
     player: PlayerId;
+    /** The start's name, as the map names its player */
     name: string;
     /** The way on foot to the nearest mine, and how much it holds. Nothing without a mine they can walk to */
     mine?: {
@@ -42,7 +46,9 @@ export interface StartMeasure {
  * @beta
  */
 export interface GameMeasure {
+    /** The name of the measure, as the editor shows it */
     name: string;
+    /** The measured number or text */
     value: number | string;
 }
 /**
@@ -63,9 +69,11 @@ export interface MapReport {
         width: number;
         at: Vec2;
     };
+    /** The measure of every player's start */
     starts: StartMeasure[];
     /** What each start has that another has more than `FAIR_MARGIN` more of: what is not fair */
     unfair: string[];
+    /** The numbers the game measures of its own (`MapEditorDef.measure`) */
     game: GameMeasure[];
 }
 /**