@v12-engine/engine 0.1.0 → 0.4.0

package/dist/ground.js

@@ -0,0 +1,375 @@
+import { playTileset } from "./map/look.js";
+import { Terrain } from "./terrain.js";
+import { mapTerrain, tilesFor } from "./map/terrain.js";
+import { packArray, packBytes, unpackBytes } from "./bytes.js";
+import { loadTerrain, saveTerrain } from "./terrainSave.js";
+//#region src/ground.ts
+var LAYERS = [
+	"heights",
+	"levels",
+	"water",
+	"waterHeights",
+	"tiles",
+	"blocked"
+];
+/**
+* Whether a save's ground is the changes of a map, not the whole of it
+*
+* @beta
+*/
+var isGroundChanges = (ground) => typeof ground.map === "string";
+/**
+* The ground a world is made on from a map, painted as the game's tiles go, then the map's own (`MapTile`): what
+* `createWorldFromMap` makes
+*
+* @internal
+*/
+function startingTerrain(map, game) {
+	const tileIds = playTileset((game.tiles ?? []).map((tile) => tile.id), map.environment);
+	return mapTerrain({
+		...map,
+		tiles: tilesFor(map, tileIds),
+		tileset: tileIds
+	});
+}
+/**
+* A hash of a ground, every layer of it and its size: two grounds of the same hash are the same ground
+*
+* @beta
+*/
+function groundHash(terrain) {
+	let a = 2166136261;
+	let b = 1523705862;
+	const mix = (word) => {
+		a = Math.imul(a ^ word, 16777619);
+		b = Math.imul(b ^ word, 1540483477);
+	};
+	mix(terrain.width);
+	mix(terrain.depth);
+	const layers = LAYERS.map((key) => terrain[key]);
+	for (const id of Object.keys(terrain.cells).sort()) {
+		const cells = terrain.cells[id];
+		if (!cells.some((value) => value !== 0)) continue;
+		for (let i = 0; i < id.length; i++) mix(id.charCodeAt(i));
+		layers.push(cells);
+	}
+	for (const layer of layers) {
+		const bytes = new Uint8Array(layer.buffer, layer.byteOffset, layer.byteLength);
+		const words = Math.floor(bytes.length / 4);
+		const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+		for (let i = 0; i < words; i++) mix(view.getUint32(i * 4, true));
+		for (let i = words * 4; i < bytes.length; i++) mix(bytes[i]);
+		mix(4294967295);
+	}
+	return (a >>> 0).toString(16).padStart(8, "0") + (b >>> 0).toString(16).padStart(8, "0");
+}
+/**
+* A ground a world starts on, as a map made it, with its hash worked out when it is first asked for
+*
+* @internal
+*/
+function startedOn(map, terrain) {
+	let hash;
+	return {
+		map,
+		terrain,
+		get hash() {
+			return hash ??= groundHash(terrain);
+		}
+	};
+}
+/**
+* The ground a map the game ships makes, and its hash: worked out once for each of those maps, which are not changed
+* once given (a map being edited is, and is not one of them)
+*/
+var bases = /* @__PURE__ */ new WeakMap();
+/**
+* The ground of a map for a game, worked out once per map and tileset and kept; returns the `GroundBase` with its terrain and hash
+*
+* @internal
+*/
+function groundBase(map, game) {
+	const key = playTileset((game.tiles ?? []).map((tile) => tile.id), map.environment).join();
+	let known = bases.get(map);
+	if (!known) bases.set(map, known = /* @__PURE__ */ new Map());
+	let base = known.get(key);
+	if (!base) {
+		const terrain = startingTerrain(map, game);
+		known.set(key, base = startedOn(map.name, terrain));
+	}
+	return base;
+}
+/**
+* The map of a name whose ground has a hash, among some maps: the one a save or a welcome names
+*
+* @internal
+*/
+function findGround(maps, name, hash, game) {
+	for (const map of maps) if (map.name === name && groundBase(map, game).hash === hash) return groundBase(map, game);
+}
+/**
+* The ground of a world as a save keeps it: the changes since the map it started as, where the game has that map as
+* it was (the same name and the same ground), else all of it
+*
+* @internal
+*/
+function savedGround(terrain, base, maps, game) {
+	if (!base || !maps?.length || !findGround(maps, base.map, base.hash, game)) return saveTerrain(terrain);
+	const from = base.terrain;
+	if (from.width !== terrain.width || from.depth !== terrain.depth) return saveTerrain(terrain);
+	const changes = {};
+	for (const key of LAYERS) {
+		const now = terrain[key];
+		const was = from[key];
+		const at = [];
+		for (let i = 0; i < now.length; i++) if (now[i] !== was[i]) at.push(i);
+		if (!at.length) continue;
+		const values = now instanceof Float32Array ? Float32Array.from(at, (i) => now[i]) : Uint8Array.from(at, (i) => now[i]);
+		changes[key] = {
+			count: at.length,
+			at: packArray(Int32Array.from(at)),
+			to: values instanceof Float32Array ? packArray(values) : packBytes(values)
+		};
+	}
+	const cells = {};
+	for (const id of /* @__PURE__ */ new Set([...Object.keys(terrain.cells), ...Object.keys(from.cells)])) {
+		const now = terrain.cells[id];
+		const was = from.cells[id];
+		const at = [];
+		for (let i = 0; i < terrain.width * terrain.depth; i++) if ((now?.[i] ?? 0) !== (was?.[i] ?? 0)) at.push(i);
+		if (at.length) cells[id] = {
+			count: at.length,
+			at: packArray(Int32Array.from(at)),
+			to: packBytes(Uint8Array.from(at, (i) => now?.[i] ?? 0))
+		};
+	}
+	return {
+		map: base.map,
+		hash: base.hash,
+		width: terrain.width,
+		depth: terrain.depth,
+		changes,
+		...Object.keys(cells).length && { cells },
+		...terrain.bounds && { bounds: { ...terrain.bounds } }
+	};
+}
+/**
+* Why the ground of a save or a welcome cannot be read: the map it names is not one of the game's, as it was
+*
+* @internal
+*/
+var MissingGround = class extends Error {
+	map;
+	hash;
+	constructor(map, hash) {
+		super(`The ground is the map "${map}" as it was (${hash}), which this game does not have: it was changed or taken out since`);
+		this.map = map;
+		this.hash = hash;
+	}
+};
+/**
+* A ground back from a save or a welcome, and what it started as where it names a map: that map among `maps`, with
+* the changes put on it. Throws `MissingGround` where none of them is that map as it was
+*
+* @internal
+*/
+function groundOf(saved, maps, game) {
+	if (!isGroundChanges(saved)) return { terrain: loadTerrain(saved) };
+	const base = maps ? findGround(maps, saved.map, saved.hash, game) : void 0;
+	if (!base) throw new MissingGround(saved.map, saved.hash);
+	return {
+		terrain: applyGroundChanges(base.terrain, saved),
+		base
+	};
+}
+/**
+* A copy of a ground, the changes put on it
+*
+* @internal
+*/
+function applyGroundChanges(from, ground) {
+	const terrain = cloneTerrain(from);
+	for (const key of LAYERS) {
+		const change = ground.changes[key];
+		if (!change) continue;
+		const layer = terrain[key];
+		const atBytes = unpackBytes(change.at, change.count * 4);
+		const toBytes = unpackBytes(change.to, change.count * (layer instanceof Float32Array ? 4 : 1));
+		if (!atBytes || !toBytes) throw new Error(`Save: the changes of the ${key} of the ground are not what they say`);
+		const at = new Int32Array(atBytes.buffer);
+		const to = layer instanceof Float32Array ? new Float32Array(toBytes.buffer) : toBytes;
+		for (let i = 0; i < at.length; i++) {
+			if (at[i] < 0 || at[i] >= layer.length) throw new Error(`Save: a change of the ${key} is off the ground`);
+			layer[at[i]] = to[i];
+		}
+	}
+	for (const [id, change] of Object.entries(ground.cells ?? {})) {
+		const layer = terrain.cellLayer(id);
+		const atBytes = unpackBytes(change.at, change.count * 4);
+		const to = unpackBytes(change.to, change.count);
+		if (!atBytes || !to) throw new Error(`Save: the changes of the cells of ${id} are not what they say`);
+		const at = new Int32Array(atBytes.buffer);
+		for (let i = 0; i < at.length; i++) {
+			if (at[i] < 0 || at[i] >= layer.length) throw new Error(`Save: a change of the cells of ${id} is off the ground`);
+			layer[at[i]] = to[i];
+		}
+	}
+	terrain.bounds = ground.bounds ? { ...ground.bounds } : void 0;
+	return terrain;
+}
+/**
+* A copy of a ground, every layer its own
+*
+* @internal
+*/
+function cloneTerrain(from) {
+	const terrain = new Terrain(from.width, from.depth, from.heights.slice(), from.levels.slice(), {
+		water: from.water.slice(),
+		waterHeights: from.waterHeights.slice(),
+		tiles: from.tiles.slice(),
+		blocked: from.blocked.slice(),
+		cells: Object.fromEntries(Object.entries(from.cells).map(([id, layer]) => [id, layer.slice()]))
+	});
+	if (from.bounds) terrain.bounds = { ...from.bounds };
+	return terrain;
+}
+/**
+* The cells of two grounds of one size that are not the same, as the smallest rectangle around them; none where they
+* are the same. Every layer, the game's layers of cells too. Two of other sizes: all of `after`
+*
+* @beta
+*/
+function groundDifference(before, after) {
+	if (before.width !== after.width || before.depth !== after.depth) return {
+		x: 0,
+		z: 0,
+		width: after.width,
+		depth: after.depth
+	};
+	let x0 = Infinity;
+	let z0 = Infinity;
+	let x1 = -1;
+	let z1 = -1;
+	const take = (x, z) => {
+		if (x < x0) x0 = x;
+		if (z < z0) z0 = z;
+		if (x > x1) x1 = x;
+		if (z > z1) z1 = z;
+	};
+	const { width, depth, vertsX } = after;
+	for (const layer of ["heights", "waterHeights"]) {
+		const a = before[layer];
+		const b = after[layer];
+		for (let i = 0; i < b.length; i++) {
+			if (a[i] === b[i]) continue;
+			const vx = i % vertsX;
+			const vz = Math.floor(i / vertsX);
+			take(Math.min(vx, width - 1), Math.min(vz, depth - 1));
+			take(Math.max(vx - 1, 0), Math.max(vz - 1, 0));
+		}
+	}
+	const cellLayers = [...[
+		"levels",
+		"water",
+		"tiles",
+		"blocked"
+	].map((layer) => [before[layer], after[layer]])];
+	for (const id of /* @__PURE__ */ new Set([...Object.keys(before.cells), ...Object.keys(after.cells)])) cellLayers.push([before.cells[id] ?? new Uint8Array(width * depth), after.cells[id] ?? new Uint8Array(width * depth)]);
+	for (const [a, b] of cellLayers) for (let i = 0; i < b.length; i++) if (a[i] !== b[i]) take(i % width, Math.floor(i / width));
+	return x1 < 0 ? void 0 : {
+		x: x0,
+		z: z0,
+		width: x1 - x0 + 1,
+		depth: z1 - z0 + 1
+	};
+}
+/**
+* A rectangle of cells of a ground as it is (`TerrainPatch`): to be put in another
+*
+* @beta
+*/
+function terrainPatch(terrain, rect) {
+	const { x, z, width, depth } = rect;
+	const vertices = (values) => {
+		const out = [];
+		for (let vz = z; vz <= z + depth; vz++) for (let vx = x; vx <= x + width; vx++) out.push(values[vz * terrain.vertsX + vx]);
+		return out;
+	};
+	const cells = (values) => {
+		const out = [];
+		for (let cz = z; cz < z + depth; cz++) for (let cx = x; cx < x + width; cx++) out.push(values[cz * terrain.width + cx]);
+		return out;
+	};
+	const layers = Object.entries(terrain.cells);
+	return {
+		x,
+		z,
+		width,
+		depth,
+		heights: vertices(terrain.heights),
+		waterHeights: vertices(terrain.waterHeights),
+		levels: cells(terrain.levels),
+		water: cells(terrain.water),
+		tiles: cells(terrain.tiles),
+		blocked: cells(terrain.blocked),
+		...layers.length > 0 && { cells: Object.fromEntries(layers.map(([id, values]) => [id, cells(values)])) }
+	};
+}
+/**
+* What is wrong with a patch for a ground (`TerrainPatch`): out of it, or of layers of other lengths. Nothing when it fits
+*
+* @beta
+*/
+function terrainPatchProblem(terrain, patch) {
+	const { x, z, width, depth } = patch;
+	if (![
+		x,
+		z,
+		width,
+		depth
+	].every(Number.isInteger) || x < 0 || z < 0 || width < 1 || depth < 1) return "the patch is no rectangle of cells";
+	if (x + width > terrain.width || z + depth > terrain.depth) return `the patch goes past the ground, ${terrain.width} by ${terrain.depth} cells`;
+	const vertices = (width + 1) * (depth + 1);
+	const cells = width * depth;
+	if (patch.heights.length !== vertices || patch.waterHeights.length !== vertices) return `the patch has not ${vertices} heights`;
+	for (const layer of [
+		patch.levels,
+		patch.water,
+		patch.tiles,
+		patch.blocked,
+		...Object.values(patch.cells ?? {})
+	]) if (layer.length !== cells) return `a layer of the patch has not ${cells} cells`;
+}
+/**
+* Puts a patch (`TerrainPatch`) in a ground, in place: its heights, water, paint and levels, and the game's layers of
+* cells (a layer the patch has that the ground has not is made). Nothing else: what the rules make of the ground is
+* `World.reshapeGround`'s. Throws where it does not fit (`terrainPatchProblem`)
+*
+* @beta
+*/
+function applyTerrainPatch(terrain, patch) {
+	const problem = terrainPatchProblem(terrain, patch);
+	if (problem) throw new Error(`applyTerrainPatch: ${problem}`);
+	const { x, z, width, depth } = patch;
+	let i = 0;
+	for (let vz = z; vz <= z + depth; vz++) for (let vx = x; vx <= x + width; vx++, i++) {
+		const at = vz * terrain.vertsX + vx;
+		terrain.heights[at] = patch.heights[i];
+		terrain.waterHeights[at] = patch.waterHeights[i];
+	}
+	const layers = [
+		[terrain.levels, patch.levels],
+		[terrain.water, patch.water],
+		[terrain.tiles, patch.tiles],
+		[terrain.blocked, patch.blocked],
+		...Object.entries(patch.cells ?? {}).map(([id, values]) => [terrain.cellLayer(id), values])
+	];
+	for (const [into, values] of layers) {
+		let j = 0;
+		for (let cz = z; cz < z + depth; cz++) for (let cx = x; cx < x + width; cx++, j++) into[cz * terrain.width + cx] = values[j];
+	}
+}
+//#endregion
+export { MissingGround, applyGroundChanges, applyTerrainPatch, cloneTerrain, findGround, groundBase, groundDifference, groundHash, groundOf, isGroundChanges, savedGround, startedOn, startingTerrain, terrainPatch, terrainPatchProblem };
+
+//# sourceMappingURL=ground.js.map

