@v12-engine/engine 0.1.1 → 0.4.0

package/dist/concealment.js

@@ -0,0 +1,409 @@
+import { cellsChanged, groundReshaped, rustled } from "./engineEvents.js";
+import { replicateEvent } from "./replication.js";
+import { detection, exposure } from "./entity.js";
+import { defineHook } from "./hooks.js";
+import { floodCells } from "./cellPatches.js";
+//#region src/concealment.ts
+var known = /* @__PURE__ */ new WeakMap();
+/** How the game's pack on a layer hides in it (`conceals`, `follows`), read from its hook: none where no pack is on it */
+function concealingOf(world, layer) {
+	for (const hook of world.registry.assembly?.hooks ?? []) {
+		const concealing = hook.concealing;
+		if (concealing?.layer === layer) return concealing;
+	}
+}
+/** The patches of the layer of a world, worked out again when the layer, or one it follows, changed since */
+function patchesOf(world, layer) {
+	let byLayer = known.get(world);
+	if (!byLayer) known.set(world, byLayer = /* @__PURE__ */ new Map());
+	let patches = byLayer.get(layer);
+	if (!patches) {
+		const how = concealingOf(world, layer);
+		const follows = how?.follows ?? [];
+		const made = {
+			cells: void 0,
+			of: /* @__PURE__ */ new Int32Array(0),
+			hiding: void 0,
+			conceals: how?.conceals,
+			next: 0,
+			searched: /* @__PURE__ */ new Int32Array(0),
+			searcher: /* @__PURE__ */ new Uint8Array(0),
+			stamp: 0,
+			dirty: true,
+			counted: false,
+			occupied: /* @__PURE__ */ new Map(),
+			stop: () => {}
+		};
+		const stopCells = world.events.on(cellsChanged, (change) => {
+			if (change.layer === layer || follows.includes(change.layer)) follow(world, made, layer, change.cells);
+		});
+		const stopGround = world.events.on(groundReshaped, ({ patch }) => {
+			const cells = patch.cells;
+			if (cells && (layer in cells || follows.some((id) => id in cells))) made.dirty = true;
+		});
+		made.stop = () => {
+			stopCells();
+			stopGround();
+		};
+		byLayer.set(layer, patches = made);
+	}
+	const cells = world.terrain.cells[layer];
+	if (patches.dirty || patches.cells !== cells) {
+		label(world, patches, cells);
+		patches.cells = cells;
+		patches.dirty = false;
+	}
+	return patches;
+}
+/**
+* The patches of a layer of a world worked out again whole at the next ask: after what decides which cells hide
+* changed while no cell did (a style's `conceals` changed in play, `debug.cellStyles`), who has someone in which
+* counted again of them
+*
+* @internal
+*/
+function markPatchesStale(world, layer) {
+	const patches = known.get(world)?.get(layer);
+	if (!patches) return;
+	patches.dirty = true;
+	patches.counted = false;
+}
+/**
+* The patches of a layer: each cell the number of the patch it is in, of the cells that hide and touch (corners too).
+* Into the patches' own arrays, where they are the size of the map
+*/
+function label(world, patches, cells) {
+	const { width, depth } = world.terrain;
+	const of = patches.of = new Int32Array(width * depth);
+	if (!cells) return;
+	let hiding = cells;
+	const { conceals } = patches;
+	if (conceals) {
+		if (patches.hiding?.length !== cells.length) patches.hiding = new Uint8Array(cells.length);
+		hiding = patches.hiding;
+		for (let c = 0; c < cells.length; c++) hiding[c] = cells[c] && conceals(world, c) ? 1 : 0;
+	}
+	let next = 0;
+	const stack = [];
+	for (let start = 0; start < hiding.length; start++) if (hiding[start] && !of[start]) floodCells(width, depth, hiding, -1, start, of, ++next, stack);
+	patches.next = next;
+}
+/** The eight cells about one, in order round it (a corner, a side, a corner…): what is asked of a cell that stops hiding */
+var ROUND_X = [
+	-1,
+	0,
+	1,
+	1,
+	1,
+	0,
+	-1,
+	-1
+];
+var ROUND_Z = [
+	-1,
+	-1,
+	-1,
+	0,
+	1,
+	1,
+	1,
+	0
+];
+/**
+* Cells of the layer, or of one it follows, changed: each that started or stopped hiding is followed into the
+* patches where that is sure (`leave`, `join`), so that a fire that changes cells every tick does not have the whole
+* map worked out again every tick. Where it is not, the patches are marked to be worked out again at the next ask
+*/
+function follow(world, patches, layer, changed) {
+	if (patches.dirty) return;
+	const cells = world.terrain.cells[layer];
+	if (!cells || patches.cells !== cells || patches.of.length !== cells.length) return void (patches.dirty = true);
+	const { of, conceals } = patches;
+	for (let i = 0; i < changed.length; i++) {
+		const cell = changed[i];
+		const was = of[cell] !== 0;
+		if (was === (cells[cell] !== 0 && (!conceals || conceals(world, cell)))) continue;
+		if (!(was ? leave(world, patches, cell) : join(world, patches, cell))) return void (patches.dirty = true);
+	}
+}
+/**
+* A cell stops hiding: out of its patch. The patch stays one where the cells about it that hide touch each other
+* round it (one run of them round the cell, a corner between two sides counting as touching): any way through the
+* cell goes round it. Else the patch may have come apart there, and the parts are looked for (`part`)
+*/
+function leave(world, patches, cell) {
+	const { width, depth } = world.terrain;
+	const { of } = patches;
+	of[cell] = 0;
+	const x = cell % width;
+	const z = (cell - x) / width;
+	let mask = 0;
+	for (let i = 0; i < 8; i++) {
+		const nx = x + ROUND_X[i];
+		const nz = z + ROUND_Z[i];
+		if (nx >= 0 && nz >= 0 && nx < width && nz < depth && of[nz * width + nx]) mask |= 1 << i;
+	}
+	let joined = mask;
+	for (let i = 0; i < 8; i += 2) if (!(mask & 1 << i) && mask & 1 << (i + 7 & 7) && mask & 1 << i + 1) joined |= 1 << i;
+	const starts = [];
+	for (let i = 0; i < 8; i++) if (joined & 1 << i && !(joined & 1 << (i + 7 & 7))) starts.push(i);
+	if (starts.length <= 1) return true;
+	part(world, patches, starts.map((i) => {
+		const at = mask & 1 << i ? i : i + 1 & 7;
+		return (z + ROUND_Z[at]) * width + x + ROUND_X[at];
+	}));
+	return true;
+}
+/**
+* A patch may have come apart: searches from a cell of each part, a step each in turn, through the cells of the
+* patch. Two that meet are one part; one that runs out has gone through a part of its own, given a patch number of
+* its own. It stops as soon as one search is left: what it goes through is about the smaller parts, not the patch
+*/
+function part(world, patches, from) {
+	const { width, depth } = world.terrain;
+	const { of } = patches;
+	if (patches.searched.length !== of.length) {
+		patches.searched = new Int32Array(of.length);
+		patches.searcher = new Uint8Array(of.length);
+		patches.stamp = 0;
+	}
+	const stamp = ++patches.stamp;
+	const { searched, searcher } = patches;
+	const patch = of[from[0]];
+	const count = from.length;
+	const queues = from.map((cell) => [cell]);
+	const heads = from.map(() => 0);
+	const went = from.map((cell) => [cell]);
+	const one = from.map((_, i) => i);
+	const done = from.map(() => false);
+	const find = (i) => {
+		while (one[i] !== i) i = one[i] = one[one[i]];
+		return i;
+	};
+	from.forEach((cell, i) => {
+		searched[cell] = stamp;
+		searcher[cell] = i;
+	});
+	let going = count;
+	while (going > 1) for (let s = 0; s < count && going > 1; s++) {
+		if (one[s] !== s || done[s]) continue;
+		if (heads[s] >= queues[s].length) {
+			done[s] = true;
+			going--;
+			continue;
+		}
+		const cell = queues[s][heads[s]++];
+		const x = cell % width;
+		const z = (cell - x) / width;
+		for (let i = 0; i < 8; i++) {
+			const nx = x + ROUND_X[i];
+			const nz = z + ROUND_Z[i];
+			if (nx < 0 || nz < 0 || nx >= width || nz >= depth) continue;
+			const n = nz * width + nx;
+			if (of[n] !== patch) continue;
+			if (searched[n] === stamp) {
+				const other = find(searcher[n]);
+				if (other === s) continue;
+				one[other] = s;
+				for (let k = heads[other]; k < queues[other].length; k++) queues[s].push(queues[other][k]);
+				for (const each of went[other]) went[s].push(each);
+				going--;
+				continue;
+			}
+			searched[n] = stamp;
+			searcher[n] = s;
+			queues[s].push(n);
+			went[s].push(n);
+		}
+	}
+	let kept = from.findIndex((_, s) => one[s] === s && !done[s]);
+	for (let s = 0; s < count; s++) {
+		if (one[s] !== s || s === kept) continue;
+		if (kept < 0) {
+			kept = s;
+			continue;
+		}
+		const number = ++patches.next;
+		for (const cell of went[s]) of[cell] = number;
+	}
+}
+/**
+* A cell starts hiding: into the patch about it, or a patch of its own where none is about. Where it joins two
+* patches into one it is not followed (false): the patches are worked out again
+*/
+function join(world, patches, cell) {
+	const { width, depth } = world.terrain;
+	const { of } = patches;
+	const x = cell % width;
+	const z = (cell - x) / width;
+	let found = 0;
+	for (let i = 0; i < 8; i++) {
+		const nx = x + ROUND_X[i];
+		const nz = z + ROUND_Z[i];
+		if (nx < 0 || nz < 0 || nx >= width || nz >= depth) continue;
+		const patch = of[nz * width + nx];
+		if (!patch || patch === found) continue;
+		if (found) return false;
+		found = patch;
+	}
+	of[cell] = found || ++patches.next;
+	return true;
+}
+/** Units on the ground, not structures: what hides when a game does not say */
+var onTheGround = (_world, entity) => !entity.def.footprint && !entity.flying && entity.def.kind === "unit";
+/**
+* The patch of a layer an entity stands in, 1 and up, or 0 where it stands in none (`ConcealmentOptions`). For a
+* game's rules and screen: who is in the grass
+*
+* @beta
+*/
+function patchAt(world, layer, x, z) {
+	const { terrain } = world;
+	if (x < 0 || z < 0 || x >= terrain.width || z >= terrain.depth) return 0;
+	return patchesOf(world, layer).of[Math.floor(z) * terrain.width + Math.floor(x)];
+}
+/**
+* A game where what stands in a layer of cells is hidden from the teams that are not in it with them (see
+* `ConcealmentOptions`): a `visible` hook, and a system that works out who has someone in which patch at the start of
+* every tick (the same in every copy of the game, whoever asks what in between). On as many layers as it is given
+*
+* @beta
+*/
+function concealmentPack(options) {
+	const { layer, hides = onTheGround, seenBy } = options;
+	const reach = options.reach ?? 2;
+	const id = options.id ?? `concealment:${layer}`;
+	const { rustle } = options;
+	const count = {
+		name: id,
+		phase: "commands",
+		update(world) {
+			if (!world.terrain.cells[layer]) return;
+			const patches = patchesOf(world, layer);
+			const { eachUnit } = options;
+			countOccupied(world, patches, hides, eachUnit);
+			if (eachUnit?.done(world)) countOccupied(world, patchesOf(world, layer), hides);
+			if (rustle) tellRustles(world, layer, patches, hides, rustle, options.rustleEvery ?? .3);
+		}
+	};
+	return {
+		id: "concealment",
+		options,
+		hooks: [{
+			...defineHook({
+				hook: "visible",
+				id,
+				run(world, event) {
+					if (!event.visible) return;
+					const { entity, team } = event;
+					if (!world.terrain.cells[layer]) return;
+					const patches = patchesOf(world, layer);
+					const { width, depth } = world.terrain;
+					const { x, z } = entity.pos;
+					if (x < 0 || z < 0 || x >= width || z >= depth) return;
+					const patch = patches.of[Math.floor(z) * width + Math.floor(x)];
+					if (!patch || !hides(world, entity)) return;
+					if (entity.get(exposure)?.has(team) || entity.get(detection)?.has(team)) return;
+					if (!patches.counted) countOccupied(world, patches, hides);
+					if (patches.occupied.get(team)?.has(patch)) return;
+					for (const near of world.spatial.query(x, z, reach, nearby)) {
+						if (near === entity || !near.alive || near.hidden) continue;
+						if (world.player(near.owner).team !== team || world.player(near.owner).neutral) continue;
+						const dx = near.pos.x - x;
+						const dz = near.pos.z - z;
+						if (dx * dx + dz * dz <= reach * reach) return;
+					}
+					if (seenBy?.(world, entity, team)) return;
+					event.visible = false;
+				}
+			}),
+			concealing: options
+		}],
+		systems: [count]
+	};
+}
+/** What the `visible` hook finds near a hidden one, kept between asks so that asking allocates nothing */
+var nearby = [];
+/** Where each that hides stood the tick before, and in which patch: what a rustle is told from. Not the world's state */
+var stood = /* @__PURE__ */ new WeakMap();
+/** One hidden that moved in a patch, or stepped into one: told to the teams the game says (`ConcealmentOptions.rustle`) */
+function tellRustles(world, layer, patches, hides, rustle, seconds) {
+	let was = stood.get(world);
+	if (!was) stood.set(world, was = /* @__PURE__ */ new Map());
+	const every = Math.max(1, Math.round(seconds / world.dt));
+	const { width, depth } = world.terrain;
+	const teams = typeof rustle === "function" ? [...new Set([...world.players.values()].filter((p) => !p.neutral).map((p) => p.team))] : void 0;
+	for (const entity of world.units.values()) {
+		if (!entity.alive || entity.hidden || !hides(world, entity)) continue;
+		const { x, z } = entity.pos;
+		const patch = x < 0 || z < 0 || x >= width || z >= depth ? 0 : patches.of[Math.floor(z) * width + Math.floor(x)];
+		const before = was.get(entity.id);
+		if (!before) {
+			was.set(entity.id, {
+				x,
+				z,
+				patch
+			});
+			continue;
+		}
+		const dx = before.x - x;
+		const dz = before.z - z;
+		const moved = dx * dx + dz * dz > 1e-4;
+		const entered = !!patch && patch !== before.patch;
+		before.x = x;
+		before.z = z;
+		before.patch = patch;
+		if (!patch || !moved || !entered && (world.tick + entity.id) % every !== 0) continue;
+		const told = teams && typeof rustle === "function" ? teams.filter((team) => rustle(world, entity, team)) : void 0;
+		if (told && !told.length) continue;
+		world.events.emit(rustled, {
+			layer,
+			entity,
+			x,
+			z,
+			entered,
+			...told && { teams: told }
+		});
+	}
+	if (was.size > world.entities.size * 2 + 64) {
+		for (const id of was.keys()) if (!world.entities.has(id)) was.delete(id);
+	}
+}
+/** The patches each team has someone in, worked out anew; each unit told to `each` on the way (`ConcealmentOptions.eachUnit`) */
+function countOccupied(world, patches, hides, each) {
+	patches.counted = true;
+	const { occupied, of } = patches;
+	for (const set of occupied.values()) set.clear();
+	const { width, depth } = world.terrain;
+	for (const entity of world.units.values()) {
+		if (!entity.alive || entity.hidden) continue;
+		const { x, z } = entity.pos;
+		if (x < 0 || z < 0 || x >= width || z >= depth) continue;
+		const cell = Math.floor(z) * width + Math.floor(x);
+		each?.unit(world, entity, cell);
+		if (!hides(world, entity)) continue;
+		const patch = of[cell];
+		if (!patch) continue;
+		const owner = world.player(entity.owner);
+		if (owner.neutral) continue;
+		let set = occupied.get(owner.team);
+		if (!set) occupied.set(owner.team, set = /* @__PURE__ */ new Set());
+		set.add(patch);
+	}
+}
+/** One hidden moving in a layer: where the player sees the ground, to whom the rules tell it, a shake of the bushes */
+var toldRustle = replicateEvent(rustled, "rustle", ({ layer, entity, x, z, entered, teams }, view) => {
+	if (view.observer || view.knows(entity) || !view.sees(x, z)) return void 0;
+	if (teams && !teams.includes(view.team)) return void 0;
+	return {
+		type: "rustle",
+		layer,
+		x: Math.round(x * 10) / 10,
+		z: Math.round(z * 10) / 10,
+		...entered && { entered }
+	};
+});
+//#endregion
+export { concealmentPack, markPatchesStale, patchAt, toldRustle };
+
+//# sourceMappingURL=concealment.js.map

