@v12-engine/engine 0.1.1 → 0.4.0

package/dist/map/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","names":[],"sources":["../../src/map/schema.ts"],"sourcesContent":["/*\n * The fields of a map, once (design review E8a): each with what it is (`kind`), when its file has it, what a map has\n * of it where the file has none, and the words a file that is wrong in it is told in. What reads and writes a map file\n * (`parseMap`, `serializeMap`, the parts it knows), copies one (`cloneMap`), grows one (`resizeMap`), merges two\n * (`mergeMaps`) and writes it for a person to read (`mapText`) goes by this table, so that a field is added in one place\n */\nimport type { GameMap } from './types'\n\n/**\n * What a field of a map is:\n * - `text`, `number`, `boolean`: one value\n * - `layer`: a layer of the ground, a value per cell (or per corner, `perVertex`, four bytes each: the heights), a\n *   line of text a row in the file, merged cell by cell\n * - `layers`: the game's layers of cells, by id, each as a `layer` is written; merged whole\n * - `mask`: a layer that a map may have none of (what is kept off cells by hand), written where anything is set\n * - `list`: a list of plain objects, those of `byId` with an id each (merged thing by thing, a line each in `mapText`)\n * - `names`: a list of names\n * - `object`: plain data, kept as it is\n *\n * @internal\n */\nexport type MapFieldKind = 'text' | 'number' | 'boolean' | 'layer' | 'layers' | 'mask' | 'list' | 'names' | 'object'\n\n/**\n * A field of a map, as the table has it\n *\n * @internal\n */\nexport interface MapFieldSpec {\n\tkey: keyof GameMap\n\tkind: MapFieldKind\n\t/**\n\t * When the file has it: `always`; `defined` where the map has it; `filled` where it holds anything (text not empty,\n\t * a list or an object with something in it, a mask with a cell set)\n\t */\n\twritten: 'always' | 'defined' | 'filled'\n\t/**\n\t * What a map has where the file has none, or nothing of the kind asked: none (the field left out) when left out. A\n\t * `list` or a `layer` the file must have where `required`\n\t */\n\tempty?: () => unknown\n\t/** A file without it, or with something else in its place, is no map (`Map file: ... is missing`) */\n\trequired?: boolean\n\t/** For a layer: one by corner of the ground (the heights, four bytes each), not by cell */\n\tperVertex?: boolean\n\t/** For a list: of things with an id each */\n\tbyId?: boolean\n\t/** What a file that is wrong in it is told it is, for a layer: `Map file: the ground does not match the size of the map` */\n\twhat?: string\n\t/** A field kept as plain data only, said where it is not: what the game and the editor keep with a map */\n\tplain?: boolean\n}\n\n/**\n * Every field of a map, in the order its file has them (`format` before them, what the reader does not know of the\n * file before that). `satisfies` checks that none of `GameMap` is left out\n *\n * @internal\n */\nexport const MAP_FIELDS = [\n\t{ key: 'name', kind: 'text', written: 'always', empty: () => 'Untitled' },\n\t{ key: 'description', kind: 'text', written: 'always', empty: () => '' },\n\t{ key: 'game', kind: 'text', written: 'defined' },\n\t{ key: 'width', kind: 'number', written: 'always', required: true },\n\t{ key: 'depth', kind: 'number', written: 'always', required: true },\n\t{ key: 'cliffHeight', kind: 'number', written: 'always', empty: () => 3 },\n\t{ key: 'ground', kind: 'layer', written: 'always', required: true, perVertex: true, what: 'the ground' },\n\t{ key: 'levels', kind: 'layer', written: 'always', required: true, what: 'the levels' },\n\t{ key: 'ramps', kind: 'layer', written: 'always', required: true, what: 'the ramps' },\n\t{ key: 'water', kind: 'layer', written: 'always', required: true, what: 'the water' },\n\t{ key: 'tiles', kind: 'layer', written: 'always', required: true, what: 'the paint' },\n\t{ key: 'cells', kind: 'layers', written: 'filled' },\n\t{ key: 'pathing', kind: 'mask', written: 'filled', what: 'what is kept off cells' },\n\t{ key: 'tileset', kind: 'names', written: 'always', required: true, what: 'the tileset' },\n\t{ key: 'players', kind: 'list', written: 'always', required: true, byId: true },\n\t{ key: 'objects', kind: 'list', written: 'always', required: true, byId: true },\n\t{ key: 'camps', kind: 'list', written: 'always', required: true, byId: true },\n\t{ key: 'regions', kind: 'list', written: 'filled', byId: true, empty: () => [] },\n\t{ key: 'points', kind: 'list', written: 'filled', byId: true, empty: () => [] },\n\t{ key: 'paths', kind: 'list', written: 'filled', byId: true, empty: () => [] },\n\t{ key: 'doodads', kind: 'list', written: 'filled', byId: true, empty: () => [] },\n\t{ key: 'cameras', kind: 'list', written: 'filled', byId: true, empty: () => [] },\n\t{ key: 'randomGroups', kind: 'list', written: 'filled' },\n\t{ key: 'itemTables', kind: 'list', written: 'filled' },\n\t{ key: 'forces', kind: 'list', written: 'filled' },\n\t{ key: 'races', kind: 'names', written: 'filled' },\n\t{ key: 'author', kind: 'text', written: 'filled' },\n\t{ key: 'silence', kind: 'names', written: 'filled' },\n\t{ key: 'meantFor', kind: 'text', written: 'filled' },\n\t{ key: 'explored', kind: 'boolean', written: 'defined' },\n\t{ key: 'loading', kind: 'text', written: 'filled' },\n\t{ key: 'preview', kind: 'text', written: 'filled' },\n\t{ key: 'environment', kind: 'object', written: 'filled' },\n\t{ key: 'definitions', kind: 'object', written: 'filled', plain: true },\n\t{ key: 'generated', kind: 'object', written: 'defined' },\n\t{ key: 'day', kind: 'object', written: 'filled' },\n\t{ key: 'bounds', kind: 'object', written: 'defined' },\n\t{ key: 'data', kind: 'object', written: 'filled', empty: () => ({}), plain: true },\n\t{ key: 'editor', kind: 'object', written: 'filled', plain: true }\n] as const satisfies readonly MapFieldSpec[]\n\n/** The keys of `GameMap` the table has, and those it has not: none but what the reader keeps of the file (`extra`) */\ntype Missing = Exclude<keyof GameMap, (typeof MAP_FIELDS)[number]['key'] | 'extra'>\n// a field of GameMap the table does not have is a type error here\nconst everyField: [Missing] extends [never] ? true : Missing = true\nvoid everyField\n\n/** The fields as specs, for what walks them */\nexport const MAP_FIELD_SPECS: readonly MapFieldSpec[] = MAP_FIELDS\n\n/** What a reader of this format knows in a file: `format` and every field. The rest is carried along (`GameMap.extra`) */\nexport const KNOWN: ReadonlySet<string> = new Set(['format', ...MAP_FIELDS.map((field) => field.key)])\n\n/** The fields of a kind */\nexport const fieldsOf = (...kinds: MapFieldKind[]): readonly MapFieldSpec[] => MAP_FIELD_SPECS.filter((field) => kinds.includes(field.kind))\n\n/** The lists of things with ids: merged thing by thing (`mergeMaps`), an entry to a line (`mapText`) */\nexport const BY_ID: readonly string[] = MAP_FIELD_SPECS.filter((field) => field.byId).map((field) => field.key)\n\n/** The layers of the ground every map has: merged cell by cell (`mergeMaps`), a row to a line (`mapText`) */\nexport const LAYERS: readonly ('ground' | 'levels' | 'ramps' | 'water' | 'tiles')[] = fieldsOf('layer').map(\n\t(field) => field.key as 'ground' | 'levels' | 'ramps' | 'water' | 'tiles'\n)\n"],"mappings":"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"}