package/dist/ground.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ground.js","names":[],"sources":["../src/ground.ts"],"sourcesContent":["import { packArray, packBytes, unpackBytes } from './bytes'\nimport type { Rules } from './game'\nimport { type GameMap, mapTerrain, playTileset, tilesFor } from './map'\nimport { loadTerrain, saveTerrain, type TerrainSave } from './terrainSave'\nimport { Terrain } from './terrain'\n\n/*\n * The ground not in every save and welcome (S36). A world made from a map the game has (`Rules.maps`) keeps the\n * ground it started on, and a save or a welcome names that map (by its name, and a hash of the ground it makes) and\n * carries only the cells of the ground that changed since: a few bytes, where the whole ground of a map of 1024 cells\n * a side is about 15 MB. A world made from bare terrain, or from a map the game does not have, keeps all of it, as\n * before. Whoever reads it finds the map among the game's own; a player who has not got it is sent the ground once,\n * in parts (`RemoteSession`).\n */\n\n/**\n * The ground of a save or a welcome: all of it, or the map it started as and what changed of it\n *\n * @beta\n */\nexport type SavedGround = TerrainSave | GroundChanges\n\n/**\n * The ground as a map the game has, and the cells of it that changed: in a save and in a welcome\n *\n * @beta\n */\nexport interface GroundChanges {\n\t/** The map it started as, by its name (`GameMap.name`) and a hash of the ground it makes (`groundHash`) */\n\tmap: string\n\t/** A hash of the ground the map makes, which tells the ground of a save or a welcome is the one it was taken from */\n\thash: string\n\t/** The ground's width in cells */\n\twidth: number\n\t/** The ground's depth in cells */\n\tdepth: number\n\t/** For each layer that changed: which cells (packed as 32-bit numbers), and what each holds now */\n\tchanges: Partial<Record<GroundLayer, { count: number; at: string; to: string }>>\n\t/** The same for the game's layers of cells (`Terrain.cells`), by id */\n\tcells?: Record<string, { count: number; at: string; to: string }>\n\t/** The part of the map play happens in, as it is now */\n\tbounds?: { x: number; z: number; width: number; depth: number }\n}\n\nconst LAYERS = ['heights', 'levels', 'water', 'waterHeights', 'tiles', 'blocked'] as const\n/**\n * A layer of the ground that can change: `heights`, `levels`, `water`, `waterHeights`, `tiles` or `blocked`\n *\n * @beta\n */\nexport type GroundLayer = (typeof LAYERS)[number]\n\n/**\n * Whether a save's ground is the changes of a map, not the whole of it\n *\n * @beta\n */\nexport const isGroundChanges = (ground: SavedGround): ground is GroundChanges => typeof (ground as GroundChanges).map === 'string'\n\n/**\n * The ground a world is made on from a map, painted as the game's tiles go, then the map's own (`MapTile`): what\n * `createWorldFromMap` makes\n *\n * @internal\n */\nexport function startingTerrain(map: GameMap, game: Pick<Rules, 'tiles'>): Terrain {\n\tconst tileIds = playTileset(\n\t\t(game.tiles ?? []).map((tile) => tile.id),\n\t\tmap.environment\n\t)\n\treturn mapTerrain({ ...map, tiles: tilesFor(map, tileIds), tileset: tileIds })\n}\n\n/**\n * A hash of a ground, every layer of it and its size: two grounds of the same hash are the same ground\n *\n * @beta\n */\nexport function groundHash(terrain: Terrain): string {\n\tlet a = 0x811c9dc5\n\tlet b = 0x01000193 ^ 0x5bd1e995\n\tconst mix = (word: number) => {\n\t\ta = Math.imul(a ^ word, 0x01000193)\n\t\tb = Math.imul(b ^ word, 0x5bd1e995)\n\t}\n\tmix(terrain.width)\n\tmix(terrain.depth)\n\tconst layers: (Float32Array | Uint8Array)[] = LAYERS.map((key) => terrain[key])\n\t// the game's layers of cells, by id, where any cell holds something: an empty layer is no layer\n\tfor (const id of Object.keys(terrain.cells).sort()) {\n\t\tconst cells = terrain.cells[id]\n\t\tif (!cells.some((value) => value !== 0)) continue\n\t\tfor (let i = 0; i < id.length; i++) mix(id.charCodeAt(i))\n\t\tlayers.push(cells)\n\t}\n\tfor (const layer of layers) {\n\t\tconst bytes = new Uint8Array(layer.buffer, layer.byteOffset, layer.byteLength)\n\t\tconst words = Math.floor(bytes.length / 4)\n\t\tconst view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength)\n\t\tfor (let i = 0; i < words; i++) mix(view.getUint32(i * 4, true))\n\t\tfor (let i = words * 4; i < bytes.length; i++) mix(bytes[i])\n\t\tmix(0xffffffff)\n\t}\n\treturn (a >>> 0).toString(16).padStart(8, '0') + (b >>> 0).toString(16).padStart(8, '0')\n}\n\n/**\n * The ground a world started on, from a map: kept with the world (`World.ground`), not in its save\n *\n * @beta\n */\nexport interface GroundBase {\n\t/** The name of the map the ground started as (`GameMap.name`) */\n\tmap: string\n\t/** A hash of the ground (`groundHash`): worked out the first time it is asked for */\n\treadonly hash: string\n\t/** The ground itself, with the changes of play not yet laid on it */\n\tterrain: Terrain\n}\n\n/**\n * A ground a world starts on, as a map made it, with its hash worked out when it is first asked for\n *\n * @internal\n */\nexport function startedOn(map: string, terrain: Terrain): GroundBase {\n\tlet hash: string | undefined\n\treturn {\n\t\tmap,\n\t\tterrain,\n\t\tget hash() {\n\t\t\treturn (hash ??= groundHash(terrain))\n\t\t}\n\t}\n}\n\n/**\n * The ground a map the game ships makes, and its hash: worked out once for each of those maps, which are not changed\n * once given (a map being edited is, and is not one of them)\n */\nconst bases = new WeakMap<GameMap, Map<string, GroundBase>>()\n/**\n * The ground of a map for a game, worked out once per map and tileset and kept; returns the `GroundBase` with its terrain and hash\n *\n * @internal\n */\nexport function groundBase(map: GameMap, game: Pick<Rules, 'tiles'>): GroundBase {\n\tconst key = playTileset(\n\t\t(game.tiles ?? []).map((tile) => tile.id),\n\t\tmap.environment\n\t).join()\n\tlet known = bases.get(map)\n\tif (!known) bases.set(map, (known = new Map()))\n\tlet base = known.get(key)\n\tif (!base) {\n\t\tconst terrain = startingTerrain(map, game)\n\t\tknown.set(key, (base = startedOn(map.name, terrain)))\n\t}\n\treturn base\n}\n\n/**\n * The map of a name whose ground has a hash, among some maps: the one a save or a welcome names\n *\n * @internal\n */\nexport function findGround(maps: readonly GameMap[], name: string, hash: string, game: Pick<Rules, 'tiles'>): GroundBase | undefined {\n\tfor (const map of maps) if (map.name === name && groundBase(map, game).hash === hash) return groundBase(map, game)\n\treturn undefined\n}\n\n/**\n * The ground of a world as a save keeps it: the changes since the map it started as, where the game has that map as\n * it was (the same name and the same ground), else all of it\n *\n * @internal\n */\nexport function savedGround(\n\tterrain: Terrain,\n\tbase: GroundBase | undefined,\n\tmaps: readonly GameMap[] | undefined,\n\tgame: Pick<Rules, 'tiles'>\n): SavedGround {\n\tif (!base || !maps?.length || !findGround(maps, base.map, base.hash, game)) return saveTerrain(terrain)\n\tconst from = base.terrain\n\tif (from.width !== terrain.width || from.depth !== terrain.depth) return saveTerrain(terrain)\n\tconst changes: GroundChanges['changes'] = {}\n\tfor (const key of LAYERS) {\n\t\tconst now = terrain[key]\n\t\tconst was = from[key]\n\t\tconst at: number[] = []\n\t\tfor (let i = 0; i < now.length; i++) if (now[i] !== was[i]) at.push(i)\n\t\tif (!at.length) continue\n\t\tconst values = now instanceof Float32Array ? Float32Array.from(at, (i) => now[i]) : Uint8Array.from(at, (i) => now[i])\n\t\tchanges[key] = {\n\t\t\tcount: at.length,\n\t\t\tat: packArray(Int32Array.from(at)),\n\t\t\tto: values instanceof Float32Array ? packArray(values) : packBytes(values)\n\t\t}\n\t}\n\tconst cells: NonNullable<GroundChanges['cells']> = {}\n\tfor (const id of new Set([...Object.keys(terrain.cells), ...Object.keys(from.cells)])) {\n\t\tconst now = terrain.cells[id]\n\t\tconst was = from.cells[id]\n\t\tconst at: number[] = []\n\t\tfor (let i = 0; i < terrain.width * terrain.depth; i++) if ((now?.[i] ?? 0) !== (was?.[i] ?? 0)) at.push(i)\n\t\tif (at.length) cells[id] = { count: at.length, at: packArray(Int32Array.from(at)), to: packBytes(Uint8Array.from(at, (i) => now?.[i] ?? 0)) }\n\t}\n\treturn {\n\t\tmap: base.map,\n\t\thash: base.hash,\n\t\twidth: terrain.width,\n\t\tdepth: terrain.depth,\n\t\tchanges,\n\t\t...(Object.keys(cells).length && { cells }),\n\t\t...(terrain.bounds && { bounds: { ...terrain.bounds } })\n\t}\n}\n\n/**\n * Why the ground of a save or a welcome cannot be read: the map it names is not one of the game's, as it was\n *\n * @internal\n */\nexport class MissingGround extends Error {\n\tconstructor(\n\t\t/** The name of the map the ground was taken from, as the save or welcome gave it */\n\t\treadonly map: string,\n\t\t/** The hash of that ground, which the game no longer has a map of */\n\t\treadonly hash: string\n\t) {\n\t\tsuper(`The ground is the map \"${map}\" as it was (${hash}), which this game does not have: it was changed or taken out since`)\n\t}\n}\n\n/**\n * A ground back from a save or a welcome, and what it started as where it names a map: that map among `maps`, with\n * the changes put on it. Throws `MissingGround` where none of them is that map as it was\n *\n * @internal\n */\nexport function groundOf(\n\tsaved: SavedGround,\n\tmaps: readonly GameMap[] | undefined,\n\tgame: Pick<Rules, 'tiles'>\n): { terrain: Terrain; base?: GroundBase } {\n\tif (!isGroundChanges(saved)) return { terrain: loadTerrain(saved) }\n\tconst base = maps ? findGround(maps, saved.map, saved.hash, game) : undefined\n\tif (!base) throw new MissingGround(saved.map, saved.hash)\n\treturn { terrain: applyGroundChanges(base.terrain, saved), base }\n}\n\n/**\n * A copy of a ground, the changes put on it\n *\n * @internal\n */\nexport function applyGroundChanges(from: Terrain, ground: GroundChanges): Terrain {\n\tconst terrain = cloneTerrain(from)\n\tfor (const key of LAYERS) {\n\t\tconst change = ground.changes[key]\n\t\tif (!change) continue\n\t\tconst layer = terrain[key]\n\t\tconst atBytes = unpackBytes(change.at, change.count * 4)\n\t\tconst toBytes = unpackBytes(change.to, change.count * (layer instanceof Float32Array ? 4 : 1))\n\t\tif (!atBytes || !toBytes) throw new Error(`Save: the changes of the ${key} of the ground are not what they say`)\n\t\tconst at = new Int32Array(atBytes.buffer)\n\t\tconst to = layer instanceof Float32Array ? new Float32Array(toBytes.buffer) : toBytes\n\t\tfor (let i = 0; i < at.length; i++) {\n\t\t\tif (at[i] < 0 || at[i] >= layer.length) throw new Error(`Save: a change of the ${key} is off the ground`)\n\t\t\tlayer[at[i]] = to[i]\n\t\t}\n\t}\n\tfor (const [id, change] of Object.entries(ground.cells ?? {})) {\n\t\tconst layer = terrain.cellLayer(id)\n\t\tconst atBytes = unpackBytes(change.at, change.count * 4)\n\t\tconst to = unpackBytes(change.to, change.count)\n\t\tif (!atBytes || !to) throw new Error(`Save: the changes of the cells of ${id} are not what they say`)\n\t\tconst at = new Int32Array(atBytes.buffer)\n\t\tfor (let i = 0; i < at.length; i++) {\n\t\t\tif (at[i] < 0 || at[i] >= layer.length) throw new Error(`Save: a change of the cells of ${id} is off the ground`)\n\t\t\tlayer[at[i]] = to[i]\n\t\t}\n\t}\n\tterrain.bounds = ground.bounds ? { ...ground.bounds } : undefined\n\treturn terrain\n}\n\n/**\n * A copy of a ground, every layer its own\n *\n * @internal\n */\nexport function cloneTerrain(from: Terrain): Terrain {\n\tconst terrain = new Terrain(from.width, from.depth, from.heights.slice(), from.levels.slice(), {\n\t\twater: from.water.slice(),\n\t\twaterHeights: from.waterHeights.slice(),\n\t\ttiles: from.tiles.slice(),\n\t\tblocked: from.blocked.slice(),\n\t\tcells: Object.fromEntries(Object.entries(from.cells).map(([id, layer]) => [id, layer.slice()]))\n\t})\n\tif (from.bounds) terrain.bounds = { ...from.bounds }\n\treturn terrain\n}\n\n/**\n * A part of the ground as it is, to put in another of the same size (`applyTerrainPatch`): a rectangle of cells and\n * every layer of it, the vertices at its corners included. What the editor's Play here sends of the map's ground as it\n * is edited (`debug.ground`, EQ10), and what a session is told of it (`ground`)\n *\n * @beta\n */\nexport interface TerrainPatch {\n\t/** The first cell, and how many across and down */\n\tx: number\n\t/** The patch's first cell on the z axis, in cells */\n\tz: number\n\t/** How many cells across the patch is */\n\twidth: number\n\t/** How many cells down the patch is */\n\tdepth: number\n\t/** Per vertex, row by row: `(width + 1) * (depth + 1)` of them */\n\theights: number[]\n\t/** Heights of the water at the patch's vertices, in the order of `heights` */\n\twaterHeights: number[]\n\t/** Per cell, row by row: `width * depth` of them */\n\tlevels: number[]\n\t/** Per cell, the water there (0 for none) */\n\twater: number[]\n\t/** Per cell, the tile there (an index into the game's tiles) */\n\ttiles: number[]\n\t/** Per cell, whether the cell is blocked for walking (0 for no) */\n\tblocked: number[]\n\t/** The game's layers of cells (`Terrain.cells`), by id, per cell: those in either ground */\n\tcells?: Record<string, number[]>\n}\n\n/**\n * The cells of two grounds of one size that are not the same, as the smallest rectangle around them; none where they\n * are the same. Every layer, the game's layers of cells too. Two of other sizes: all of `after`\n *\n * @beta\n */\nexport function groundDifference(before: Terrain, after: Terrain): { x: number; z: number; width: number; depth: number } | undefined {\n\tif (before.width !== after.width || before.depth !== after.depth) return { x: 0, z: 0, width: after.width, depth: after.depth }\n\tlet x0 = Infinity\n\tlet z0 = Infinity\n\tlet x1 = -1\n\tlet z1 = -1\n\tconst take = (x: number, z: number) => {\n\t\tif (x < x0) x0 = x\n\t\tif (z < z0) z0 = z\n\t\tif (x > x1) x1 = x\n\t\tif (z > z1) z1 = z\n\t}\n\tconst { width, depth, vertsX } = after\n\t// a vertex is a corner of the cells about it: the one up and left of it, where there is one, else the one there\n\tfor (const layer of ['heights', 'waterHeights'] as const) {\n\t\tconst a = before[layer]\n\t\tconst b = after[layer]\n\t\tfor (let i = 0; i < b.length; i++) {\n\t\t\tif (a[i] === b[i]) continue\n\t\t\tconst vx = i % vertsX\n\t\t\tconst vz = Math.floor(i / vertsX)\n\t\t\ttake(Math.min(vx, width - 1), Math.min(vz, depth - 1))\n\t\t\ttake(Math.max(vx - 1, 0), Math.max(vz - 1, 0))\n\t\t}\n\t}\n\tconst cellLayers = [...(['levels', 'water', 'tiles', 'blocked'] as const).map((layer) => [before[layer], after[layer]] as const)]\n\tfor (const id of new Set([...Object.keys(before.cells), ...Object.keys(after.cells)]))\n\t\tcellLayers.push([before.cells[id] ?? new Uint8Array(width * depth), after.cells[id] ?? new Uint8Array(width * depth)])\n\tfor (const [a, b] of cellLayers) {\n\t\tfor (let i = 0; i < b.length; i++) if (a[i] !== b[i]) take(i % width, Math.floor(i / width))\n\t}\n\treturn x1 < 0 ? undefined : { x: x0, z: z0, width: x1 - x0 + 1, depth: z1 - z0 + 1 }\n}\n\n/**\n * A rectangle of cells of a ground as it is (`TerrainPatch`): to be put in another\n *\n * @beta\n */\nexport function terrainPatch(terrain: Terrain, rect: { x: number; z: number; width: number; depth: number }): TerrainPatch {\n\tconst { x, z, width, depth } = rect\n\tconst vertices = (values: Float32Array) => {\n\t\tconst out: number[] = []\n\t\tfor (let vz = z; vz <= z + depth; vz++) for (let vx = x; vx <= x + width; vx++) out.push(values[vz * terrain.vertsX + vx])\n\t\treturn out\n\t}\n\tconst cells = (values: Uint8Array) => {\n\t\tconst out: number[] = []\n\t\tfor (let cz = z; cz < z + depth; cz++) for (let cx = x; cx < x + width; cx++) out.push(values[cz * terrain.width + cx])\n\t\treturn out\n\t}\n\tconst layers = Object.entries(terrain.cells)\n\treturn {\n\t\tx,\n\t\tz,\n\t\twidth,\n\t\tdepth,\n\t\theights: vertices(terrain.heights),\n\t\twaterHeights: vertices(terrain.waterHeights),\n\t\tlevels: cells(terrain.levels),\n\t\twater: cells(terrain.water),\n\t\ttiles: cells(terrain.tiles),\n\t\tblocked: cells(terrain.blocked),\n\t\t...(layers.length > 0 && { cells: Object.fromEntries(layers.map(([id, values]) => [id, cells(values)])) })\n\t}\n}\n\n/**\n * What is wrong with a patch for a ground (`TerrainPatch`): out of it, or of layers of other lengths. Nothing when it fits\n *\n * @beta\n */\nexport function terrainPatchProblem(terrain: Terrain, patch: TerrainPatch): string | undefined {\n\tconst { x, z, width, depth } = patch\n\tif (![x, z, width, depth].every(Number.isInteger) || x < 0 || z < 0 || width < 1 || depth < 1) return 'the patch is no rectangle of cells'\n\tif (x + width > terrain.width || z + depth > terrain.depth) return `the patch goes past the ground, ${terrain.width} by ${terrain.depth} cells`\n\tconst vertices = (width + 1) * (depth + 1)\n\tconst cells = width * depth\n\tif (patch.heights.length !== vertices || patch.waterHeights.length !== vertices) return `the patch has not ${vertices} heights`\n\tfor (const layer of [patch.levels, patch.water, patch.tiles, patch.blocked, ...Object.values(patch.cells ?? {})])\n\t\tif (layer.length !== cells) return `a layer of the patch has not ${cells} cells`\n\treturn undefined\n}\n\n/**\n * Puts a patch (`TerrainPatch`) in a ground, in place: its heights, water, paint and levels, and the game's layers of\n * cells (a layer the patch has that the ground has not is made). Nothing else: what the rules make of the ground is\n * `World.reshapeGround`'s. Throws where it does not fit (`terrainPatchProblem`)\n *\n * @beta\n */\nexport function applyTerrainPatch(terrain: Terrain, patch: TerrainPatch): void {\n\tconst problem = terrainPatchProblem(terrain, patch)\n\tif (problem) throw new Error(`applyTerrainPatch: ${problem}`)\n\tconst { x, z, width, depth } = patch\n\tlet i = 0\n\tfor (let vz = z; vz <= z + depth; vz++) {\n\t\tfor (let vx = x; vx <= x + width; vx++, i++) {\n\t\t\tconst at = vz * terrain.vertsX + vx\n\t\t\tterrain.heights[at] = patch.heights[i]\n\t\t\tterrain.waterHeights[at] = patch.waterHeights[i]\n\t\t}\n\t}\n\tconst layers: [Uint8Array, number[]][] = [\n\t\t[terrain.levels, patch.levels],\n\t\t[terrain.water, patch.water],\n\t\t[terrain.tiles, patch.tiles],\n\t\t[terrain.blocked, patch.blocked],\n\t\t...Object.entries(patch.cells ?? {}).map(([id, values]): [Uint8Array, number[]] => [terrain.cellLayer(id), values])\n\t]\n\tfor (const [into, values] of layers) {\n\t\tlet j = 0\n\t\tfor (let cz = z; cz < z + depth; cz++) for (let cx = x; cx < x + width; cx++, j++) into[cz * terrain.width + cx] = values[j]\n\t}\n}\n"],"mappings":";;;;;;AA4CA,IAAM,SAAS;CAAC;CAAW;CAAU;CAAS;CAAgB;CAAS;AAAS;;;;;;AAahF,IAAa,mBAAmB,WAAiD,OAAQ,OAAyB,QAAQ;;;;;;;AAQ1H,SAAgB,gBAAgB,KAAc,MAAqC;CAClF,MAAM,UAAU,aACd,KAAK,SAAS,CAAC,EAAA,CAAG,KAAK,SAAS,KAAK,EAAE,GACxC,IAAI,WACL;CACA,OAAO,WAAW;EAAE,GAAG;EAAK,OAAO,SAAS,KAAK,OAAO;EAAG,SAAS;CAAQ,CAAC;AAC9E;;;;;;AAOA,SAAgB,WAAW,SAA0B;CACpD,IAAI,IAAI;CACR,IAAI,IAAI;CACR,MAAM,OAAO,SAAiB;EAC7B,IAAI,KAAK,KAAK,IAAI,MAAM,QAAU;EAClC,IAAI,KAAK,KAAK,IAAI,MAAM,UAAU;CACnC;CACA,IAAI,QAAQ,KAAK;CACjB,IAAI,QAAQ,KAAK;CACjB,MAAM,SAAwC,OAAO,KAAK,QAAQ,QAAQ,IAAI;CAE9E,KAAK,MAAM,MAAM,OAAO,KAAK,QAAQ,KAAK,CAAC,CAAC,KAAK,GAAG;EACnD,MAAM,QAAQ,QAAQ,MAAM;EAC5B,IAAI,CAAC,MAAM,MAAM,UAAU,UAAU,CAAC,GAAG;EACzC,KAAK,IAAI,IAAI,GAAG,IAAI,GAAG,QAAQ,KAAK,IAAI,GAAG,WAAW,CAAC,CAAC;EACxD,OAAO,KAAK,KAAK;CAClB;CACA,KAAK,MAAM,SAAS,QAAQ;EAC3B,MAAM,QAAQ,IAAI,WAAW,MAAM,QAAQ,MAAM,YAAY,MAAM,UAAU;EAC7E,MAAM,QAAQ,KAAK,MAAM,MAAM,SAAS,CAAC;EACzC,MAAM,OAAO,IAAI,SAAS,MAAM,QAAQ,MAAM,YAAY,MAAM,UAAU;EAC1E,KAAK,IAAI,IAAI,GAAG,IAAI,OAAO,KAAK,IAAI,KAAK,UAAU,IAAI,GAAG,IAAI,CAAC;EAC/D,KAAK,IAAI,IAAI,QAAQ,GAAG,IAAI,MAAM,QAAQ,KAAK,IAAI,MAAM,EAAE;EAC3D,IAAI,UAAU;CACf;CACA,QAAQ,MAAM,EAAA,CAAG,SAAS,EAAE,CAAC,CAAC,SAAS,GAAG,GAAG,KAAK,MAAM,EAAA,CAAG,SAAS,EAAE,CAAC,CAAC,SAAS,GAAG,GAAG;AACxF;;;;;;AAqBA,SAAgB,UAAU,KAAa,SAA8B;CACpE,IAAI;CACJ,OAAO;EACN;EACA;EACA,IAAI,OAAO;GACV,OAAQ,SAAS,WAAW,OAAO;EACpC;CACD;AACD;;;;;AAMA,IAAM,wBAAQ,IAAI,QAA0C;;;;;;AAM5D,SAAgB,WAAW,KAAc,MAAwC;CAChF,MAAM,MAAM,aACV,KAAK,SAAS,CAAC,EAAA,CAAG,KAAK,SAAS,KAAK,EAAE,GACxC,IAAI,WACL,CAAC,CAAC,KAAK;CACP,IAAI,QAAQ,MAAM,IAAI,GAAG;CACzB,IAAI,CAAC,OAAO,MAAM,IAAI,KAAM,wBAAQ,IAAI,IAAI,CAAE;CAC9C,IAAI,OAAO,MAAM,IAAI,GAAG;CACxB,IAAI,CAAC,MAAM;EACV,MAAM,UAAU,gBAAgB,KAAK,IAAI;EACzC,MAAM,IAAI,KAAM,OAAO,UAAU,IAAI,MAAM,OAAO,CAAE;CACrD;CACA,OAAO;AACR;;;;;;AAOA,SAAgB,WAAW,MAA0B,MAAc,MAAc,MAAoD;CACpI,KAAK,MAAM,OAAO,MAAM,IAAI,IAAI,SAAS,QAAQ,WAAW,KAAK,IAAI,CAAC,CAAC,SAAS,MAAM,OAAO,WAAW,KAAK,IAAI;AAElH;;;;;;;AAQA,SAAgB,YACf,SACA,MACA,MACA,MACc;CACd,IAAI,CAAC,QAAQ,CAAC,MAAM,UAAU,CAAC,WAAW,MAAM,KAAK,KAAK,KAAK,MAAM,IAAI,GAAG,OAAO,YAAY,OAAO;CACtG,MAAM,OAAO,KAAK;CAClB,IAAI,KAAK,UAAU,QAAQ,SAAS,KAAK,UAAU,QAAQ,OAAO,OAAO,YAAY,OAAO;CAC5F,MAAM,UAAoC,CAAC;CAC3C,KAAK,MAAM,OAAO,QAAQ;EACzB,MAAM,MAAM,QAAQ;EACpB,MAAM,MAAM,KAAK;EACjB,MAAM,KAAe,CAAC;EACtB,KAAK,IAAI,IAAI,GAAG,IAAI,IAAI,QAAQ,KAAK,IAAI,IAAI,OAAO,IAAI,IAAI,GAAG,KAAK,CAAC;EACrE,IAAI,CAAC,GAAG,QAAQ;EAChB,MAAM,SAAS,eAAe,eAAe,aAAa,KAAK,KAAK,MAAM,IAAI,EAAE,IAAI,WAAW,KAAK,KAAK,MAAM,IAAI,EAAE;EACrH,QAAQ,OAAO;GACd,OAAO,GAAG;GACV,IAAI,UAAU,WAAW,KAAK,EAAE,CAAC;GACjC,IAAI,kBAAkB,eAAe,UAAU,MAAM,IAAI,UAAU,MAAM;EAC1E;CACD;CACA,MAAM,QAA6C,CAAC;CACpD,KAAK,MAAM,sBAAM,IAAI,IAAI,CAAC,GAAG,OAAO,KAAK,QAAQ,KAAK,GAAG,GAAG,OAAO,KAAK,KAAK,KAAK,CAAC,CAAC,GAAG;EACtF,MAAM,MAAM,QAAQ,MAAM;EAC1B,MAAM,MAAM,KAAK,MAAM;EACvB,MAAM,KAAe,CAAC;EACtB,KAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,QAAQ,QAAQ,OAAO,KAAK,KAAK,MAAM,MAAM,QAAQ,MAAM,MAAM,IAAI,GAAG,KAAK,CAAC;EAC1G,IAAI,GAAG,QAAQ,MAAM,MAAM;GAAE,OAAO,GAAG;GAAQ,IAAI,UAAU,WAAW,KAAK,EAAE,CAAC;GAAG,IAAI,UAAU,WAAW,KAAK,KAAK,MAAM,MAAM,MAAM,CAAC,CAAC;EAAE;CAC7I;CACA,OAAO;EACN,KAAK,KAAK;EACV,MAAM,KAAK;EACX,OAAO,QAAQ;EACf,OAAO,QAAQ;EACf;EACA,GAAI,OAAO,KAAK,KAAK,CAAC,CAAC,UAAU,EAAE,MAAM;EACzC,GAAI,QAAQ,UAAU,EAAE,QAAQ,EAAE,GAAG,QAAQ,OAAO,EAAE;CACvD;AACD;;;;;;AAOA,IAAa,gBAAb,cAAmC,MAAM;CAG9B;CAEA;CAJV,YAEC,KAEA,MACC;EACD,MAAM,0BAA0B,IAAI,eAAe,KAAK,oEAAoE;EAJnH,KAAA,MAAA;EAEA,KAAA,OAAA;CAGV;AACD;;;;;;;AAQA,SAAgB,SACf,OACA,MACA,MAC0C;CAC1C,IAAI,CAAC,gBAAgB,KAAK,GAAG,OAAO,EAAE,SAAS,YAAY,KAAK,EAAE;CAClE,MAAM,OAAO,OAAO,WAAW,MAAM,MAAM,KAAK,MAAM,MAAM,IAAI,IAAI,KAAA;CACpE,IAAI,CAAC,MAAM,MAAM,IAAI,cAAc,MAAM,KAAK,MAAM,IAAI;CACxD,OAAO;EAAE,SAAS,mBAAmB,KAAK,SAAS,KAAK;EAAG;CAAK;AACjE;;;;;;AAOA,SAAgB,mBAAmB,MAAe,QAAgC;CACjF,MAAM,UAAU,aAAa,IAAI;CACjC,KAAK,MAAM,OAAO,QAAQ;EACzB,MAAM,SAAS,OAAO,QAAQ;EAC9B,IAAI,CAAC,QAAQ;EACb,MAAM,QAAQ,QAAQ;EACtB,MAAM,UAAU,YAAY,OAAO,IAAI,OAAO,QAAQ,CAAC;EACvD,MAAM,UAAU,YAAY,OAAO,IAAI,OAAO,SAAS,iBAAiB,eAAe,IAAI,EAAE;EAC7F,IAAI,CAAC,WAAW,CAAC,SAAS,MAAM,IAAI,MAAM,4BAA4B,IAAI,qCAAqC;EAC/G,MAAM,KAAK,IAAI,WAAW,QAAQ,MAAM;EACxC,MAAM,KAAK,iBAAiB,eAAe,IAAI,aAAa,QAAQ,MAAM,IAAI;EAC9E,KAAK,IAAI,IAAI,GAAG,IAAI,GAAG,QAAQ,KAAK;GACnC,IAAI,GAAG,KAAK,KAAK,GAAG,MAAM,MAAM,QAAQ,MAAM,IAAI,MAAM,yBAAyB,IAAI,mBAAmB;GACxG,MAAM,GAAG,MAAM,GAAG;EACnB;CACD;CACA,KAAK,MAAM,CAAC,IAAI,WAAW,OAAO,QAAQ,OAAO,SAAS,CAAC,CAAC,GAAG;EAC9D,MAAM,QAAQ,QAAQ,UAAU,EAAE;EAClC,MAAM,UAAU,YAAY,OAAO,IAAI,OAAO,QAAQ,CAAC;EACvD,MAAM,KAAK,YAAY,OAAO,IAAI,OAAO,KAAK;EAC9C,IAAI,CAAC,WAAW,CAAC,IAAI,MAAM,IAAI,MAAM,qCAAqC,GAAG,uBAAuB;EACpG,MAAM,KAAK,IAAI,WAAW,QAAQ,MAAM;EACxC,KAAK,IAAI,IAAI,GAAG,IAAI,GAAG,QAAQ,KAAK;GACnC,IAAI,GAAG,KAAK,KAAK,GAAG,MAAM,MAAM,QAAQ,MAAM,IAAI,MAAM,kCAAkC,GAAG,mBAAmB;GAChH,MAAM,GAAG,MAAM,GAAG;EACnB;CACD;CACA,QAAQ,SAAS,OAAO,SAAS,EAAE,GAAG,OAAO,OAAO,IAAI,KAAA;CACxD,OAAO;AACR;;;;;;AAOA,SAAgB,aAAa,MAAwB;CACpD,MAAM,UAAU,IAAI,QAAQ,KAAK,OAAO,KAAK,OAAO,KAAK,QAAQ,MAAM,GAAG,KAAK,OAAO,MAAM,GAAG;EAC9F,OAAO,KAAK,MAAM,MAAM;EACxB,cAAc,KAAK,aAAa,MAAM;EACtC,OAAO,KAAK,MAAM,MAAM;EACxB,SAAS,KAAK,QAAQ,MAAM;EAC5B,OAAO,OAAO,YAAY,OAAO,QAAQ,KAAK,KAAK,CAAC,CAAC,KAAK,CAAC,IAAI,WAAW,CAAC,IAAI,MAAM,MAAM,CAAC,CAAC,CAAC;CAC/F,CAAC;CACD,IAAI,KAAK,QAAQ,QAAQ,SAAS,EAAE,GAAG,KAAK,OAAO;CACnD,OAAO;AACR;;;;;;;AAwCA,SAAgB,iBAAiB,QAAiB,OAAoF;CACrI,IAAI,OAAO,UAAU,MAAM,SAAS,OAAO,UAAU,MAAM,OAAO,OAAO;EAAE,GAAG;EAAG,GAAG;EAAG,OAAO,MAAM;EAAO,OAAO,MAAM;CAAM;CAC9H,IAAI,KAAK;CACT,IAAI,KAAK;CACT,IAAI,KAAK;CACT,IAAI,KAAK;CACT,MAAM,QAAQ,GAAW,MAAc;EACtC,IAAI,IAAI,IAAI,KAAK;EACjB,IAAI,IAAI,IAAI,KAAK;EACjB,IAAI,IAAI,IAAI,KAAK;EACjB,IAAI,IAAI,IAAI,KAAK;CAClB;CACA,MAAM,EAAE,OAAO,OAAO,WAAW;CAEjC,KAAK,MAAM,SAAS,CAAC,WAAW,cAAc,GAAY;EACzD,MAAM,IAAI,OAAO;EACjB,MAAM,IAAI,MAAM;EAChB,KAAK,IAAI,IAAI,GAAG,IAAI,EAAE,QAAQ,KAAK;GAClC,IAAI,EAAE,OAAO,EAAE,IAAI;GACnB,MAAM,KAAK,IAAI;GACf,MAAM,KAAK,KAAK,MAAM,IAAI,MAAM;GAChC,KAAK,KAAK,IAAI,IAAI,QAAQ,CAAC,GAAG,KAAK,IAAI,IAAI,QAAQ,CAAC,CAAC;GACrD,KAAK,KAAK,IAAI,KAAK,GAAG,CAAC,GAAG,KAAK,IAAI,KAAK,GAAG,CAAC,CAAC;EAC9C;CACD;CACA,MAAM,aAAa,CAAC,GAAI;EAAC;EAAU;EAAS;EAAS;CAAS,CAAC,CAAW,KAAK,UAAU,CAAC,OAAO,QAAQ,MAAM,MAAM,CAAU,CAAC;CAChI,KAAK,MAAM,sBAAM,IAAI,IAAI,CAAC,GAAG,OAAO,KAAK,OAAO,KAAK,GAAG,GAAG,OAAO,KAAK,MAAM,KAAK,CAAC,CAAC,GACnF,WAAW,KAAK,CAAC,OAAO,MAAM,OAAO,IAAI,WAAW,QAAQ,KAAK,GAAG,MAAM,MAAM,OAAO,IAAI,WAAW,QAAQ,KAAK,CAAC,CAAC;CACtH,KAAK,MAAM,CAAC,GAAG,MAAM,YACpB,KAAK,IAAI,IAAI,GAAG,IAAI,EAAE,QAAQ,KAAK,IAAI,EAAE,OAAO,EAAE,IAAI,KAAK,IAAI,OAAO,KAAK,MAAM,IAAI,KAAK,CAAC;CAE5F,OAAO,KAAK,IAAI,KAAA,IAAY;EAAE,GAAG;EAAI,GAAG;EAAI,OAAO,KAAK,KAAK;EAAG,OAAO,KAAK,KAAK;CAAE;AACpF;;;;;;AAOA,SAAgB,aAAa,SAAkB,MAA4E;CAC1H,MAAM,EAAE,GAAG,GAAG,OAAO,UAAU;CAC/B,MAAM,YAAY,WAAyB;EAC1C,MAAM,MAAgB,CAAC;EACvB,KAAK,IAAI,KAAK,GAAG,MAAM,IAAI,OAAO,MAAM,KAAK,IAAI,KAAK,GAAG,MAAM,IAAI,OAAO,MAAM,IAAI,KAAK,OAAO,KAAK,QAAQ,SAAS,GAAG;EACzH,OAAO;CACR;CACA,MAAM,SAAS,WAAuB;EACrC,MAAM,MAAgB,CAAC;EACvB,KAAK,IAAI,KAAK,GAAG,KAAK,IAAI,OAAO,MAAM,KAAK,IAAI,KAAK,GAAG,KAAK,IAAI,OAAO,MAAM,IAAI,KAAK,OAAO,KAAK,QAAQ,QAAQ,GAAG;EACtH,OAAO;CACR;CACA,MAAM,SAAS,OAAO,QAAQ,QAAQ,KAAK;CAC3C,OAAO;EACN;EACA;EACA;EACA;EACA,SAAS,SAAS,QAAQ,OAAO;EACjC,cAAc,SAAS,QAAQ,YAAY;EAC3C,QAAQ,MAAM,QAAQ,MAAM;EAC5B,OAAO,MAAM,QAAQ,KAAK;EAC1B,OAAO,MAAM,QAAQ,KAAK;EAC1B,SAAS,MAAM,QAAQ,OAAO;EAC9B,GAAI,OAAO,SAAS,KAAK,EAAE,OAAO,OAAO,YAAY,OAAO,KAAK,CAAC,IAAI,YAAY,CAAC,IAAI,MAAM,MAAM,CAAC,CAAC,CAAC,EAAE;CACzG;AACD;;;;;;AAOA,SAAgB,oBAAoB,SAAkB,OAAyC;CAC9F,MAAM,EAAE,GAAG,GAAG,OAAO,UAAU;CAC/B,IAAI,CAAC;EAAC;EAAG;EAAG;EAAO;CAAK,CAAC,CAAC,MAAM,OAAO,SAAS,KAAK,IAAI,KAAK,IAAI,KAAK,QAAQ,KAAK,QAAQ,GAAG,OAAO;CACtG,IAAI,IAAI,QAAQ,QAAQ,SAAS,IAAI,QAAQ,QAAQ,OAAO,OAAO,mCAAmC,QAAQ,MAAM,MAAM,QAAQ,MAAM;CACxI,MAAM,YAAY,QAAQ,MAAM,QAAQ;CACxC,MAAM,QAAQ,QAAQ;CACtB,IAAI,MAAM,QAAQ,WAAW,YAAY,MAAM,aAAa,WAAW,UAAU,OAAO,qBAAqB,SAAS;CACtH,KAAK,MAAM,SAAS;EAAC,MAAM;EAAQ,MAAM;EAAO,MAAM;EAAO,MAAM;EAAS,GAAG,OAAO,OAAO,MAAM,SAAS,CAAC,CAAC;CAAC,GAC9G,IAAI,MAAM,WAAW,OAAO,OAAO,gCAAgC,MAAM;AAE3E;;;;;;;;AASA,SAAgB,kBAAkB,SAAkB,OAA2B;CAC9E,MAAM,UAAU,oBAAoB,SAAS,KAAK;CAClD,IAAI,SAAS,MAAM,IAAI,MAAM,sBAAsB,SAAS;CAC5D,MAAM,EAAE,GAAG,GAAG,OAAO,UAAU;CAC/B,IAAI,IAAI;CACR,KAAK,IAAI,KAAK,GAAG,MAAM,IAAI,OAAO,MACjC,KAAK,IAAI,KAAK,GAAG,MAAM,IAAI,OAAO,MAAM,KAAK;EAC5C,MAAM,KAAK,KAAK,QAAQ,SAAS;EACjC,QAAQ,QAAQ,MAAM,MAAM,QAAQ;EACpC,QAAQ,aAAa,MAAM,MAAM,aAAa;CAC/C;CAED,MAAM,SAAmC;EACxC,CAAC,QAAQ,QAAQ,MAAM,MAAM;EAC7B,CAAC,QAAQ,OAAO,MAAM,KAAK;EAC3B,CAAC,QAAQ,OAAO,MAAM,KAAK;EAC3B,CAAC,QAAQ,SAAS,MAAM,OAAO;EAC/B,GAAG,OAAO,QAAQ,MAAM,SAAS,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,YAAoC,CAAC,QAAQ,UAAU,EAAE,GAAG,MAAM,CAAC;CACnH;CACA,KAAK,MAAM,CAAC,MAAM,WAAW,QAAQ;EACpC,IAAI,IAAI;EACR,KAAK,IAAI,KAAK,GAAG,KAAK,IAAI,OAAO,MAAM,KAAK,IAAI,KAAK,GAAG,KAAK,IAAI,OAAO,MAAM,KAAK,KAAK,KAAK,QAAQ,QAAQ,MAAM,OAAO;CAC3H;AACD"}

package/dist/groundObjects.d.ts

@@ -0,0 +1,70 @@
+import { type Entity, type EntityId } from './entity';
+import type { GamePack } from './packs/pack';
+import type { World } from './world';
+/**
+ * The ground objects pack's id
+ *
+ * @beta
+ */
+export declare const GROUND_OBJECTS = "core.groundObjects";
+/**
+ * Who put a unit down, for one made by a `spawn` of the ground objects pack: in whose name what it does goes off (`by`),
+ * by which ability and at what level, and the others put down with it (`group`, in order: a portal's other end)
+ *
+ * @beta
+ */
+export interface MadeBy {
+    /** Who put it down */
+    by: EntityId;
+    /** The ability it was put down by */
+    ability: string;
+    /** The level it was cast at */
+    level: number;
+    /** Those put down with it, itself among them, in the order they were laid: where there were more than one */
+    group?: EntityId[];
+}
+/**
+ * What a ground object keeps of what it does (`UnitTypeDef.trigger`, `use`): seconds before it is armed, times it went
+ * off or was used, and who is within its reach now (each sets it off as it comes, not again while it stays)
+ *
+ * @beta
+ */
+export interface GroundObjectState {
+    /** Seconds before its trigger works */
+    arm?: number;
+    /** Times it went off, or was used */
+    went?: number;
+    /** Who is within its trigger's reach now, by id */
+    inside?: EntityId[];
+}
+/**
+ * Who put a unit down (`MadeBy`): on what a `spawn` of the pack makes
+ *
+ * @beta
+ */
+export declare const madeBy: import("./components").Component<MadeBy, MadeBy>;
+/**
+ * What a ground object keeps (`GroundObjectState`): on every unit whose type has a `trigger`, a `use`,
+ * `blocksMissiles` or a `burst`, from the moment it is made
+ *
+ * @beta
+ */
+export declare const groundObject: import("./components").Component<GroundObjectState, GroundObjectState>;
+/**
+ * Uses a ground object (`UnitTypeDef.use`), as the `useObject` order does once there: its ability goes off, the user
+ * its target, and it is gone after its `times`. False where it is no such thing, or not for this one
+ *
+ * @beta
+ */
+export declare function useObject(world: World, user: Entity, object: Entity): boolean;
+/**
+ * Ground objects: what a game with it (`Rules.packs`) gets for what abilities put down. Its `spawn` lays units along a
+ * `line` or round a `ring` (buildings one to a cell, standing in the way as any building does), each knowing who put it
+ * down (`madeBy`); a unit type may be a trap or a pickup (`trigger`: its ability goes off as one it is for comes near,
+ * armed after `arm`, gone after `times`), a thing others use (`use`: right-clicked, walked up to and used, the
+ * `useObject` order; `useObject` in code), a wall that stops missiles (`blocksMissiles`) or a barrel that bursts as it
+ * dies and sets off those of its kind near it (`burst`)
+ *
+ * @beta
+ */
+export declare function groundObjectsPack(): GamePack;