package/dist/concealment.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"concealment.js","names":[],"sources":["../src/concealment.ts"],"sourcesContent":["import { cellsChanged, groundReshaped, rustled } from '#engine/engineEvents'\nimport type { Entity } from './entity'\nimport { exposure, detection } from './entity'\nimport type { GamePack } from './packs/pack'\nimport { defineHook, type HookDef } from './hooks'\nimport type { System } from './registry'\nimport type { World } from './world'\nimport { replicateEvent } from './replication'\nimport { floodCells } from './cellPatches'\n\n/**\n * Hiding places painted on a map, as a layer of cells (`CellLayerDef`): tall grass, a forest's edge. Who stands in one\n * is seen by another team only from inside the same patch of it (the cells of the layer that touch, sides or corners),\n * or from close by (`reach`). An attacker in one is seen by whom it hits for a moment, as anyone is (`expose`), and\n * what detects the invisible (`entity.detected`) sees it too. A game turns it on, on as many layers as it likes:\n *\n *     export const rules = { ...myGame, packs: [concealmentPack({ layer: 'bush' })] }\n *\n * Everything that asks what a team sees (`world.isVisibleTo`) goes by it: what units pick to attack, the commands a\n * player may give, the fog's memory, and each player's snapshots, so the computer player and the players over a wire\n * see what the rules let them. Nothing is saved: it is worked out from the layer and where everyone stands\n *\n * @beta\n */\nexport interface ConcealmentOptions {\n\t/** The layer of cells that hides (`Terrain.cells`): any cell of it with a value other than 0 */\n\tlayer: string\n\t/** How near, in cells, someone of another team has to be to see into it from outside: 2 when left out */\n\treach?: number\n\t/**\n\t * What it hides: units on the ground, of anyone, when left out (not structures, not what flies). A game's own, to hide\n\t * heroes only or let some types never hide\n\t */\n\thides?: (world: World, entity: Entity) => boolean\n\t/**\n\t * Whether a team sees a hidden entity anyway, after what the patch and `reach` make of it: a ward, a scout's ability.\n\t * Asked only of what would otherwise be hidden\n\t */\n\tseenBy?: (world: World, entity: Entity, team: number) => boolean\n\t/**\n\t * Whether one hidden in it gives itself away by moving, as the brush of a hero arena game shakes: the teams that do not see it are\n\t * told where it moves in it and steps into it (a `rustle` event, where they see the ground; not who), and their\n\t * screens shake the bushes there. `true` for every team, a function to say for each (`team`), no when left out:\n\t * a hidden unit shakes nothing on the screens of those who do not see it\n\t */\n\trustle?: boolean | ((world: World, entity: Entity, team: number) => boolean)\n\t/** How often one moving in it is told again, in seconds: 0.3 when left out. Stepping in is told at once */\n\trustleEvery?: number\n\t/** The id of its hook and its system, to replace or leave out: `concealment:<layer>` when left out */\n\tid?: string\n\t/**\n\t * Which cells of the layer hide, by their index: every cell that is not 0 when left out. The patches are of the\n\t * cells that do (those that touch), so grass that is cut or burnt neither hides nor joins two patches. What the\n\t * foliage pack hides by: a style that conceals, in a state that still does (`foliagePack`). Asked as the patches are\n\t * worked out, not for every unit\n\t */\n\tconceals?: (world: World, cell: number) => boolean\n\t/**\n\t * Other layers whose cells decide what hides (`conceals`), by id: the patches are worked out again when one of them\n\t * changes, as when the layer itself does. The foliage pack's state layer (`foliageStateLayer`)\n\t */\n\tfollows?: readonly string[]\n\t/**\n\t * Told of each unit on the map as the count goes through the units at the start of a tick (alive, not inside\n\t * anything), with the cell it stands in (`unit`), and once the count is done (`done`, whether it changed cells of the\n\t * layer or of one it follows: the count is made again of the patches as they are now). What the foliage pack\n\t * tramples by, in the same pass over the units as the count (`FoliageStyleDef.trample`). Never told from a `visible`\n\t * asked before the tick's count\n\t */\n\teachUnit?: { unit(world: World, entity: Entity, cell: number): void; done(world: World): boolean }\n}\n\n/** What a world's patches of a layer are, worked out once and again when the layer changes */\ninterface Patches {\n\t/** The cells of the layer this was worked out from: another array (the map resized, a save loaded) works it out again */\n\tcells: Uint8Array | undefined\n\t/** The patch of each cell, 1 and up; 0 for none */\n\tof: Int32Array\n\t/** Which cells hide, of a layer whose pack says (`ConcealmentOptions.conceals`): filled again as the patches are worked out */\n\thiding: Uint8Array | undefined\n\t/** Which cells of the layer hide, as the pack on it says: every cell not 0 where none says */\n\tconceals: ConcealmentOptions['conceals']\n\t/** The highest patch number given yet: a patch parted from another is given the next */\n\tnext: number\n\t/** Scratch of a parting (`part`): the cells a search went through, by the search's stamp, and which search each */\n\tsearched: Int32Array\n\tsearcher: Uint8Array\n\tstamp: number\n\tdirty: boolean\n\t/** Whether `occupied` was worked out yet: at the start of every tick, by the system, and never in the middle of one */\n\tcounted: boolean\n\t/** The patches each team has someone on the ground in, by team */\n\toccupied: Map<number, Set<number>>\n\tstop: () => void\n}\n\nconst known = new WeakMap<World, Map<string, Patches>>()\n\n/** The hook of a concealment pack, with how it hides: what its patches are worked out by, wherever they are asked for */\ninterface ConcealingHook extends HookDef {\n\treadonly concealing: ConcealmentOptions\n}\n\n/** How the game's pack on a layer hides in it (`conceals`, `follows`), read from its hook: none where no pack is on it */\nfunction concealingOf(world: World, layer: string): ConcealmentOptions | undefined {\n\tfor (const hook of world.registry.assembly?.hooks ?? []) {\n\t\tconst concealing = (hook as Partial<ConcealingHook>).concealing\n\t\tif (concealing?.layer === layer) return concealing\n\t}\n\treturn undefined\n}\n\n/** The patches of the layer of a world, worked out again when the layer, or one it follows, changed since */\nfunction patchesOf(world: World, layer: string): Patches {\n\tlet byLayer = known.get(world)\n\tif (!byLayer) known.set(world, (byLayer = new Map()))\n\tlet patches = byLayer.get(layer)\n\tif (!patches) {\n\t\tconst how = concealingOf(world, layer)\n\t\tconst follows = how?.follows ?? []\n\t\tconst made: Patches = {\n\t\t\tcells: undefined,\n\t\t\tof: new Int32Array(0),\n\t\t\thiding: undefined,\n\t\t\tconceals: how?.conceals,\n\t\t\tnext: 0,\n\t\t\tsearched: new Int32Array(0),\n\t\t\tsearcher: new Uint8Array(0),\n\t\t\tstamp: 0,\n\t\t\tdirty: true,\n\t\t\tcounted: false,\n\t\t\toccupied: new Map(),\n\t\t\tstop: () => {}\n\t\t}\n\t\t// the cells that changed followed one by one, where that is sure to come to what working them all out again\n\t\t// would; else only marked, worked out at the next ask, so a layer changed many times in a tick is worked out once\n\t\tconst stopCells = world.events.on(cellsChanged, (change) => {\n\t\t\tif (change.layer === layer || follows.includes(change.layer)) follow(world, made, layer, change.cells)\n\t\t})\n\t\t// the ground reshaped with its layers of cells as the patch has them (`World.reshapeGround`), which no change of\n\t\t// cells is said for: worked out again whole, as a world loaded from a save made after works them out\n\t\tconst stopGround = world.events.on(groundReshaped, ({ patch }) => {\n\t\t\tconst cells = patch.cells\n\t\t\tif (cells && (layer in cells || follows.some((id) => id in cells))) made.dirty = true\n\t\t})\n\t\tmade.stop = () => {\n\t\t\tstopCells()\n\t\t\tstopGround()\n\t\t}\n\t\tbyLayer.set(layer, (patches = made))\n\t}\n\tconst cells = world.terrain.cells[layer]\n\tif (patches.dirty || patches.cells !== cells) {\n\t\tlabel(world, patches, cells)\n\t\tpatches.cells = cells\n\t\tpatches.dirty = false\n\t}\n\treturn patches\n}\n\n/**\n * The patches of a layer of a world worked out again whole at the next ask: after what decides which cells hide\n * changed while no cell did (a style's `conceals` changed in play, `debug.cellStyles`), who has someone in which\n * counted again of them\n *\n * @internal\n */\nexport function markPatchesStale(world: World, layer: string): void {\n\tconst patches = known.get(world)?.get(layer)\n\tif (!patches) return\n\tpatches.dirty = true\n\t// who is in which patch counted again of the new patches, at the next ask\n\tpatches.counted = false\n}\n\n/**\n * The patches of a layer: each cell the number of the patch it is in, of the cells that hide and touch (corners too).\n * Into the patches' own arrays, where they are the size of the map\n */\nfunction label(world: World, patches: Patches, cells: Uint8Array | undefined): void {\n\tconst { width, depth } = world.terrain\n\t// a new one each time: as quick as clearing the last (zeroed as it is made), and nothing holds the last\n\tconst of = (patches.of = new Int32Array(width * depth))\n\tif (!cells) return\n\t// the cells that hide, each asked once: every cell not 0, or those of them the pack says\n\tlet hiding = cells\n\tconst { conceals } = patches\n\tif (conceals) {\n\t\tif (patches.hiding?.length !== cells.length) patches.hiding = new Uint8Array(cells.length)\n\t\thiding = patches.hiding!\n\t\tfor (let c = 0; c < cells.length; c++) hiding[c] = cells[c] && conceals(world, c) ? 1 : 0\n\t}\n\tlet next = 0\n\tconst stack: number[] = []\n\t// each patch the one flood fill a game's `patchCells` is too, numbered in the order its first cell comes\n\tfor (let start = 0; start < hiding.length; start++) if (hiding[start] && !of[start]) floodCells(width, depth, hiding, -1, start, of, ++next, stack)\n\tpatches.next = next\n}\n\n/** The eight cells about one, in order round it (a corner, a side, a corner…): what is asked of a cell that stops hiding */\nconst ROUND_X = [-1, 0, 1, 1, 1, 0, -1, -1] as const\nconst ROUND_Z = [-1, -1, -1, 0, 1, 1, 1, 0] as const\n\n/**\n * Cells of the layer, or of one it follows, changed: each that started or stopped hiding is followed into the\n * patches where that is sure (`leave`, `join`), so that a fire that changes cells every tick does not have the whole\n * map worked out again every tick. Where it is not, the patches are marked to be worked out again at the next ask\n */\nfunction follow(world: World, patches: Patches, layer: string, changed: readonly number[]): void {\n\tif (patches.dirty) return\n\tconst cells = world.terrain.cells[layer]\n\tif (!cells || patches.cells !== cells || patches.of.length !== cells.length) return void (patches.dirty = true)\n\tconst { of, conceals } = patches\n\tfor (let i = 0; i < changed.length; i++) {\n\t\tconst cell = changed[i]\n\t\tconst was = of[cell] !== 0\n\t\tconst now = cells[cell] !== 0 && (!conceals || conceals(world, cell))\n\t\tif (was === now) continue\n\t\tif (!(was ? leave(world, patches, cell) : join(world, patches, cell))) return void (patches.dirty = true)\n\t}\n}\n\n/**\n * A cell stops hiding: out of its patch. The patch stays one where the cells about it that hide touch each other\n * round it (one run of them round the cell, a corner between two sides counting as touching): any way through the\n * cell goes round it. Else the patch may have come apart there, and the parts are looked for (`part`)\n */\nfunction leave(world: World, patches: Patches, cell: number): boolean {\n\tconst { width, depth } = world.terrain\n\tconst { of } = patches\n\tof[cell] = 0\n\tconst x = cell % width\n\tconst z = (cell - x) / width\n\t// which of the eight hide, round the cell\n\tlet mask = 0\n\tfor (let i = 0; i < 8; i++) {\n\t\tconst nx = x + ROUND_X[i]\n\t\tconst nz = z + ROUND_Z[i]\n\t\tif (nx >= 0 && nz >= 0 && nx < width && nz < depth && of[nz * width + nx]) mask |= 1 << i\n\t}\n\t// a corner between two sides that hide is passed through (the sides touch across it)\n\tlet joined = mask\n\tfor (let i = 0; i < 8; i += 2) if (!(mask & (1 << i)) && mask & (1 << ((i + 7) & 7)) && mask & (1 << (i + 1))) joined |= 1 << i\n\t// the runs of them round the cell: where one starts after one that does not hide\n\tconst starts: number[] = []\n\tfor (let i = 0; i < 8; i++) if (joined & (1 << i) && !(joined & (1 << ((i + 7) & 7)))) starts.push(i)\n\tif (starts.length <= 1) return true\n\t// a cell of each run, of those that hide (a run starts at one, or at a corner joined between two that do)\n\tconst from = starts.map((i) => {\n\t\tconst at = mask & (1 << i) ? i : (i + 1) & 7\n\t\treturn (z + ROUND_Z[at]) * width + x + ROUND_X[at]\n\t})\n\tpart(world, patches, from)\n\treturn true\n}\n\n/**\n * A patch may have come apart: searches from a cell of each part, a step each in turn, through the cells of the\n * patch. Two that meet are one part; one that runs out has gone through a part of its own, given a patch number of\n * its own. It stops as soon as one search is left: what it goes through is about the smaller parts, not the patch\n */\nfunction part(world: World, patches: Patches, from: number[]): void {\n\tconst { width, depth } = world.terrain\n\tconst { of } = patches\n\tif (patches.searched.length !== of.length) {\n\t\tpatches.searched = new Int32Array(of.length)\n\t\tpatches.searcher = new Uint8Array(of.length)\n\t\tpatches.stamp = 0\n\t}\n\tconst stamp = ++patches.stamp\n\tconst { searched, searcher } = patches\n\tconst patch = of[from[0]]\n\tconst count = from.length\n\t// each search's cells to go on from, the cells it went through, and the search it is one with now\n\tconst queues = from.map((cell) => [cell])\n\tconst heads = from.map(() => 0)\n\tconst went = from.map((cell) => [cell])\n\tconst one = from.map((_, i) => i)\n\tconst done = from.map(() => false)\n\tconst find = (i: number) => {\n\t\twhile (one[i] !== i) i = one[i] = one[one[i]]\n\t\treturn i\n\t}\n\tfrom.forEach((cell, i) => {\n\t\tsearched[cell] = stamp\n\t\tsearcher[cell] = i\n\t})\n\tlet going = count\n\twhile (going > 1) {\n\t\tfor (let s = 0; s < count && going > 1; s++) {\n\t\t\tif (one[s] !== s || done[s]) continue\n\t\t\tif (heads[s] >= queues[s].length) {\n\t\t\t\tdone[s] = true\n\t\t\t\tgoing--\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\tconst cell = queues[s][heads[s]++]\n\t\t\tconst x = cell % width\n\t\t\tconst z = (cell - x) / width\n\t\t\tfor (let i = 0; i < 8; i++) {\n\t\t\t\tconst nx = x + ROUND_X[i]\n\t\t\t\tconst nz = z + ROUND_Z[i]\n\t\t\t\tif (nx < 0 || nz < 0 || nx >= width || nz >= depth) continue\n\t\t\t\tconst n = nz * width + nx\n\t\t\t\tif (of[n] !== patch) continue\n\t\t\t\tif (searched[n] === stamp) {\n\t\t\t\t\t// met another search: one part, gone on as one\n\t\t\t\t\tconst other = find(searcher[n])\n\t\t\t\t\tif (other === s) continue\n\t\t\t\t\tone[other] = s\n\t\t\t\t\tfor (let k = heads[other]; k < queues[other].length; k++) queues[s].push(queues[other][k])\n\t\t\t\t\tfor (const each of went[other]) went[s].push(each)\n\t\t\t\t\tgoing--\n\t\t\t\t\tcontinue\n\t\t\t\t}\n\t\t\t\tsearched[n] = stamp\n\t\t\t\tsearcher[n] = s\n\t\t\t\tqueues[s].push(n)\n\t\t\t\twent[s].push(n)\n\t\t\t}\n\t\t}\n\t}\n\t// the parts that ran out, but one where none is left going: patches of their own\n\tlet kept = from.findIndex((_, s) => one[s] === s && !done[s])\n\tfor (let s = 0; s < count; s++) {\n\t\tif (one[s] !== s || s === kept) continue\n\t\tif (kept < 0) {\n\t\t\tkept = s\n\t\t\tcontinue\n\t\t}\n\t\tconst number = ++patches.next\n\t\tfor (const cell of went[s]) of[cell] = number\n\t}\n}\n\n/**\n * A cell starts hiding: into the patch about it, or a patch of its own where none is about. Where it joins two\n * patches into one it is not followed (false): the patches are worked out again\n */\nfunction join(world: World, patches: Patches, cell: number): boolean {\n\tconst { width, depth } = world.terrain\n\tconst { of } = patches\n\tconst x = cell % width\n\tconst z = (cell - x) / width\n\tlet found = 0\n\tfor (let i = 0; i < 8; i++) {\n\t\tconst nx = x + ROUND_X[i]\n\t\tconst nz = z + ROUND_Z[i]\n\t\tif (nx < 0 || nz < 0 || nx >= width || nz >= depth) continue\n\t\tconst patch = of[nz * width + nx]\n\t\tif (!patch || patch === found) continue\n\t\tif (found) return false\n\t\tfound = patch\n\t}\n\tof[cell] = found || ++patches.next\n\treturn true\n}\n\n/** Units on the ground, not structures: what hides when a game does not say */\nconst onTheGround = (_world: World, entity: Entity) => !entity.def.footprint && !entity.flying && entity.def.kind === 'unit'\n\n/**\n * The patch of a layer an entity stands in, 1 and up, or 0 where it stands in none (`ConcealmentOptions`). For a\n * game's rules and screen: who is in the grass\n *\n * @beta\n */\nexport function patchAt(world: World, layer: string, x: number, z: number): number {\n\tconst { terrain } = world\n\tif (x < 0 || z < 0 || x >= terrain.width || z >= terrain.depth) return 0\n\treturn patchesOf(world, layer).of[Math.floor(z) * terrain.width + Math.floor(x)]\n}\n\n/**\n * A game where what stands in a layer of cells is hidden from the teams that are not in it with them (see\n * `ConcealmentOptions`): a `visible` hook, and a system that works out who has someone in which patch at the start of\n * every tick (the same in every copy of the game, whoever asks what in between). On as many layers as it is given\n *\n * @beta\n */\nexport function concealmentPack(options: ConcealmentOptions): GamePack {\n\tconst { layer, hides = onTheGround, seenBy } = options\n\tconst reach = options.reach ?? 2\n\tconst id = options.id ?? `concealment:${layer}`\n\tconst { rustle } = options\n\tconst count: System = {\n\t\tname: id,\n\t\tphase: 'commands',\n\t\tupdate(world) {\n\t\t\tif (!world.terrain.cells[layer]) return\n\t\t\tconst patches = patchesOf(world, layer)\n\t\t\tconst { eachUnit } = options\n\t\t\tcountOccupied(world, patches, hides, eachUnit)\n\t\t\t// what the pass changed (grass trampled flat) counted again, of the patches as it left them\n\t\t\tif (eachUnit?.done(world)) countOccupied(world, patchesOf(world, layer), hides)\n\t\t\tif (rustle) tellRustles(world, layer, patches, hides, rustle, options.rustleEvery ?? 0.3)\n\t\t}\n\t}\n\tconst visible = defineHook({\n\t\thook: 'visible',\n\t\tid,\n\t\trun(world, event) {\n\t\t\tif (!event.visible) return\n\t\t\tconst { entity, team } = event\n\t\t\tif (!world.terrain.cells[layer]) return\n\t\t\tconst patches = patchesOf(world, layer)\n\t\t\tconst { width, depth } = world.terrain\n\t\t\tconst { x, z } = entity.pos\n\t\t\tif (x < 0 || z < 0 || x >= width || z >= depth) return\n\t\t\tconst patch = patches.of[Math.floor(z) * width + Math.floor(x)]\n\t\t\tif (!patch || !hides(world, entity)) return\n\t\t\t// seen for a moment by whom it hit, and by what sees the invisible\n\t\t\tif (entity.get(exposure)?.has(team) || entity.get(detection)?.has(team)) return\n\t\t\t// worked out at the start of the tick; once, where nothing ticked yet (a world just made or loaded: as it would be)\n\t\t\tif (!patches.counted) countOccupied(world, patches, hides)\n\t\t\tif (patches.occupied.get(team)?.has(patch)) return\n\t\t\t// someone of the team close by. Into a list of its own (asked for every entity, team and target search, and\n\t\t\t// nothing in the loop asks again): not the caller's, which may be going through a query of its own\n\t\t\tfor (const near of world.spatial.query(x, z, reach, nearby)) {\n\t\t\t\tif (near === entity || !near.alive || near.hidden) continue\n\t\t\t\tif (world.player(near.owner).team !== team || world.player(near.owner).neutral) continue\n\t\t\t\tconst dx = near.pos.x - x\n\t\t\t\tconst dz = near.pos.z - z\n\t\t\t\tif (dx * dx + dz * dz <= reach * reach) return\n\t\t\t}\n\t\t\tif (seenBy?.(world, entity, team)) return\n\t\t\tevent.visible = false\n\t\t}\n\t})\n\t// how it hides, for its patches wherever they are asked for: this hook, its system, `patchAt`\n\tconst hook: ConcealingHook = { ...visible, concealing: options }\n\treturn { id: 'concealment', options, hooks: [hook], systems: [count] }\n}\n\n/** What the `visible` hook finds near a hidden one, kept between asks so that asking allocates nothing */\nconst nearby: Entity[] = []\n\n/** Where each that hides stood the tick before, and in which patch: what a rustle is told from. Not the world's state */\nconst stood = new WeakMap<World, Map<number, { x: number; z: number; patch: number }>>()\n\n/** One hidden that moved in a patch, or stepped into one: told to the teams the game says (`ConcealmentOptions.rustle`) */\nfunction tellRustles(\n\tworld: World,\n\tlayer: string,\n\tpatches: Patches,\n\thides: NonNullable<ConcealmentOptions['hides']>,\n\trustle: NonNullable<ConcealmentOptions['rustle']>,\n\tseconds: number\n): void {\n\tlet was = stood.get(world)\n\tif (!was) stood.set(world, (was = new Map()))\n\tconst every = Math.max(1, Math.round(seconds / world.dt))\n\tconst { width, depth } = world.terrain\n\tconst teams = typeof rustle === 'function' ? [...new Set([...world.players.values()].filter((p) => !p.neutral).map((p) => p.team))] : undefined\n\t// the actors only: scenery stands still and is neutral, which neither rustles nor has a team in a patch\n\tfor (const entity of world.units.values()) {\n\t\tif (!entity.alive || entity.hidden || !hides(world, entity)) continue\n\t\tconst { x, z } = entity.pos\n\t\tconst patch = x < 0 || z < 0 || x >= width || z >= depth ? 0 : patches.of[Math.floor(z) * width + Math.floor(x)]\n\t\tconst before = was.get(entity.id)\n\t\tif (!before) {\n\t\t\twas.set(entity.id, { x, z, patch })\n\t\t\tcontinue\n\t\t}\n\t\tconst dx = before.x - x\n\t\tconst dz = before.z - z\n\t\tconst moved = dx * dx + dz * dz > 1e-4\n\t\tconst entered = !!patch && patch !== before.patch\n\t\tbefore.x = x\n\t\tbefore.z = z\n\t\tbefore.patch = patch\n\t\tif (!patch || !moved || (!entered && (world.tick + entity.id) % every !== 0)) continue\n\t\tconst told = teams && typeof rustle === 'function' ? teams.filter((team) => rustle(world, entity, team)) : undefined\n\t\tif (told && !told.length) continue\n\t\tworld.events.emit(rustled, { layer, entity, x, z, entered, ...(told && { teams: told }) })\n\t}\n\tif (was.size > world.entities.size * 2 + 64) for (const id of was.keys()) if (!world.entities.has(id)) was.delete(id)\n}\n\n/** The patches each team has someone in, worked out anew; each unit told to `each` on the way (`ConcealmentOptions.eachUnit`) */\nfunction countOccupied(\n\tworld: World,\n\tpatches: Patches,\n\thides: NonNullable<ConcealmentOptions['hides']>,\n\teach?: ConcealmentOptions['eachUnit']\n): void {\n\tpatches.counted = true\n\tconst { occupied, of } = patches\n\tfor (const set of occupied.values()) set.clear()\n\tconst { width, depth } = world.terrain\n\t// the actors only: scenery stands still and is neutral, which neither rustles nor has a team in a patch\n\tfor (const entity of world.units.values()) {\n\t\tif (!entity.alive || entity.hidden) continue\n\t\tconst { x, z } = entity.pos\n\t\tif (x < 0 || z < 0 || x >= width || z >= depth) continue\n\t\tconst cell = Math.floor(z) * width + Math.floor(x)\n\t\teach?.unit(world, entity, cell)\n\t\tif (!hides(world, entity)) continue\n\t\tconst patch = of[cell]\n\t\tif (!patch) continue\n\t\tconst owner = world.player(entity.owner)\n\t\tif (owner.neutral) continue\n\t\tlet set = occupied.get(owner.team)\n\t\tif (!set) occupied.set(owner.team, (set = new Set()))\n\t\tset.add(patch)\n\t}\n}\n\n/** One hidden moving in a layer: where the player sees the ground, to whom the rules tell it, a shake of the bushes */\nexport const toldRustle = replicateEvent(rustled, 'rustle', ({ layer, entity, x, z, entered, teams }, view) => {\n\tif (view.observer || view.knows(entity) || !view.sees(x, z)) return undefined\n\tif (teams && !teams.includes(view.team)) return undefined\n\treturn { type: 'rustle', layer, x: Math.round(x * 10) / 10, z: Math.round(z * 10) / 10, ...(entered && { entered }) }\n})\n"],"mappings":";;;;;;AAgGA,IAAM,wBAAQ,IAAI,QAAqC;;AAQvD,SAAS,aAAa,OAAc,OAA+C;CAClF,KAAK,MAAM,QAAQ,MAAM,SAAS,UAAU,SAAS,CAAC,GAAG;EACxD,MAAM,aAAc,KAAiC;EACrD,IAAI,YAAY,UAAU,OAAO,OAAO;CACzC;AAED;;AAGA,SAAS,UAAU,OAAc,OAAwB;CACxD,IAAI,UAAU,MAAM,IAAI,KAAK;CAC7B,IAAI,CAAC,SAAS,MAAM,IAAI,OAAQ,0BAAU,IAAI,IAAI,CAAE;CACpD,IAAI,UAAU,QAAQ,IAAI,KAAK;CAC/B,IAAI,CAAC,SAAS;EACb,MAAM,MAAM,aAAa,OAAO,KAAK;EACrC,MAAM,UAAU,KAAK,WAAW,CAAC;EACjC,MAAM,OAAgB;GACrB,OAAO,KAAA;GACP,oBAAI,IAAI,WAAW,CAAC;GACpB,QAAQ,KAAA;GACR,UAAU,KAAK;GACf,MAAM;GACN,0BAAU,IAAI,WAAW,CAAC;GAC1B,0BAAU,IAAI,WAAW,CAAC;GAC1B,OAAO;GACP,OAAO;GACP,SAAS;GACT,0BAAU,IAAI,IAAI;GAClB,YAAY,CAAC;EACd;EAGA,MAAM,YAAY,MAAM,OAAO,GAAG,eAAe,WAAW;GAC3D,IAAI,OAAO,UAAU,SAAS,QAAQ,SAAS,OAAO,KAAK,GAAG,OAAO,OAAO,MAAM,OAAO,OAAO,KAAK;EACtG,CAAC;EAGD,MAAM,aAAa,MAAM,OAAO,GAAG,iBAAiB,EAAE,YAAY;GACjE,MAAM,QAAQ,MAAM;GACpB,IAAI,UAAU,SAAS,SAAS,QAAQ,MAAM,OAAO,MAAM,KAAK,IAAI,KAAK,QAAQ;EAClF,CAAC;EACD,KAAK,aAAa;GACjB,UAAU;GACV,WAAW;EACZ;EACA,QAAQ,IAAI,OAAQ,UAAU,IAAK;CACpC;CACA,MAAM,QAAQ,MAAM,QAAQ,MAAM;CAClC,IAAI,QAAQ,SAAS,QAAQ,UAAU,OAAO;EAC7C,MAAM,OAAO,SAAS,KAAK;EAC3B,QAAQ,QAAQ;EAChB,QAAQ,QAAQ;CACjB;CACA,OAAO;AACR;;;;;;;;AASA,SAAgB,iBAAiB,OAAc,OAAqB;CACnE,MAAM,UAAU,MAAM,IAAI,KAAK,CAAC,EAAE,IAAI,KAAK;CAC3C,IAAI,CAAC,SAAS;CACd,QAAQ,QAAQ;CAEhB,QAAQ,UAAU;AACnB;;;;;AAMA,SAAS,MAAM,OAAc,SAAkB,OAAqC;CACnF,MAAM,EAAE,OAAO,UAAU,MAAM;CAE/B,MAAM,KAAM,QAAQ,KAAK,IAAI,WAAW,QAAQ,KAAK;CACrD,IAAI,CAAC,OAAO;CAEZ,IAAI,SAAS;CACb,MAAM,EAAE,aAAa;CACrB,IAAI,UAAU;EACb,IAAI,QAAQ,QAAQ,WAAW,MAAM,QAAQ,QAAQ,SAAS,IAAI,WAAW,MAAM,MAAM;EACzF,SAAS,QAAQ;EACjB,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK,OAAO,KAAK,MAAM,MAAM,SAAS,OAAO,CAAC,IAAI,IAAI;CACzF;CACA,IAAI,OAAO;CACX,MAAM,QAAkB,CAAC;CAEzB,KAAK,IAAI,QAAQ,GAAG,QAAQ,OAAO,QAAQ,SAAS,IAAI,OAAO,UAAU,CAAC,GAAG,QAAQ,WAAW,OAAO,OAAO,QAAQ,IAAI,OAAO,IAAI,EAAE,MAAM,KAAK;CAClJ,QAAQ,OAAO;AAChB;;AAGA,IAAM,UAAU;CAAC;CAAI;CAAG;CAAG;CAAG;CAAG;CAAG;CAAI;AAAE;AAC1C,IAAM,UAAU;CAAC;CAAI;CAAI;CAAI;CAAG;CAAG;CAAG;CAAG;AAAC;;;;;;AAO1C,SAAS,OAAO,OAAc,SAAkB,OAAe,SAAkC;CAChG,IAAI,QAAQ,OAAO;CACnB,MAAM,QAAQ,MAAM,QAAQ,MAAM;CAClC,IAAI,CAAC,SAAS,QAAQ,UAAU,SAAS,QAAQ,GAAG,WAAW,MAAM,QAAQ,OAAO,MAAM,QAAQ,QAAQ;CAC1G,MAAM,EAAE,IAAI,aAAa;CACzB,KAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK;EACxC,MAAM,OAAO,QAAQ;EACrB,MAAM,MAAM,GAAG,UAAU;EAEzB,IAAI,SADQ,MAAM,UAAU,MAAM,CAAC,YAAY,SAAS,OAAO,IAAI,KAClD;EACjB,IAAI,EAAE,MAAM,MAAM,OAAO,SAAS,IAAI,IAAI,KAAK,OAAO,SAAS,IAAI,IAAI,OAAO,MAAM,QAAQ,QAAQ;CACrG;AACD;;;;;;AAOA,SAAS,MAAM,OAAc,SAAkB,MAAuB;CACrE,MAAM,EAAE,OAAO,UAAU,MAAM;CAC/B,MAAM,EAAE,OAAO;CACf,GAAG,QAAQ;CACX,MAAM,IAAI,OAAO;CACjB,MAAM,KAAK,OAAO,KAAK;CAEvB,IAAI,OAAO;CACX,KAAK,IAAI,IAAI,GAAG,IAAI,GAAG,KAAK;EAC3B,MAAM,KAAK,IAAI,QAAQ;EACvB,MAAM,KAAK,IAAI,QAAQ;EACvB,IAAI,MAAM,KAAK,MAAM,KAAK,KAAK,SAAS,KAAK,SAAS,GAAG,KAAK,QAAQ,KAAK,QAAQ,KAAK;CACzF;CAEA,IAAI,SAAS;CACb,KAAK,IAAI,IAAI,GAAG,IAAI,GAAG,KAAK,GAAG,IAAI,EAAE,OAAQ,KAAK,MAAO,OAAQ,MAAO,IAAI,IAAK,MAAO,OAAQ,KAAM,IAAI,GAAK,UAAU,KAAK;CAE9H,MAAM,SAAmB,CAAC;CAC1B,KAAK,IAAI,IAAI,GAAG,IAAI,GAAG,KAAK,IAAI,SAAU,KAAK,KAAM,EAAE,SAAU,MAAO,IAAI,IAAK,KAAM,OAAO,KAAK,CAAC;CACpG,IAAI,OAAO,UAAU,GAAG,OAAO;CAM/B,KAAK,OAAO,SAJC,OAAO,KAAK,MAAM;EAC9B,MAAM,KAAK,OAAQ,KAAK,IAAK,IAAK,IAAI,IAAK;EAC3C,QAAQ,IAAI,QAAQ,OAAO,QAAQ,IAAI,QAAQ;CAChD,CACqB,CAAI;CACzB,OAAO;AACR;;;;;;AAOA,SAAS,KAAK,OAAc,SAAkB,MAAsB;CACnE,MAAM,EAAE,OAAO,UAAU,MAAM;CAC/B,MAAM,EAAE,OAAO;CACf,IAAI,QAAQ,SAAS,WAAW,GAAG,QAAQ;EAC1C,QAAQ,WAAW,IAAI,WAAW,GAAG,MAAM;EAC3C,QAAQ,WAAW,IAAI,WAAW,GAAG,MAAM;EAC3C,QAAQ,QAAQ;CACjB;CACA,MAAM,QAAQ,EAAE,QAAQ;CACxB,MAAM,EAAE,UAAU,aAAa;CAC/B,MAAM,QAAQ,GAAG,KAAK;CACtB,MAAM,QAAQ,KAAK;CAEnB,MAAM,SAAS,KAAK,KAAK,SAAS,CAAC,IAAI,CAAC;CACxC,MAAM,QAAQ,KAAK,UAAU,CAAC;CAC9B,MAAM,OAAO,KAAK,KAAK,SAAS,CAAC,IAAI,CAAC;CACtC,MAAM,MAAM,KAAK,KAAK,GAAG,MAAM,CAAC;CAChC,MAAM,OAAO,KAAK,UAAU,KAAK;CACjC,MAAM,QAAQ,MAAc;EAC3B,OAAO,IAAI,OAAO,GAAG,IAAI,IAAI,KAAK,IAAI,IAAI;EAC1C,OAAO;CACR;CACA,KAAK,SAAS,MAAM,MAAM;EACzB,SAAS,QAAQ;EACjB,SAAS,QAAQ;CAClB,CAAC;CACD,IAAI,QAAQ;CACZ,OAAO,QAAQ,GACd,KAAK,IAAI,IAAI,GAAG,IAAI,SAAS,QAAQ,GAAG,KAAK;EAC5C,IAAI,IAAI,OAAO,KAAK,KAAK,IAAI;EAC7B,IAAI,MAAM,MAAM,OAAO,EAAE,CAAC,QAAQ;GACjC,KAAK,KAAK;GACV;GACA;EACD;EACA,MAAM,OAAO,OAAO,EAAE,CAAC,MAAM,EAAE;EAC/B,MAAM,IAAI,OAAO;EACjB,MAAM,KAAK,OAAO,KAAK;EACvB,KAAK,IAAI,IAAI,GAAG,IAAI,GAAG,KAAK;GAC3B,MAAM,KAAK,IAAI,QAAQ;GACvB,MAAM,KAAK,IAAI,QAAQ;GACvB,IAAI,KAAK,KAAK,KAAK,KAAK,MAAM,SAAS,MAAM,OAAO;GACpD,MAAM,IAAI,KAAK,QAAQ;GACvB,IAAI,GAAG,OAAO,OAAO;GACrB,IAAI,SAAS,OAAO,OAAO;IAE1B,MAAM,QAAQ,KAAK,SAAS,EAAE;IAC9B,IAAI,UAAU,GAAG;IACjB,IAAI,SAAS;IACb,KAAK,IAAI,IAAI,MAAM,QAAQ,IAAI,OAAO,MAAM,CAAC,QAAQ,KAAK,OAAO,EAAE,CAAC,KAAK,OAAO,MAAM,CAAC,EAAE;IACzF,KAAK,MAAM,QAAQ,KAAK,QAAQ,KAAK,EAAE,CAAC,KAAK,IAAI;IACjD;IACA;GACD;GACA,SAAS,KAAK;GACd,SAAS,KAAK;GACd,OAAO,EAAE,CAAC,KAAK,CAAC;GAChB,KAAK,EAAE,CAAC,KAAK,CAAC;EACf;CACD;CAGD,IAAI,OAAO,KAAK,WAAW,GAAG,MAAM,IAAI,OAAO,KAAK,CAAC,KAAK,EAAE;CAC5D,KAAK,IAAI,IAAI,GAAG,IAAI,OAAO,KAAK;EAC/B,IAAI,IAAI,OAAO,KAAK,MAAM,MAAM;EAChC,IAAI,OAAO,GAAG;GACb,OAAO;GACP;EACD;EACA,MAAM,SAAS,EAAE,QAAQ;EACzB,KAAK,MAAM,QAAQ,KAAK,IAAI,GAAG,QAAQ;CACxC;AACD;;;;;AAMA,SAAS,KAAK,OAAc,SAAkB,MAAuB;CACpE,MAAM,EAAE,OAAO,UAAU,MAAM;CAC/B,MAAM,EAAE,OAAO;CACf,MAAM,IAAI,OAAO;CACjB,MAAM,KAAK,OAAO,KAAK;CACvB,IAAI,QAAQ;CACZ,KAAK,IAAI,IAAI,GAAG,IAAI,GAAG,KAAK;EAC3B,MAAM,KAAK,IAAI,QAAQ;EACvB,MAAM,KAAK,IAAI,QAAQ;EACvB,IAAI,KAAK,KAAK,KAAK,KAAK,MAAM,SAAS,MAAM,OAAO;EACpD,MAAM,QAAQ,GAAG,KAAK,QAAQ;EAC9B,IAAI,CAAC,SAAS,UAAU,OAAO;EAC/B,IAAI,OAAO,OAAO;EAClB,QAAQ;CACT;CACA,GAAG,QAAQ,SAAS,EAAE,QAAQ;CAC9B,OAAO;AACR;;AAGA,IAAM,eAAe,QAAe,WAAmB,CAAC,OAAO,IAAI,aAAa,CAAC,OAAO,UAAU,OAAO,IAAI,SAAS;;;;;;;AAQtH,SAAgB,QAAQ,OAAc,OAAe,GAAW,GAAmB;CAClF,MAAM,EAAE,YAAY;CACpB,IAAI,IAAI,KAAK,IAAI,KAAK,KAAK,QAAQ,SAAS,KAAK,QAAQ,OAAO,OAAO;CACvE,OAAO,UAAU,OAAO,KAAK,CAAC,CAAC,GAAG,KAAK,MAAM,CAAC,IAAI,QAAQ,QAAQ,KAAK,MAAM,CAAC;AAC/E;;;;;;;;AASA,SAAgB,gBAAgB,SAAuC;CACtE,MAAM,EAAE,OAAO,QAAQ,aAAa,WAAW;CAC/C,MAAM,QAAQ,QAAQ,SAAS;CAC/B,MAAM,KAAK,QAAQ,MAAM,eAAe;CACxC,MAAM,EAAE,WAAW;CACnB,MAAM,QAAgB;EACrB,MAAM;EACN,OAAO;EACP,OAAO,OAAO;GACb,IAAI,CAAC,MAAM,QAAQ,MAAM,QAAQ;GACjC,MAAM,UAAU,UAAU,OAAO,KAAK;GACtC,MAAM,EAAE,aAAa;GACrB,cAAc,OAAO,SAAS,OAAO,QAAQ;GAE7C,IAAI,UAAU,KAAK,KAAK,GAAG,cAAc,OAAO,UAAU,OAAO,KAAK,GAAG,KAAK;GAC9E,IAAI,QAAQ,YAAY,OAAO,OAAO,SAAS,OAAO,QAAQ,QAAQ,eAAe,EAAG;EACzF;CACD;CAkCA,OAAO;EAAE,IAAI;EAAe;EAAS,OAAO,CAAC;GADd,GAhCf,WAAW;IAC1B,MAAM;IACN;IACA,IAAI,OAAO,OAAO;KACjB,IAAI,CAAC,MAAM,SAAS;KACpB,MAAM,EAAE,QAAQ,SAAS;KACzB,IAAI,CAAC,MAAM,QAAQ,MAAM,QAAQ;KACjC,MAAM,UAAU,UAAU,OAAO,KAAK;KACtC,MAAM,EAAE,OAAO,UAAU,MAAM;KAC/B,MAAM,EAAE,GAAG,MAAM,OAAO;KACxB,IAAI,IAAI,KAAK,IAAI,KAAK,KAAK,SAAS,KAAK,OAAO;KAChD,MAAM,QAAQ,QAAQ,GAAG,KAAK,MAAM,CAAC,IAAI,QAAQ,KAAK,MAAM,CAAC;KAC7D,IAAI,CAAC,SAAS,CAAC,MAAM,OAAO,MAAM,GAAG;KAErC,IAAI,OAAO,IAAI,QAAQ,CAAC,EAAE,IAAI,IAAI,KAAK,OAAO,IAAI,SAAS,CAAC,EAAE,IAAI,IAAI,GAAG;KAEzE,IAAI,CAAC,QAAQ,SAAS,cAAc,OAAO,SAAS,KAAK;KACzD,IAAI,QAAQ,SAAS,IAAI,IAAI,CAAC,EAAE,IAAI,KAAK,GAAG;KAG5C,KAAK,MAAM,QAAQ,MAAM,QAAQ,MAAM,GAAG,GAAG,OAAO,MAAM,GAAG;MAC5D,IAAI,SAAS,UAAU,CAAC,KAAK,SAAS,KAAK,QAAQ;MACnD,IAAI,MAAM,OAAO,KAAK,KAAK,CAAC,CAAC,SAAS,QAAQ,MAAM,OAAO,KAAK,KAAK,CAAC,CAAC,SAAS;MAChF,MAAM,KAAK,KAAK,IAAI,IAAI;MACxB,MAAM,KAAK,KAAK,IAAI,IAAI;MACxB,IAAI,KAAK,KAAK,KAAK,MAAM,QAAQ,OAAO;KACzC;KACA,IAAI,SAAS,OAAO,QAAQ,IAAI,GAAG;KACnC,MAAM,UAAU;IACjB;GACD,CAEkC;GAAS,YAAY;EACV,CAAI;EAAG,SAAS,CAAC,KAAK;CAAE;AACtE;;AAGA,IAAM,SAAmB,CAAC;;AAG1B,IAAM,wBAAQ,IAAI,QAAqE;;AAGvF,SAAS,YACR,OACA,OACA,SACA,OACA,QACA,SACO;CACP,IAAI,MAAM,MAAM,IAAI,KAAK;CACzB,IAAI,CAAC,KAAK,MAAM,IAAI,OAAQ,sBAAM,IAAI,IAAI,CAAE;CAC5C,MAAM,QAAQ,KAAK,IAAI,GAAG,KAAK,MAAM,UAAU,MAAM,EAAE,CAAC;CACxD,MAAM,EAAE,OAAO,UAAU,MAAM;CAC/B,MAAM,QAAQ,OAAO,WAAW,aAAa,CAAC,GAAG,IAAI,IAAI,CAAC,GAAG,MAAM,QAAQ,OAAO,CAAC,CAAC,CAAC,QAAQ,MAAM,CAAC,EAAE,OAAO,CAAC,CAAC,KAAK,MAAM,EAAE,IAAI,CAAC,CAAC,IAAI,KAAA;CAEtI,KAAK,MAAM,UAAU,MAAM,MAAM,OAAO,GAAG;EAC1C,IAAI,CAAC,OAAO,SAAS,OAAO,UAAU,CAAC,MAAM,OAAO,MAAM,GAAG;EAC7D,MAAM,EAAE,GAAG,MAAM,OAAO;EACxB,MAAM,QAAQ,IAAI,KAAK,IAAI,KAAK,KAAK,SAAS,KAAK,QAAQ,IAAI,QAAQ,GAAG,KAAK,MAAM,CAAC,IAAI,QAAQ,KAAK,MAAM,CAAC;EAC9G,MAAM,SAAS,IAAI,IAAI,OAAO,EAAE;EAChC,IAAI,CAAC,QAAQ;GACZ,IAAI,IAAI,OAAO,IAAI;IAAE;IAAG;IAAG;GAAM,CAAC;GAClC;EACD;EACA,MAAM,KAAK,OAAO,IAAI;EACtB,MAAM,KAAK,OAAO,IAAI;EACtB,MAAM,QAAQ,KAAK,KAAK,KAAK,KAAK;EAClC,MAAM,UAAU,CAAC,CAAC,SAAS,UAAU,OAAO;EAC5C,OAAO,IAAI;EACX,OAAO,IAAI;EACX,OAAO,QAAQ;EACf,IAAI,CAAC,SAAS,CAAC,SAAU,CAAC,YAAY,MAAM,OAAO,OAAO,MAAM,UAAU,GAAI;EAC9E,MAAM,OAAO,SAAS,OAAO,WAAW,aAAa,MAAM,QAAQ,SAAS,OAAO,OAAO,QAAQ,IAAI,CAAC,IAAI,KAAA;EAC3G,IAAI,QAAQ,CAAC,KAAK,QAAQ;EAC1B,MAAM,OAAO,KAAK,SAAS;GAAE;GAAO;GAAQ;GAAG;GAAG;GAAS,GAAI,QAAQ,EAAE,OAAO,KAAK;EAAG,CAAC;CAC1F;CACA,IAAI,IAAI,OAAO,MAAM,SAAS,OAAO,IAAI,IAAS;OAAA,MAAM,MAAM,IAAI,KAAK,GAAG,IAAI,CAAC,MAAM,SAAS,IAAI,EAAE,GAAG,IAAI,OAAO,EAAE;CAAA;AACrH;;AAGA,SAAS,cACR,OACA,SACA,OACA,MACO;CACP,QAAQ,UAAU;CAClB,MAAM,EAAE,UAAU,OAAO;CACzB,KAAK,MAAM,OAAO,SAAS,OAAO,GAAG,IAAI,MAAM;CAC/C,MAAM,EAAE,OAAO,UAAU,MAAM;CAE/B,KAAK,MAAM,UAAU,MAAM,MAAM,OAAO,GAAG;EAC1C,IAAI,CAAC,OAAO,SAAS,OAAO,QAAQ;EACpC,MAAM,EAAE,GAAG,MAAM,OAAO;EACxB,IAAI,IAAI,KAAK,IAAI,KAAK,KAAK,SAAS,KAAK,OAAO;EAChD,MAAM,OAAO,KAAK,MAAM,CAAC,IAAI,QAAQ,KAAK,MAAM,CAAC;EACjD,MAAM,KAAK,OAAO,QAAQ,IAAI;EAC9B,IAAI,CAAC,MAAM,OAAO,MAAM,GAAG;EAC3B,MAAM,QAAQ,GAAG;EACjB,IAAI,CAAC,OAAO;EACZ,MAAM,QAAQ,MAAM,OAAO,OAAO,KAAK;EACvC,IAAI,MAAM,SAAS;EACnB,IAAI,MAAM,SAAS,IAAI,MAAM,IAAI;EACjC,IAAI,CAAC,KAAK,SAAS,IAAI,MAAM,MAAO,sBAAM,IAAI,IAAI,CAAE;EACpD,IAAI,IAAI,KAAK;CACd;AACD;;AAGA,IAAa,aAAa,eAAe,SAAS,WAAW,EAAE,OAAO,QAAQ,GAAG,GAAG,SAAS,SAAS,SAAS;CAC9G,IAAI,KAAK,YAAY,KAAK,MAAM,MAAM,KAAK,CAAC,KAAK,KAAK,GAAG,CAAC,GAAG,OAAO,KAAA;CACpE,IAAI,SAAS,CAAC,MAAM,SAAS,KAAK,IAAI,GAAG,OAAO,KAAA;CAChD,OAAO;EAAE,MAAM;EAAU;EAAO,GAAG,KAAK,MAAM,IAAI,EAAE,IAAI;EAAI,GAAG,KAAK,MAAM,IAAI,EAAE,IAAI;EAAI,GAAI,WAAW,EAAE,QAAQ;CAAG;AACrH,CAAC"}