package/dist/map/terrain.js

@@ -0,0 +1,214 @@
+import { hypot } from "../exactMath.js";
+import { clamp } from "../math.js";
+import "./types.js";
+import { Path } from "../paths.js";
+import { tileRemap } from "../tiles.js";
+import { Terrain } from "../terrain.js";
+import { WATER_DEPTH, profiledGround } from "./pathProfile.js";
+//#region src/map/terrain.ts
+/** How far below the banks the water stands */
+var WATER_SURFACE = .18;
+/**
+* The terrain a map describes
+*
+* @beta
+*/
+function mapTerrain(map) {
+	const terrain = new Terrain(map.width, map.depth, new Float32Array(map.ground.length), new Uint8Array(map.levels.length), {
+		water: new Uint8Array(map.water.length),
+		tiles: new Uint8Array(map.tiles.length)
+	});
+	updateMapTerrain(map, terrain);
+	return terrain;
+}
+/**
+* What the doodads of a map keep off its cells, and what is kept off them by hand (`GameMap.pathing`), into the
+* terrain (`Terrain.blocked`): the most any of them keeps off. With `area` (cells), there alone: what the layers changed
+* there (a brush's step), the doodads elsewhere as they were; the whole map where a doodad itself changed
+*
+* @beta
+*/
+function blockByDoodads(map, terrain, area) {
+	const { blocked } = terrain;
+	const x0 = area ? Math.max(Math.floor(area.x), 0) : 0;
+	const z0 = area ? Math.max(Math.floor(area.z), 0) : 0;
+	const x1 = area ? Math.min(Math.ceil(area.x + area.width), map.width) : map.width;
+	const z1 = area ? Math.min(Math.ceil(area.z + area.depth), map.depth) : map.depth;
+	if (x1 <= x0 || z1 <= z0) return;
+	const byHand = map.pathing && map.pathing.length === blocked.length ? map.pathing : void 0;
+	for (let cz = z0; cz < z1; cz++) for (let c = cz * map.width + x0; c < cz * map.width + x1; c++) blocked[c] = byHand ? Math.min(byHand[c], 2) : 0;
+	for (const doodad of map.doodads ?? []) {
+		if (!doodad.radius) continue;
+		if (doodad.x + doodad.radius < x0 || doodad.x - doodad.radius > x1 || doodad.z + doodad.radius < z0 || doodad.z - doodad.radius > z1) continue;
+		const kind = doodad.bridge ? 3 : doodad.gate ? 1 : doodad.blocks === "walk" ? 2 : doodad.blocks ? 1 : 0;
+		if (!kind) continue;
+		const { radius } = doodad;
+		for (let cz = Math.max(Math.floor(doodad.z - radius), z0); cz < Math.min(Math.ceil(doodad.z + radius), z1); cz++) for (let cx = Math.max(Math.floor(doodad.x - radius), x0); cx < Math.min(Math.ceil(doodad.x + radius), x1); cx++) {
+			if (hypot(cx + .5 - doodad.x, cz + .5 - doodad.z) > radius) continue;
+			const c = cz * map.width + cx;
+			blocked[c] = kind === 3 || blocked[c] === 3 ? blocked[c] === 2 ? 2 : 3 : Math.max(blocked[c], kind);
+		}
+	}
+	const row = map.width + 1;
+	for (const doodad of map.doodads ?? []) {
+		if (!doodad.bridge || !doodad.radius) continue;
+		if (doodad.x + doodad.radius < x0 || doodad.x - doodad.radius > x1 || doodad.z + doodad.radius < z0 || doodad.z - doodad.radius > z1) continue;
+		for (let cz = Math.max(Math.floor(doodad.z - doodad.radius), 0); cz < Math.min(Math.ceil(doodad.z + doodad.radius), map.depth); cz++) for (let cx = Math.max(Math.floor(doodad.x - doodad.radius), 0); cx < Math.min(Math.ceil(doodad.x + doodad.radius), map.width); cx++) {
+			if (hypot(cx + .5 - doodad.x, cz + .5 - doodad.z) > doodad.radius) continue;
+			for (const v of [
+				cz * row + cx,
+				cz * row + cx + 1,
+				(cz + 1) * row + cx,
+				(cz + 1) * row + cx + 1
+			]) {
+				const deck = Math.max(terrain.waterHeights[v], terrain.heights[v]) + (doodad.y ?? 0);
+				if (terrain.heights[v] < deck) terrain.heights[v] = deck;
+			}
+		}
+	}
+}
+/**
+* How far a change to a cell reaches into the terrain: a ramp's slope is the average of the levels within
+* `RAMP_REACH`, and a ramp cell's level is its corners'
+*/
+var REACH = 4;
+/**
+* Brings a terrain of the same size in line with the layers of a map, in place, for editing. With `area`, only what
+* a change to those cells can have changed: the cells and the corners of cells within reach of it. Returns the cells
+* whose terrain was worked out again, for whoever draws it to draw again: their corners are the vertices that changed
+*
+* @beta
+*/
+function updateMapTerrain(map, terrain, area) {
+	const { width, depth, cliffHeight, levels, ramps, water, ground } = map;
+	if (terrain.width !== width || terrain.depth !== depth) throw new Error("updateMapTerrain: the terrain is not the size of the map");
+	terrain.bounds = map.bounds && { ...map.bounds };
+	const vx = width + 1;
+	const x0 = area ? Math.max(Math.floor(area.x) - REACH, 0) : 0;
+	const z0 = area ? Math.max(Math.floor(area.z) - REACH, 0) : 0;
+	const x1 = area ? Math.min(Math.ceil(area.x + area.width) + REACH, width) : width;
+	const z1 = area ? Math.min(Math.ceil(area.z + area.depth) + REACH, depth) : depth;
+	const rowLength = x1 - x0 + 1;
+	const carved = profiledGround(map, x0, z0, x1, z1);
+	const cellRow = rowLength + 1;
+	const waterAt = (c, cx, cz) => carved?.water ? Math.max(water[c], carved.water[(cz - z0 + 1) * cellRow + (cx - x0 + 1)]) : water[c];
+	const vertexLevels = new Float32Array(rowLength * (z1 - z0 + 1));
+	for (let iz = z0; iz <= z1; iz++) for (let ix = x0; ix <= x1; ix++) {
+		let top = 0;
+		let onRamp = false;
+		let depthSum = 0;
+		let wetLevel = Infinity;
+		for (let cz = iz - 1; cz <= iz; cz++) for (let cx = ix - 1; cx <= ix; cx++) {
+			if (cx < 0 || cz < 0 || cx >= width || cz >= depth) continue;
+			const c = cz * width + cx;
+			top = Math.max(top, levels[c]);
+			if (ramps[c]) onRamp = true;
+			const wet = waterAt(c, cx, cz);
+			depthSum += WATER_DEPTH[wet] ?? 0;
+			if (wet) wetLevel = Math.min(wetLevel, levels[c]);
+		}
+		const v = iz * vx + ix;
+		const level = onRamp ? averageLevel(map, ix, iz) : top;
+		vertexLevels[(iz - z0) * rowLength + (ix - x0)] = level;
+		const under = carved ? carved.ground[(iz - z0) * rowLength + (ix - x0)] : ground[v];
+		const land = under + level * cliffHeight;
+		terrain.heights[v] = land - depthSum / 4;
+		terrain.waterHeights[v] = under + Math.min(wetLevel, level) * cliffHeight - WATER_SURFACE;
+	}
+	const levelAt = (ix, iz) => vertexLevels[(iz - z0) * rowLength + (ix - x0)];
+	for (let cz = z0; cz < z1; cz++) for (let cx = x0; cx < x1; cx++) {
+		const c = cz * width + cx;
+		terrain.water[c] = waterAt(c, cx, cz);
+		terrain.tiles[c] = map.tiles[c];
+		for (const id in map.cells) terrain.cellLayer(id)[c] = map.cells[id][c];
+		if (!ramps[c]) {
+			terrain.levels[c] = levels[c];
+			continue;
+		}
+		const middle = (levelAt(cx, cz) + levelAt(cx + 1, cz) + levelAt(cx, cz + 1) + levelAt(cx + 1, cz + 1)) / 4;
+		terrain.levels[c] = Math.floor(middle + .5);
+	}
+	const touched = {
+		x: x0,
+		z: z0,
+		width: x1 - x0,
+		depth: z1 - z0
+	};
+	paintPaths(map, terrain.tiles, touched);
+	blockByDoodads(map, terrain, area && touched);
+	return touched;
+}
+/**
+* Paints the ground under the paths that say so, over the paint of the map: the tiles are those of the map's tileset.
+* Within `area` only, when it is given
+*/
+function paintPaths(map, tiles, area = {
+	x: 0,
+	z: 0,
+	width: map.width,
+	depth: map.depth
+}) {
+	const width = area.x + area.width;
+	const depth = area.z + area.depth;
+	for (const def of map.paths) {
+		const bed = def.profile?.ground !== void 0;
+		const paint = bed ? def.profile.ground : def.paint;
+		const wide = bed ? def.profile.width ?? def.width : def.width;
+		const tile = paint === void 0 ? 0 : map.tileset.indexOf(paint) + 1;
+		if (!tile || !def.points.length) continue;
+		const path = new Path(def.points, wide);
+		const reach = wide / 2 + 1;
+		const xs = def.points.map((point) => point.x);
+		const zs = def.points.map((point) => point.z);
+		for (let cz = Math.max(Math.floor(Math.min(...zs) - reach), area.z); cz < Math.min(Math.ceil(Math.max(...zs) + reach), depth); cz++) for (let cx = Math.max(Math.floor(Math.min(...xs) - reach), area.x); cx < Math.min(Math.ceil(Math.max(...xs) + reach), width); cx++) if (path.containsCell(cx, cz)) tiles[cz * map.width + cx] = tile;
+	}
+}
+/** Average level of the cells within ramp reach of a vertex */
+function averageLevel(map, ix, iz) {
+	const { width, depth, levels } = map;
+	let sum = 0;
+	let count = 0;
+	for (let cz = Math.max(iz - 3, 0); cz < Math.min(iz + 3, depth); cz++) for (let cx = Math.max(ix - 3, 0); cx < Math.min(ix + 3, width); cx++) {
+		sum += levels[cz * width + cx];
+		count++;
+	}
+	return count ? sum / count : 0;
+}
+/**
+* Cell of a map a point is in
+*
+* @internal
+*/
+var mapCell = (map, x, z) => clamp(Math.floor(z), 0, map.depth - 1) * map.width + clamp(Math.floor(x), 0, map.width - 1);
+/**
+* Brings the paint of a map in line with a game's tiles, in place: afterwards index 1 is the game's first tile, and
+* so on. What was painted with a tile the game does not have keeps it, under an index after the game's: the map
+* loses nothing, and the file has it still. Returns the names of those, which no world is given
+*
+* @beta
+*/
+function adoptTileset(map, tiles) {
+	const used = new Set(map.tiles);
+	const strangers = map.tileset.filter((id, i) => !tiles.includes(id) && used.has(i + 1));
+	const tileset = [...tiles, ...strangers];
+	if (tileset.length > 255) throw new Error(`Map: ${tileset.length} tiles are more than a map can hold`);
+	if (tileset.length !== map.tileset.length || tileset.some((id, i) => id !== map.tileset[i])) {
+		const remap = tileRemap(map.tileset, tileset);
+		for (let c = 0; c < map.tiles.length; c++) map.tiles[c] = remap[map.tiles[c]] ?? 0;
+		map.tileset = tileset;
+	}
+	return strangers;
+}
+/**
+* The paint of a map as a game's tiles have it: what is painted with a tile the game does not have is no paint
+*
+* @internal
+*/
+function tilesFor(map, tiles) {
+	const remap = tileRemap(map.tileset, tiles);
+	return map.tiles.map((tile) => remap[tile] ?? 0);
+}
+//#endregion
+export { adoptTileset, blockByDoodads, mapCell, mapTerrain, tilesFor, updateMapTerrain };
+
+//# sourceMappingURL=terrain.js.map