package/dist/coreComponents.js

@@ -0,0 +1,130 @@
+import { inventorySlots } from "./inventory.js";
+import { teamMemory } from "./session/memory.js";
+import { constructionSite } from "./systems/construction.js";
+import { deposit, detection, exposure, fighting, moving } from "./entity.js";
+import { productionQueue } from "./systems/productionQueue.js";
+import { form } from "./formState.js";
+import { heroState, respawning } from "./hero.js";
+import { summoned } from "./summoned.js";
+import { dashing } from "./dashing.js";
+import { added, inside } from "./areas.js";
+import { mapInfo, names } from "./names.js";
+import { triggerState } from "./abilities/triggers.js";
+import { shownTimers, waiting } from "./timers.js";
+import { running } from "./sequences.js";
+import { regionCinematicsPlayed, waits } from "./cinematics.js";
+import { seatCameras } from "./cameraOrders.js";
+import { purchases, shopStock } from "./items.js";
+import { gathering } from "./orders/harvest.js";
+import { cargo } from "./transport.js";
+import { sent } from "./talk.js";
+import { pauses } from "./endings.js";
+import { controlled } from "./abilities/control.js";
+import { current } from "./dialog.js";
+import { played } from "./effects.js";
+import { corpses, illusion } from "./summons.js";
+import { redefinitions } from "./gameData.js";
+import { objectives } from "./objectives.js";
+import { mapDrops } from "./randomGroups.js";
+import { scoreData } from "./score.js";
+import { gateStates } from "./gates.js";
+import { tunings } from "./tunables.js";
+import { campMember, camps } from "./camps.js";
+import { sideKnowledge } from "./navigation/sidePaths.js";
+import { control, relations, vision } from "./sides.js";
+import { computerDefaults, computerSeats } from "./computers.js";
+import { captures, ready } from "./capture.js";
+import { counted } from "./denying.js";
+import { heroStrike, laneMinion, lanesState } from "./lanes.js";
+import { pileOf, remains } from "./remains.js";
+import { stance } from "./stances.js";
+import { veterancy } from "./veterancy.js";
+//#region src/coreComponents.ts
+/**
+* The engine's own components that its computer player's kit defines (`@v12-engine/engine/ai`), listed as the kit loads
+* (`listKitComponents`): the core loads nothing of the kit (E3), and a game that seats no computer has none of them
+*/
+var kit = [];
+/**
+* Lists components of the computer player's kit with the engine's own, as the kit's module loads
+*
+* @internal
+*/
+function listKitComponents(...components) {
+	for (const component of components) if (!kit.some((each) => each.id === component.id)) kit.push(component);
+}
+/**
+* The engine's own components, in one order: asked for as a registry is made, when every module that defines one has
+* been loaded (the kit's with them, where the game's brains loaded it)
+*
+* @internal
+*/
+function coreComponents() {
+	return [
+		moving,
+		fighting,
+		deposit,
+		exposure,
+		detection,
+		inventorySlots,
+		shopStock,
+		purchases,
+		heroState,
+		respawning,
+		corpses,
+		summoned,
+		illusion,
+		form,
+		scoreData,
+		pauses,
+		sent,
+		waiting,
+		shownTimers,
+		dashing,
+		waits,
+		regionCinematicsPlayed,
+		seatCameras,
+		computerSeats,
+		computerDefaults,
+		mapDrops,
+		captures,
+		ready,
+		names,
+		mapInfo,
+		counted,
+		gateStates,
+		objectives,
+		stance,
+		tunings,
+		pileOf,
+		remains,
+		laneMinion,
+		lanesState,
+		heroStrike,
+		cargo,
+		veterancy,
+		current,
+		inside,
+		added,
+		played,
+		campMember,
+		camps,
+		running,
+		relations,
+		vision,
+		control,
+		sideKnowledge,
+		redefinitions,
+		constructionSite,
+		gathering,
+		productionQueue,
+		teamMemory,
+		triggerState,
+		controlled,
+		...kit
+	];
+}
+//#endregion
+export { coreComponents, listKitComponents };
+
+//# sourceMappingURL=coreComponents.js.map

package/dist/coreComponents.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"coreComponents.js","names":["entity.moving","entity.fighting","entity.deposit","entity.exposure","entity.detection","inventory.inventorySlots","items.shopStock","items.purchases","hero.heroState","hero.respawning","summons.corpses","summons.summoned","summons.illusion","forms.form","score.scoreData","endings.pauses","talk.sent","timers.waiting","timers.shownTimers","dashing.dashing","cinematics.waits","cinematics.regionCinematicsPlayed","computers.computerSeats","computers.computerDefaults","randomGroups.mapDrops","capture.captures","capture.ready","names.names","names.mapInfo","denying.counted","gates.gateStates","objectives.objectives","stances.stance","tunables.tunings","remains.pileOf","remains.remains","lanes.laneMinion","lanes.lanesState","lanes.heroStrike","transport.cargo","veterancy.veterancy","dialog.current","areas.inside","areas.added","effects.played","camps.campMember","camps.camps","sequences.running","sides.relations","sides.vision","sides.control","sidePaths.sideKnowledge","gameData.redefinitions","construction.constructionSite","harvest.gathering","productionQueue.productionQueue","memory.teamMemory","triggers.triggerState","control.controlled"],"sources":["../src/coreComponents.ts"],"sourcesContent":["/**\n * The engine's own components, listed (design review E15): what every world's registry has besides its game's\n * (`Registry.component`), found by id there and not through the process. A component of the engine's is defined where\n * its rules live and added here; one that is not is a part no world finds (`Registry.component`, unlisted)\n */\nimport type { Component } from './components'\nimport * as areas from './areas'\nimport * as camps from './camps'\nimport * as capture from './capture'\nimport { seatCameras } from './cameraOrders'\nimport * as cinematics from './cinematics'\nimport * as computers from './computers'\nimport * as dashing from './dashing'\nimport * as denying from './denying'\nimport * as dialog from './dialog'\nimport * as effects from './effects'\nimport * as endings from './endings'\nimport * as entity from './entity'\nimport * as gameData from './gameData'\nimport * as forms from './formState'\nimport * as gates from './gates'\nimport * as hero from './hero'\nimport * as inventory from './inventory'\nimport * as items from './items'\nimport * as lanes from './lanes'\nimport * as names from './names'\nimport * as sidePaths from './navigation/sidePaths'\nimport * as objectives from './objectives'\nimport * as harvest from './orders/harvest'\nimport * as randomGroups from './randomGroups'\nimport * as remains from './remains'\nimport * as score from './score'\nimport * as sequences from './sequences'\nimport * as memory from './session/memory'\nimport * as sides from './sides'\nimport * as stances from './stances'\nimport * as summons from './summons'\nimport * as construction from './systems/construction'\nimport * as productionQueue from './systems/productionQueue'\nimport * as talk from './talk'\nimport * as timers from './timers'\nimport * as triggers from './abilities/triggers'\nimport * as control from './abilities/control'\nimport * as transport from './transport'\nimport * as tunables from './tunables'\nimport * as veterancy from './veterancy'\n\n/**\n * The engine's own components that its computer player's kit defines (`@v12-engine/engine/ai`), listed as the kit loads\n * (`listKitComponents`): the core loads nothing of the kit (E3), and a game that seats no computer has none of them\n */\nconst kit: Component<unknown, unknown>[] = []\n\n/**\n * Lists components of the computer player's kit with the engine's own, as the kit's module loads\n *\n * @internal\n */\nexport function listKitComponents(...components: Component<any, any>[]): void {\n\tfor (const component of components) if (!kit.some((each) => each.id === component.id)) kit.push(component)\n}\n\n/**\n * The engine's own components, in one order: asked for as a registry is made, when every module that defines one has\n * been loaded (the kit's with them, where the game's brains loaded it)\n *\n * @internal\n */\nexport function coreComponents(): readonly Component<unknown, unknown>[] {\n\treturn [\n\t\tentity.moving,\n\t\tentity.fighting,\n\t\tentity.deposit,\n\t\tentity.exposure,\n\t\tentity.detection,\n\t\tinventory.inventorySlots,\n\t\titems.shopStock,\n\t\titems.purchases,\n\t\thero.heroState,\n\t\thero.respawning,\n\t\tsummons.corpses,\n\t\tsummons.summoned,\n\t\tsummons.illusion,\n\t\tforms.form,\n\t\tscore.scoreData,\n\t\tendings.pauses,\n\t\ttalk.sent,\n\t\ttimers.waiting,\n\t\ttimers.shownTimers,\n\t\tdashing.dashing,\n\t\tcinematics.waits,\n\t\tcinematics.regionCinematicsPlayed,\n\t\tseatCameras,\n\t\tcomputers.computerSeats,\n\t\tcomputers.computerDefaults,\n\t\trandomGroups.mapDrops,\n\t\tcapture.captures,\n\t\tcapture.ready,\n\t\tnames.names,\n\t\tnames.mapInfo,\n\t\tdenying.counted,\n\t\tgates.gateStates,\n\t\tobjectives.objectives,\n\t\tstances.stance,\n\t\ttunables.tunings,\n\t\tremains.pileOf,\n\t\tremains.remains,\n\t\tlanes.laneMinion,\n\t\tlanes.lanesState,\n\t\tlanes.heroStrike,\n\t\ttransport.cargo,\n\t\tveterancy.veterancy,\n\t\tdialog.current,\n\t\tareas.inside,\n\t\tareas.added,\n\t\teffects.played,\n\t\tcamps.campMember,\n\t\tcamps.camps,\n\t\tsequences.running,\n\t\tsides.relations,\n\t\tsides.vision,\n\t\tsides.control,\n\t\tsidePaths.sideKnowledge,\n\t\tgameData.redefinitions,\n\t\tconstruction.constructionSite,\n\t\tharvest.gathering,\n\t\tproductionQueue.productionQueue,\n\t\tmemory.teamMemory,\n\t\ttriggers.triggerState,\n\t\tcontrol.controlled,\n\t\t...kit\n\t] as Component<unknown, unknown>[]\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmDA,IAAM,MAAqC,CAAC;;;;;;AAO5C,SAAgB,kBAAkB,GAAG,YAAyC;CAC7E,KAAK,MAAM,aAAa,YAAY,IAAI,CAAC,IAAI,MAAM,SAAS,KAAK,OAAO,UAAU,EAAE,GAAG,IAAI,KAAK,SAAS;AAC1G;;;;;;;AAQA,SAAgB,iBAAyD;CACxE,OAAO;EACNA;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACA;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACA,GAAG;CACJ;AACD"}