package/dist/map/terrain.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"terrain.js","names":[],"sources":["../../src/map/terrain.ts"],"sourcesContent":["/*\n * The terrain a map describes, made from its layers, and its paint brought in line with a game's tiles (design review E8a: `map.ts` in parts)\n */\nimport { hypot } from '../exactMath'\nimport { clamp } from '../math'\nimport { Path } from '../paths'\nimport { Terrain } from '../terrain'\nimport { MAX_TILES, tileRemap } from '../tiles'\nimport { BLOCKS_BUILD, BLOCKS_WALK, BRIDGE, type CellRect, type GameMap, RAMP_REACH } from './types'\nimport { profiledGround, WATER_DEPTH } from './pathProfile'\n/** How far below the banks the water stands */\nconst WATER_SURFACE = 0.18\n\n/**\n * The terrain a map describes\n *\n * @beta\n */\nexport function mapTerrain(map: GameMap): Terrain {\n\tconst terrain = new Terrain(map.width, map.depth, new Float32Array(map.ground.length), new Uint8Array(map.levels.length), {\n\t\twater: new Uint8Array(map.water.length),\n\t\ttiles: new Uint8Array(map.tiles.length)\n\t})\n\tupdateMapTerrain(map, terrain)\n\treturn terrain\n}\n\n/**\n * What the doodads of a map keep off its cells, and what is kept off them by hand (`GameMap.pathing`), into the\n * terrain (`Terrain.blocked`): the most any of them keeps off. With `area` (cells), there alone: what the layers changed\n * there (a brush's step), the doodads elsewhere as they were; the whole map where a doodad itself changed\n *\n * @beta\n */\nexport function blockByDoodads(map: Pick<GameMap, 'doodads' | 'width' | 'depth' | 'pathing'>, terrain: Terrain, area?: CellRect): void {\n\tconst { blocked } = terrain\n\tconst x0 = area ? Math.max(Math.floor(area.x), 0) : 0\n\tconst z0 = area ? Math.max(Math.floor(area.z), 0) : 0\n\tconst x1 = area ? Math.min(Math.ceil(area.x + area.width), map.width) : map.width\n\tconst z1 = area ? Math.min(Math.ceil(area.z + area.depth), map.depth) : map.depth\n\tif (x1 <= x0 || z1 <= z0) return\n\t// by hand first: a bridge laid over it after is still a bridge, but over a wall painted there nothing walks\n\tconst byHand = map.pathing && map.pathing.length === blocked.length ? map.pathing : undefined\n\tfor (let cz = z0; cz < z1; cz++)\n\t\tfor (let c = cz * map.width + x0; c < cz * map.width + x1; c++) blocked[c] = byHand ? Math.min(byHand[c], BLOCKS_WALK) : 0\n\tfor (const doodad of map.doodads ?? []) {\n\t\tif (!doodad.radius) continue\n\t\t// (one whose reach is all outside the area is as it was)\n\t\tif (doodad.x + doodad.radius < x0 || doodad.x - doodad.radius > x1 || doodad.z + doodad.radius < z0 || doodad.z - doodad.radius > z1) continue\n\t\t// a gate keeps building off; walking it keeps off while the game runs, as it is shut (`setGate`)\n\t\tconst kind = doodad.bridge ? BRIDGE : doodad.gate ? BLOCKS_BUILD : doodad.blocks === 'walk' ? BLOCKS_WALK : doodad.blocks ? BLOCKS_BUILD : 0\n\t\tif (!kind) continue\n\t\tconst { radius } = doodad\n\t\tfor (let cz = Math.max(Math.floor(doodad.z - radius), z0); cz < Math.min(Math.ceil(doodad.z + radius), z1); cz++) {\n\t\t\tfor (let cx = Math.max(Math.floor(doodad.x - radius), x0); cx < Math.min(Math.ceil(doodad.x + radius), x1); cx++) {\n\t\t\t\t// a cell whose middle is within reach\n\t\t\t\tif (hypot(cx + 0.5 - doodad.x, cz + 0.5 - doodad.z) > radius) continue\n\t\t\t\tconst c = cz * map.width + cx\n\t\t\t\t// a bridge over what blocks is a bridge: it is how one gets over\n\t\t\t\tblocked[c] = kind === BRIDGE || blocked[c] === BRIDGE ? (blocked[c] === BLOCKS_WALK ? BLOCKS_WALK : BRIDGE) : Math.max(blocked[c], kind)\n\t\t\t}\n\t\t}\n\t}\n\t// what is walked on a bridge is its deck: the ground under it as high as the water, and its height over that\n\tconst row = map.width + 1\n\tfor (const doodad of map.doodads ?? []) {\n\t\tif (!doodad.bridge || !doodad.radius) continue\n\t\tif (doodad.x + doodad.radius < x0 || doodad.x - doodad.radius > x1 || doodad.z + doodad.radius < z0 || doodad.z - doodad.radius > z1) continue\n\t\tfor (let cz = Math.max(Math.floor(doodad.z - doodad.radius), 0); cz < Math.min(Math.ceil(doodad.z + doodad.radius), map.depth); cz++) {\n\t\t\tfor (let cx = Math.max(Math.floor(doodad.x - doodad.radius), 0); cx < Math.min(Math.ceil(doodad.x + doodad.radius), map.width); cx++) {\n\t\t\t\tif (hypot(cx + 0.5 - doodad.x, cz + 0.5 - doodad.z) > doodad.radius) continue\n\t\t\t\tfor (const v of [cz * row + cx, cz * row + cx + 1, (cz + 1) * row + cx, (cz + 1) * row + cx + 1]) {\n\t\t\t\t\tconst deck = Math.max(terrain.waterHeights[v], terrain.heights[v]) + (doodad.y ?? 0)\n\t\t\t\t\tif (terrain.heights[v] < deck) terrain.heights[v] = deck\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n}\n\n/**\n * How far a change to a cell reaches into the terrain: a ramp's slope is the average of the levels within\n * `RAMP_REACH`, and a ramp cell's level is its corners'\n */\nconst REACH = RAMP_REACH + 1\n\n/**\n * Brings a terrain of the same size in line with the layers of a map, in place, for editing. With `area`, only what\n * a change to those cells can have changed: the cells and the corners of cells within reach of it. Returns the cells\n * whose terrain was worked out again, for whoever draws it to draw again: their corners are the vertices that changed\n *\n * @beta\n */\nexport function updateMapTerrain(map: GameMap, terrain: Terrain, area?: CellRect): CellRect {\n\tconst { width, depth, cliffHeight, levels, ramps, water, ground } = map\n\tif (terrain.width !== width || terrain.depth !== depth) throw new Error('updateMapTerrain: the terrain is not the size of the map')\n\tterrain.bounds = map.bounds && { ...map.bounds }\n\tconst vx = width + 1\n\t// the cells, and the vertices at their corners, that can have changed\n\tconst x0 = area ? Math.max(Math.floor(area.x) - REACH, 0) : 0\n\tconst z0 = area ? Math.max(Math.floor(area.z) - REACH, 0) : 0\n\tconst x1 = area ? Math.min(Math.ceil(area.x + area.width) + REACH, width) : width\n\tconst z1 = area ? Math.min(Math.ceil(area.z + area.depth) + REACH, depth) : depth\n\tconst rowLength = x1 - x0 + 1\n\t// the roads and rivers of the paths with a profile, carved from the land here (`MapPath.profile`)\n\tconst carved = profiledGround(map, x0, z0, x1, z1)\n\tconst cellRow = rowLength + 1\n\tconst waterAt = (c: number, cx: number, cz: number): number =>\n\t\tcarved?.water ? Math.max(water[c], carved.water[(cz - z0 + 1) * cellRow + (cx - x0 + 1)]) : water[c]\n\t// the level of each vertex: the highest cell around it, or on a ramp the average of all cells within reach\n\tconst vertexLevels = new Float32Array(rowLength * (z1 - z0 + 1))\n\tfor (let iz = z0; iz <= z1; iz++) {\n\t\tfor (let ix = x0; ix <= x1; ix++) {\n\t\t\tlet top = 0\n\t\t\tlet onRamp = false\n\t\t\tlet depthSum = 0\n\t\t\t// water lies at the foot of a cliff, never up its face\n\t\t\tlet wetLevel = Infinity\n\t\t\tfor (let cz = iz - 1; cz <= iz; cz++) {\n\t\t\t\tfor (let cx = ix - 1; cx <= ix; cx++) {\n\t\t\t\t\tif (cx < 0 || cz < 0 || cx >= width || cz >= depth) continue\n\t\t\t\t\tconst c = cz * width + cx\n\t\t\t\t\ttop = Math.max(top, levels[c])\n\t\t\t\t\tif (ramps[c]) onRamp = true\n\t\t\t\t\tconst wet = waterAt(c, cx, cz)\n\t\t\t\t\tdepthSum += WATER_DEPTH[wet] ?? 0\n\t\t\t\t\tif (wet) wetLevel = Math.min(wetLevel, levels[c])\n\t\t\t\t}\n\t\t\t}\n\t\t\tconst v = iz * vx + ix\n\t\t\tconst level = onRamp ? averageLevel(map, ix, iz) : top\n\t\t\tvertexLevels[(iz - z0) * rowLength + (ix - x0)] = level\n\t\t\tconst under = carved ? carved.ground[(iz - z0) * rowLength + (ix - x0)] : ground[v]\n\t\t\tconst land = under + level * cliffHeight\n\t\t\tterrain.heights[v] = land - depthSum / 4\n\t\t\tterrain.waterHeights[v] = under + Math.min(wetLevel, level) * cliffHeight - WATER_SURFACE\n\t\t}\n\t}\n\tconst levelAt = (ix: number, iz: number) => vertexLevels[(iz - z0) * rowLength + (ix - x0)]\n\tfor (let cz = z0; cz < z1; cz++) {\n\t\tfor (let cx = x0; cx < x1; cx++) {\n\t\t\tconst c = cz * width + cx\n\t\t\tterrain.water[c] = waterAt(c, cx, cz)\n\t\t\tterrain.tiles[c] = map.tiles[c]\n\t\t\tfor (const id in map.cells) terrain.cellLayer(id)[c] = map.cells[id][c]\n\t\t\tif (!ramps[c]) {\n\t\t\t\tterrain.levels[c] = levels[c]\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\t// a ramp belongs to the level below until halfway up\n\t\t\tconst middle = (levelAt(cx, cz) + levelAt(cx + 1, cz) + levelAt(cx, cz + 1) + levelAt(cx + 1, cz + 1)) / 4\n\t\t\tterrain.levels[c] = Math.floor(middle + 0.5)\n\t\t}\n\t}\n\tconst touched = { x: x0, z: z0, width: x1 - x0, depth: z1 - z0 }\n\tpaintPaths(map, terrain.tiles, touched)\n\t// last: what doodads block, and the decks of bridges over the heights just worked out, where they were\n\tblockByDoodads(map, terrain, area && touched)\n\treturn touched\n}\n\n/**\n * Paints the ground under the paths that say so, over the paint of the map: the tiles are those of the map's tileset.\n * Within `area` only, when it is given\n */\nfunction paintPaths(map: GameMap, tiles: Uint8Array, area: CellRect = { x: 0, z: 0, width: map.width, depth: map.depth }): void {\n\tconst width = area.x + area.width\n\tconst depth = area.z + area.depth\n\tfor (const def of map.paths) {\n\t\t// a profile's ground over the path's paint, as wide as its bed\n\t\tconst bed = def.profile?.ground !== undefined\n\t\tconst paint = bed ? def.profile!.ground : def.paint\n\t\tconst wide = bed ? (def.profile!.width ?? def.width) : def.width\n\t\tconst tile = paint === undefined ? 0 : map.tileset.indexOf(paint) + 1\n\t\tif (!tile || !def.points.length) continue\n\t\tconst path = new Path(def.points, wide)\n\t\t// only the cells within reach of its points, not the whole map\n\t\tconst reach = wide / 2 + 1\n\t\tconst xs = def.points.map((point) => point.x)\n\t\tconst zs = def.points.map((point) => point.z)\n\t\tfor (let cz = Math.max(Math.floor(Math.min(...zs) - reach), area.z); cz < Math.min(Math.ceil(Math.max(...zs) + reach), depth); cz++) {\n\t\t\tfor (let cx = Math.max(Math.floor(Math.min(...xs) - reach), area.x); cx < Math.min(Math.ceil(Math.max(...xs) + reach), width); cx++) {\n\t\t\t\tif (path.containsCell(cx, cz)) tiles[cz * map.width + cx] = tile\n\t\t\t}\n\t\t}\n\t}\n}\n\n/** Average level of the cells within ramp reach of a vertex */\nfunction averageLevel(map: GameMap, ix: number, iz: number): number {\n\tconst { width, depth, levels } = map\n\tlet sum = 0\n\tlet count = 0\n\tfor (let cz = Math.max(iz - RAMP_REACH, 0); cz < Math.min(iz + RAMP_REACH, depth); cz++) {\n\t\tfor (let cx = Math.max(ix - RAMP_REACH, 0); cx < Math.min(ix + RAMP_REACH, width); cx++) {\n\t\t\tsum += levels[cz * width + cx]\n\t\t\tcount++\n\t\t}\n\t}\n\treturn count ? sum / count : 0\n}\n\n/**\n * Cell of a map a point is in\n *\n * @internal\n */\nexport const mapCell = (map: GameMap, x: number, z: number): number =>\n\tclamp(Math.floor(z), 0, map.depth - 1) * map.width + clamp(Math.floor(x), 0, map.width - 1)\n\n// ---- tiles\n\n/**\n * Brings the paint of a map in line with a game's tiles, in place: afterwards index 1 is the game's first tile, and\n * so on. What was painted with a tile the game does not have keeps it, under an index after the game's: the map\n * loses nothing, and the file has it still. Returns the names of those, which no world is given\n *\n * @beta\n */\nexport function adoptTileset(map: GameMap, tiles: readonly string[]): string[] {\n\tconst used = new Set(map.tiles)\n\tconst strangers = map.tileset.filter((id, i) => !tiles.includes(id) && used.has(i + 1))\n\tconst tileset = [...tiles, ...strangers]\n\tif (tileset.length > MAX_TILES) throw new Error(`Map: ${tileset.length} tiles are more than a map can hold`)\n\tif (tileset.length !== map.tileset.length || tileset.some((id, i) => id !== map.tileset[i])) {\n\t\tconst remap = tileRemap(map.tileset, tileset)\n\t\tfor (let c = 0; c < map.tiles.length; c++) map.tiles[c] = remap[map.tiles[c]] ?? 0\n\t\tmap.tileset = tileset\n\t}\n\treturn strangers\n}\n\n/**\n * The paint of a map as a game's tiles have it: what is painted with a tile the game does not have is no paint\n *\n * @internal\n */\nexport function tilesFor(map: GameMap, tiles: readonly string[]): Uint8Array {\n\tconst remap = tileRemap(map.tileset, tiles)\n\treturn map.tiles.map((tile) => remap[tile] ?? 0)\n}\n"],"mappings":"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"}

package/dist/map/types.d.ts

@@ -11,17 +11,21 @@ import type { MapDoodadLight, MapEnvironment } from './look';
  * cliff levels, ramps between levels, water and paint. The layers are what a map file stores, the terrain is
  * derived from them whenever one changes.
  *
- * @beta
+ * @public
  */
 export interface GameMap {
+    /** The map's name, as lists and the editor show it */
     name: string;
+    /** A line about the map, for lists of maps */
     description: string;
     /**
-     * The game the map was made for, by the id of its module (`GameModule.id`): a world is not made from it for
+     * The game the map was made for, by the id of its module (`Rules.id`): a world is not made from it for
      * another. For any game when left out, like the maps made before maps said
      */
     game?: string;
+    /** The map's width in cells */
     width: number;
+    /** The map's depth in cells */
     depth: number;
     /** How much higher a level stands than the one below */
     cliffHeight: number;
@@ -54,7 +58,9 @@ export interface GameMap {
     tileset: string[];
     /** The players who can take part. Neutral and the creeps are always there on top of these */
     players: MapPlayer[];
+    /** What stands on the map when the game begins: units, buildings, trees, mines */
     objects: MapObject[];
+    /** The creep camps of the map */
     camps: MapCamp[];
     /** Parts of the map the rules watch by name: who walks in and out (see `MapRegion`) */
     regions: MapRegion[];
@@ -68,6 +74,7 @@ export interface GameMap {
     cameras: MapCamera[];
     /** Groups what is placed can be drawn from when the game starts, and tables of what drops (see `MapRandomGroup`) */
     randomGroups?: MapRandomGroup[];
+    /** The tables of what dropped things come from, by name (`MapObject.drops`) */
     itemTables?: MapItemTable[];
     /**
      * The map's own definitions (campaign plan RC8), a `data.json` as the game's has it (`GameData`): laid over the
@@ -88,7 +95,7 @@ export interface GameMap {
     /**
      * Whether the whole map starts explored for everyone, the fog over it all the same: its ground, and what stands on it
      * and belongs to no player (trees, mines, neutral buildings), seen from the first moment. Yes or no over the game's
-     * (`FogRules.startExplored`); the game's when left out
+     * (`FogSettings.startExplored`); the game's when left out
      */
     explored?: boolean;
     /** What the loading screen says while it loads */
@@ -123,11 +130,19 @@ export interface GameMap {
      */
     extra?: Record<string, unknown>;
 }
-/** @beta */
+/**
+ * A seat for a player of the map: the player's id, name, team and colour with the options for what they start with
+ *
+ * @beta
+ */
 export interface MapPlayer {
+    /** The player's id, the number units and entities are owned by */
     id: PlayerId;
+    /** The player's name as lobbies show it */
     name: string;
+    /** The player's team number; players of the same number are allies */
     team: number;
+    /** The player's colour as red, green and blue in 0..1 */
     color: [number, number, number];
     /** Where their base goes, for a game that gives everyone a start */
     start?: Vec2;
@@ -141,7 +156,7 @@ export interface MapPlayer {
     /** What they start with, by resource id, over what the game gives everyone */
     resources?: Record<string, number>;
     /**
-     * The race they play, fixed by the map (a campaign's), of the game's races (`GameModule.races`), or `random`: not
+     * The race they play, fixed by the map (a campaign's), of the game's races (`Rules.races`), or `random`: not
      * chosen in a lobby. Left to the lobby, or the game's first, when left out
      */
     race?: string;
@@ -156,6 +171,7 @@ export interface MapPlayer {
 export interface MapForce {
     /** The team, as its players have it (`MapPlayer.team`) */
     team: number;
+    /** The team's name, shown in lobbies and for the game to read */
     name: string;
     /** Its players see what each other sees. Teams always do in this engine: kept for the game to read */
     sharedVision?: boolean;
@@ -171,12 +187,17 @@ export interface MapForce {
 export interface MapCamera {
     /** The editor's, see `MapRegion.id` */
     id: number;
+    /** The camera's name, which cinematics and code find it by */
     name: string;
+    /** The camera's target on the map's x axis, in cells */
     x: number;
+    /** The camera's target on the map's z axis, in cells */
     z: number;
+    /** How far the camera is from what it looks at */
     distance: number;
     /** Radians around the vertical axis, 0 looking north, and between the view and the ground */
     yaw: number;
+    /** The angle between the view and the ground, in radians */
     pitch: number;
 }
 /**
@@ -185,11 +206,17 @@ export interface MapCamera {
  * @beta
  */
 export interface MapObject {
+    /** The object's id on the map, used by the editor */
     id: number;
+    /** The id of the unit type placed */
     type: string;
+    /** The player that owns it (`MAP_NEUTRAL` or `MAP_CREEPS` for the neutral and the creeps) */
     owner: PlayerId;
+    /** Where it stands on the map's x axis, in cells */
     x: number;
+    /** Where it stands on the map's z axis, in cells */
     z: number;
+    /** The way it faces in radians, the way entities do (0 is along +z) */
     facing: number;
     /** How big it is drawn */
     scale: number;
@@ -243,8 +270,11 @@ export interface MapObject {
  * @beta
  */
 export interface MapObjectOrder {
+    /** What the order is: `move` to a point or along a path, `patrol`, `guard` or `hold` */
     kind: 'move' | 'patrol' | 'guard' | 'hold';
+    /** The name of a path of the map it follows, bend after bend */
     path?: string;
+    /** The point it goes to, or guards */
     point?: Vec2;
 }
 /**
@@ -258,6 +288,7 @@ export interface MapRegion {
     id: number;
     /** What the rules know it by. No two things on a map have the same, whatever they are */
     name: string;
+    /** The shape of the region: a circle or a rectangle (`AreaShape`) */
     shape: AreaShape;
     /** What it is drawn in, in the editor, to tell it from the others. The editor picks one when left out */
     color?: [number, number, number];
@@ -292,7 +323,9 @@ export interface MapPoint {
     id: number;
     /** What the rules know it by. No two things on a map have the same, whatever they are */
     name: string;
+    /** Where it stands on the map's x axis, in cells */
     x: number;
+    /** Where it stands on the map's z axis, in cells */
     z: number;
     /** Radians, the way entities face: 0 is along +z */
     facing: number;
@@ -311,13 +344,17 @@ export interface MapDoodad {
     id: number;
     /** The model, by its path in `models/`: the map's own, the game's, or a shared one */
     model: string;
+    /** Where it stands on the map's x axis, in cells */
     x: number;
+    /** Where it stands on the map's z axis, in cells */
     z: number;
     /** How high above the ground under it */
     y?: number;
     /** Radians: which way it faces, the way entities do (0 is along +z), then how far it leans forward and to the side */
     yaw: number;
+    /** How far it leans forward in radians; 0 when left out */
     pitch?: number;
+    /** How far it leans to the side in radians; 0 when left out */
     roll?: number;
     /** How much bigger or smaller it is drawn than it was made, across, up and deep */
     scale: [number, number, number];
@@ -337,6 +374,7 @@ export interface MapDoodad {
      * name while the game runs (`setGate`). Shut when the game starts, unless `open`
      */
     gate?: boolean;
+    /** Whether the gate starts open; shut when left out */
     open?: boolean;
     /** How far around its middle it blocks, in cells */
     radius?: number;
@@ -407,7 +445,7 @@ export interface MapDoodadDetail {
 }
 /**
  * How much detail things are drawn with by their distance on a map (`MapEnvironment.detail`), over the game's
- * (`GameView.scene.detail`): a forest map drawn lighter. The screen's: the rules never see it
+ * (`GameView.world.detail`): a forest map drawn lighter. The screen's: the rules never see it
  *
  * @beta
  */
@@ -416,12 +454,18 @@ export interface MapDetail {
     scale?: number;
     /** Past this far from the camera, in cells, no scenery, tree or mine is drawn at all, nor casts a shadow. None when left out */
     cull?: number;
+    /**
+     * How many cells past the edges of the view what is there is drawn already, so that it is ready (its pictures, its
+     * shaders, its scenery merged) before the camera brings it in: no trees coming in as the view moves, for a little more
+     * drawn off the screen. The game's when left out
+     */
+    preload?: number;
     /**
      * How many levels coarser than it is drawn at a thing casts its shadow, where its level does not say (`shadow`): 1
      * draws a tree's shadow at its next lighter level. The game's when left out
      */
     shadowBias?: number;
-    /** The levels of every model that has none said of it, over the game's (`GameView.scene.detail.levels`) */
+    /** The levels of every model that has none said of it, over the game's (`GameView.world.detail.levels`) */
     levels?: MapDetailLevel[];
     /** A model's levels, by its path in `models/`, over its own and the game's */
     models?: Record<string, MapDetailLevel[]>;
@@ -433,6 +477,7 @@ export interface MapDetail {
  * @beta
  */
 export interface MapRandomGroup {
+    /** The group's name, which `MapObject.random` names it by */
     name: string;
     /** One of these, more likely by its weight */
     choices?: {
@@ -448,7 +493,9 @@ export interface MapRandomGroup {
  * @beta
  */
 export interface MapItemTable {
+    /** The table's name, which `MapObject.drops` names it by */
     name: string;
+    /** The lines of the table, one of which is picked by weight */
     items: MapItemTableEntry[];
     /** How likely it is to drop anything, 0..1. Always when left out */
     chance?: number;
@@ -460,9 +507,13 @@ export interface MapItemTable {
  * @beta
  */
 export interface MapItemTableEntry {
+    /** The item's id, for a line that names one */
     item?: string;
+    /** The level of item it stands for, for a line that does not name one */
     level?: number;
+    /** The class of item it stands for, for a line that does not name one */
     class?: string;
+    /** How likely this line is among the table's, relative to the others' weights */
     weight: number;
 }
 /**
@@ -471,7 +522,11 @@ export interface MapItemTableEntry {
  * @beta
  */
 export declare const BLOCKS_BUILD = 1;
-/** @beta */
+/**
+ * The `Terrain.blocked` value for a cell where walking and building are both kept off
+ *
+ * @beta
+ */
 export declare const BLOCKS_WALK = 2;
 /**
  * A named line of the map, through points in order, with a width: `world.map.path('road')` (see `Path`)
@@ -483,6 +538,7 @@ export interface MapPath {
     id: number;
     /** What the rules know it by. No two things on a map have the same, whatever they are */
     name: string;
+    /** The points of the path in order, in cells */
     points: Vec2[];
     /** How wide it is, in cells: what it paints and keeps clear, and what `Path.contains` says is on it */
     width: number;
@@ -518,7 +574,7 @@ export interface PathProfile {
     water?: boolean;
 }
 /**
- * The time of day of a map, in a game with days (`GameModule.day`). The rules': what is done at night is done by it
+ * The time of day of a map, in a game with days (`Rules.day`). The rules': what is done at night is done by it
  *
  * @beta
  */
@@ -534,8 +590,11 @@ export interface MapDay {
  * @beta
  */
 export interface MapCamp {
+    /** The map's id for the camp, used by the editor */
     id: number;
+    /** Where the camp stands on the map's x axis, in cells */
     x: number;
+    /** Where the camp stands on the map's z axis, in cells */
     z: number;
     /** Unit types, the first one stands in the middle */
     units: string[];
@@ -560,7 +619,7 @@ export declare const MAP_NEUTRAL: PlayerId;
 export declare const MAP_CREEPS: PlayerId;
 /**
  * Players a map may have at most, whatever the game: each could be a team of its own, and the fog of war keeps 32
- * teams apart (`MAX_FOG_TEAMS`). How many a game allows is its own (`GameModule.maxPlayers`, 8 when it says nothing)
+ * teams apart (`MAX_FOG_TEAMS`). How many a game allows is its own (`Rules.maxPlayers`, 8 when it says nothing)
  *
  * @beta
  */
@@ -571,17 +630,33 @@ export declare const MAX_MAP_PLAYERS = 32;
  * @beta
  */
 export declare const MAX_LEVEL = 4;
-/** @beta */
+/**
+ * The colours players are given by their number, in 0..1; past the end they start again
+ *
+ * @beta
+ */
 export declare const PLAYER_COLORS: [number, number, number][];
-/** @beta */
+/**
+ * Makes the `MapPlayer` for a player's id, with the default name `Player <id>`, its own team and the colour from `PLAYER_COLORS`
+ *
+ * @beta
+ */
 export declare const playerSlot: (id: number) => MapPlayer;
-/** @beta */
+/**
+ * The options `createMap` makes a map with
+ *
+ * @beta
+ */
 export interface NewMapOptions {
+    /** The map's name: `New map` when left out */
     name?: string;
+    /** The map's width in cells */
     width: number;
+    /** The map's depth in cells */
     depth: number;
     /** Height of the land everywhere */
     height?: number;
+    /** How many player slots the map has: 2 when left out */
     players?: number;
     /** The game it is for, see `GameMap.game` */
     game?: string;
@@ -600,9 +675,13 @@ export declare function createMap(options: NewMapOptions): GameMap;
  * @beta
  */
 export interface CellRect {
+    /** The rectangle's first cell on the x axis */
     x: number;
+    /** The rectangle's first cell on the z axis */
     z: number;
+    /** How many cells across it is */
     width: number;
+    /** How many cells down it is */
     depth: number;
 }
 /**