@v12-engine/engine 0.1.0 → 0.4.0

package/dist/prefabs.js

@@ -0,0 +1,239 @@
+import { cos, sin } from "./exactMath.js";
+import { hashText } from "./math.js";
+import { shapeAt } from "./areas.js";
+import "./map/types.js";
+import { spawnCamp } from "./camps.js";
+//#region src/prefabs.ts
+/**
+* Typed help for writing a prefab
+*
+* @public
+*/
+var definePrefab = (def) => def;
+/**
+* A prefab put down in the world as one: its objects spawned (`world.spawn`, for the owner given or as each says),
+* its camps (`spawnCamp`: a world with camps seats the creeps, `PlayerInit.creeps`), its areas added under ids of
+* their own; turned and sized around its middle as asked
+*
+* @beta
+*/
+function spawnPrefab(world, prefab, options) {
+	return spawnWithin(world, prefab, options, []);
+}
+/** `spawnPrefab`, told the prefabs it is inside of: one inside itself is not spawned again */
+function spawnWithin(world, prefab, options, within) {
+	const def = typeof prefab === "string" ? world.registry.prefab(prefab) : prefab;
+	const contents = typeof def.contents === "function" ? def.contents(options.at, world) : def.contents;
+	const turn = options.facing ?? 0;
+	const scale = options.scale ?? 1;
+	const c = cos(turn);
+	const s = sin(turn);
+	const place = (p) => {
+		const x = p.x * scale;
+		const z = p.z * scale;
+		return {
+			x: options.at.x + x * c + z * s,
+			z: options.at.z - x * s + z * c
+		};
+	};
+	const ownerOf = (owner) => owner === "neutral" ? 0 : owner === "creeps" ? 90 : typeof owner === "number" ? owner : options.owner ?? 0;
+	const out = {
+		entities: [],
+		camps: [],
+		areas: []
+	};
+	let suffix;
+	contents.objects?.forEach((object, i) => {
+		if (options.without?.objects?.includes(i)) return;
+		const entity = world.spawn(object.type, ownerOf(object.owner), place(object), {
+			facing: (object.facing ?? 0) + turn,
+			...object.scale !== void 0 && { scale: object.scale * scale },
+			...object.look !== void 0 && { look: object.look },
+			...object.name !== void 0 && { name: freeName(world, object.name) },
+			...object.underConstruction && { underConstruction: true }
+		});
+		if (object.health !== void 0 && object.health < 1) entity.health = Math.max(1, Math.round(entity.maxHealth * object.health));
+		out.entities.push(entity);
+	});
+	contents.camps?.forEach((camp, i) => {
+		if (options.without?.camps?.includes(i)) return;
+		const made = spawnCamp(world, 90, place(camp), camp.units);
+		if (camp.name) made.name = freeName(world, camp.name);
+		out.camps.push(made);
+	});
+	contents.areas?.forEach((area, i) => {
+		if (options.without?.areas?.includes(i)) return;
+		const at = place(area.shape);
+		const shape = shapeAt(area.shape, at, scale);
+		const id = `${area.id}#${suffix ??= world.newId()}`;
+		world.areas.add({
+			id,
+			shape
+		});
+		out.areas.push(id);
+	});
+	contents.prefabs?.forEach((inside, i) => {
+		if (options.without?.prefabs?.includes(i) || inside.prefab === def.id || within.includes(inside.prefab)) return;
+		const made = spawnWithin(world, inside.prefab, {
+			at: place(inside),
+			...options.owner !== void 0 && { owner: options.owner },
+			facing: turn + (inside.facing ?? 0),
+			scale: scale * (inside.scale ?? 1)
+		}, [...within, def.id]);
+		out.entities.push(...made.entities);
+		out.camps.push(...made.camps);
+		out.areas.push(...made.areas);
+	});
+	return out;
+}
+/** A name of the prefab's, free on this world: as it is, or with a number */
+function freeName(world, name) {
+	if (!world.named(name)) return name;
+	for (let n = 2;; n++) if (!world.named(`${name} ${n}`)) return `${name} ${n}`;
+}
+/** The lists of a file's copy the engine reads */
+var KINDS = [
+	"objects",
+	"camps",
+	"regions"
+];
+/**
+* The id a part of a prefab inside another has in the outer one's copy, as the editor and `prefabsFrom` number it:
+* made from the inner prefab's id there and the part's id in it (itself one of these, a level down), the same each
+* time it is read; below zero, where a prefab's own parts (the map's ids they had) never are
+*
+* @beta
+*/
+function nestedPartId(nested, id) {
+	return -(parseInt(hashText(`${nested}/${id}`), 16) || 1);
+}
+/**
+* A file read through the others it names, as the editor places it: a variant's source with its overrides, the file's
+* own parts, the prefabs inside it unpacked where it says; what holds itself or names a file there is not is left out
+*/
+function readThrough(file, name, read, within) {
+	const path = [...within, name];
+	const out = {
+		objects: [],
+		camps: [],
+		regions: []
+	};
+	const join = (more) => {
+		for (const kind of KINDS) {
+			const taken = new Set(out[kind].map((part) => part.id));
+			for (const part of more[kind] ?? []) {
+				if (part.id !== void 0 && taken.has(part.id)) {
+					let next = 1;
+					while (taken.has(next)) next++;
+					part.id = next;
+				}
+				taken.add(part.id);
+				out[kind].push(part);
+			}
+		}
+	};
+	const through = (of) => {
+		const other = !path.includes(of) ? read(of) : void 0;
+		return other && readThrough(other, of, read, path);
+	};
+	if (file.variant) {
+		const source = through(file.variant.of);
+		if (source) join(overriddenClip(source, file.variant.over, file.variant.without));
+	}
+	join(structuredClone(file.contents ?? {}));
+	for (const nested of file.prefabs ?? []) {
+		const inner = through(nested.prefab);
+		if (!inner) continue;
+		const turn = nested.turn ?? 0;
+		const scale = nested.scale ?? 1;
+		const c = cos(turn);
+		const s = sin(turn);
+		const place = (p) => {
+			const x = p.x * scale;
+			const z = p.z * scale;
+			return {
+				...p,
+				x: nested.x + x * c + z * s,
+				z: nested.z - x * s + z * c
+			};
+		};
+		const placed = overriddenClip(inner, nested.over, nested.without);
+		join({
+			objects: (placed.objects ?? []).map((object) => ({
+				...place(object),
+				id: nestedPartId(nested.id, object.id ?? 0),
+				facing: (object.facing ?? 0) + turn,
+				...scale !== 1 && { scale: (object.scale ?? 1) * scale }
+			})),
+			camps: (placed.camps ?? []).map((camp) => ({
+				...place(camp),
+				id: nestedPartId(nested.id, camp.id ?? 0)
+			})),
+			regions: (placed.regions ?? []).map((region) => ({
+				...region,
+				id: nestedPartId(nested.id, region.id ?? 0),
+				shape: shapeAt(region.shape, place(region.shape), scale)
+			}))
+		});
+	}
+	return out;
+}
+/** A copy with fields of its parts overridden and parts left out, by kind and id */
+function overriddenClip(clip, over, without) {
+	const out = {};
+	for (const kind of KINDS) {
+		const left = new Set(without?.[kind] ?? []);
+		const fields = over?.[kind] ?? {};
+		out[kind] = (clip[kind] ?? []).filter((part) => part.id === void 0 || !left.has(part.id)).map((part) => ({
+			...structuredClone(part),
+			...part.id !== void 0 && structuredClone(fields[part.id])
+		}));
+	}
+	return out;
+}
+/**
+* The prefabs a designer made in the editor (`prefabs/<name>.prefab.json` of the game's folder), as prefabs of the
+* game's, by their file names: `prefabsFrom(import.meta.glob('./prefabs/*.prefab.json', { eager: true }))`, or any
+* record of name to file. An object of a player's becomes the owner's; scenery, points and paths are left out. A
+* variant is read through its source and a prefab with prefabs inside through those, as the editor places them, from
+* the files given
+*
+* @public
+*/
+function prefabsFrom(files, options = {}) {
+	const byName = /* @__PURE__ */ new Map();
+	for (const [path, data] of Object.entries(files)) {
+		const file = data?.default ?? data;
+		if (file?.contents?.kind !== "v12-clip") continue;
+		byName.set(file.name ?? path.replace(/^.*[\\/]/, "").replace(/\.prefab\.json$/, ""), file);
+	}
+	const out = [];
+	for (const [name, file] of byName) {
+		const clip = file.variant || file.prefabs?.length ? readThrough(file, name, (of) => byName.get(of), []) : file.contents;
+		out.push({
+			id: `${options.prefix ?? ""}${name}`,
+			name,
+			contents: {
+				objects: (clip.objects ?? []).map(({ owner, ...object }) => ({
+					...object,
+					owner: owner === 0 ? "neutral" : owner === 90 ? "creeps" : "owner"
+				})),
+				camps: (clip.camps ?? []).map(({ x, z, units, name }) => ({
+					x,
+					z,
+					units,
+					...name && { name }
+				})),
+				areas: (clip.regions ?? []).map((region) => ({
+					id: region.name,
+					shape: region.shape
+				}))
+			}
+		});
+	}
+	return out;
+}
+//#endregion
+export { definePrefab, nestedPartId, prefabsFrom, spawnPrefab };
+
+//# sourceMappingURL=prefabs.js.map

package/dist/prefabs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefabs.js","names":[],"sources":["../src/prefabs.ts"],"sourcesContent":["import { type Camp, spawnCamp } from './camps'\nimport { type AreaShape, shapeAt } from './areas'\nimport type { Entity, PlayerId } from './entity'\nimport { MAP_CREEPS, MAP_NEUTRAL } from './map'\nimport { cos, sin } from './exactMath'\nimport { hashText, type Vec2 } from './math'\nimport type { World } from './world'\n\n/*\n * Prefabs in code (master plan FA4): a group of things a game spawns as one, at a place, for a player: a camp of a\n * kind, a base for the computer's expansion, a wave's fortress. The same shape the editor's prefab files have of their\n * contents, in the map's plain terms (no client types): the editor places one as a designer would, and a game spawns\n * one at tick 300, and they look the same. A game's own are `definePrefab`; the files a designer made are\n * `prefabsFrom(import.meta.glob('./prefabs/*.prefab.json', { eager: true }))`.\n *\n * What a prefab spawns at runtime is what the engine has at runtime: units and buildings (`world.spawn`), camps of\n * creeps (`spawnCamp`) and areas the rules watch (`world.areas.add`). Scenery, points and paths are the map's own\n * and have no life at runtime: a file's are left out, and said so once.\n */\n\n/** A unit or a building of a prefab, where it stands around the prefab's middle *\n * @beta\n */\nexport interface PrefabObject {\n\t/** The unit type id to spawn */\n\ttype: string\n\t/**\n\t * Whose: the player the prefab is spawned for (`'owner'`, the default), neutral, the creeps, or a player of the\n\t * map's by id (a file's objects say the id they had; one that is a player's becomes `'owner'` as the file is read)\n\t */\n\towner?: 'owner' | 'neutral' | 'creeps' | PlayerId\n\t/** Where it stands east-west, in cells from the prefab's middle before the prefab's turn and size */\n\tx: number\n\t/** Where it stands north-south, in cells from the prefab's middle before the prefab's turn and size */\n\tz: number\n\t/** Radians, the way entities face */\n\tfacing?: number\n\t/** Size of the entity as a multiple of its type's own; the prefab's scale is applied on top */\n\tscale?: number\n\t/** The id of the look the entity is drawn with, in place of its type's own */\n\tlook?: string\n\t/** A name of its own, for the rules to find it by: made free where it is taken (a number added) */\n\tname?: string\n\t/** 0..1 of its health, less than whole */\n\thealth?: number\n\t/** Structures: as a construction site */\n\tunderConstruction?: boolean\n}\n\n/** A camp of creeps of a prefab *\n * @beta\n */\nexport interface PrefabCamp {\n\t/** East-west position of the camp from the prefab's middle, in cells */\n\tx: number\n\t/** North-south position of the camp from the prefab's middle, in cells */\n\tz: number\n\t/** Unit type ids of the creeps the camp holds */\n\tunits: string[]\n\t/** A name for the camp, for the rules to find it by */\n\tname?: string\n}\n\n/** An area the rules watch, of a prefab: its id gets the spawn's own suffix, so that two of one prefab are two areas *\n * @beta\n */\nexport interface PrefabArea {\n\t/** The area's id before the spawn's own suffix is added, so two spawns of one prefab give two areas */\n\tid: string\n\t/** The area's shape, placed around the prefab's middle */\n\tshape: AreaShape\n}\n\n/** A prefab inside a prefab: spawned with it, its middle where it says from the outer one's, turned and sized with it *\n * @beta\n */\nexport interface PrefabInside {\n\t/** The prefab's id */\n\tprefab: string\n\t/** East-west position of the inner prefab's middle, from the outer one's middle, in cells */\n\tx: number\n\t/** North-south position of the inner prefab's middle, from the outer one's middle, in cells */\n\tz: number\n\t/** Radians, the way facings turn: on top of the outer prefab's turn */\n\tfacing?: number\n\t/** Size of the inner prefab as a multiple, on top of the outer prefab's scale */\n\tscale?: number\n}\n\n/** What a prefab is made of, around its middle (0, 0) *\n * @beta\n */\nexport interface PrefabContents {\n\t/** The units and buildings it spawns */\n\tobjects?: PrefabObject[]\n\t/** The camps of creeps it spawns */\n\tcamps?: PrefabCamp[]\n\t/** The areas it adds for the rules to watch */\n\tareas?: PrefabArea[]\n\t/** Prefabs inside it, spawned with it (a prefab that holds itself, at any depth, is not spawned past the first) */\n\tprefabs?: PrefabInside[]\n}\n\n/**\n * A prefab of a game's own: what `world.spawnPrefab` puts down as one. Its contents as data, or made for the place\n * and the world (a camp the stronger the farther from the starts)\n *\n * @beta\n */\nexport interface PrefabDef {\n\t/** Shared by every game: give it a prefix of the game's (`'td.fortress'`) */\n\tid: string\n\t/** A readable name for the prefab, for tools that list prefabs */\n\tname?: string\n\t/** What the prefab is made of: plain data, or a function of the spawn point and the world that returns it */\n\tcontents: PrefabContents | ((at: Vec2, world: World) => PrefabContents)\n}\n\n/**\n * Typed help for writing a prefab\n *\n * @public\n */\nexport const definePrefab = (def: PrefabDef): PrefabDef => def\n\n/** How a prefab is spawned: where its middle goes, for whom, turned and sized *\n * @beta\n */\nexport interface SpawnPrefabOptions {\n\t/** Where the prefab's middle goes, in world coordinates */\n\tat: Vec2\n\t/** The player the prefab's `'owner'` objects are spawned for: neutral when left out */\n\towner?: PlayerId\n\t/** Radians, the way facings turn: the prefab turned around its middle */\n\tfacing?: number\n\t/** Size multiplier of the prefab around its middle; whole size when left out */\n\tscale?: number\n\t/** Parts left out, by their index in the prefab's lists: a gate without its towers */\n\twithout?: { objects?: number[]; camps?: number[]; areas?: number[]; prefabs?: number[] }\n}\n\n/** What a prefab spawned became *\n * @beta\n */\nexport interface SpawnedPrefab {\n\t/** The units and buildings spawned */\n\tentities: Entity[]\n\t/** The camps of creeps spawned */\n\tcamps: Camp[]\n\t/** The ids of the areas added */\n\tareas: string[]\n}\n\n/**\n * A prefab put down in the world as one: its objects spawned (`world.spawn`, for the owner given or as each says),\n * its camps (`spawnCamp`: a world with camps seats the creeps, `PlayerInit.creeps`), its areas added under ids of\n * their own; turned and sized around its middle as asked\n *\n * @beta\n */\nexport function spawnPrefab(world: World, prefab: PrefabDef | string, options: SpawnPrefabOptions): SpawnedPrefab {\n\treturn spawnWithin(world, prefab, options, [])\n}\n\n/** `spawnPrefab`, told the prefabs it is inside of: one inside itself is not spawned again */\nfunction spawnWithin(world: World, prefab: PrefabDef | string, options: SpawnPrefabOptions, within: readonly string[]): SpawnedPrefab {\n\tconst def = typeof prefab === 'string' ? world.registry.prefab(prefab) : prefab\n\tconst contents = typeof def.contents === 'function' ? def.contents(options.at, world) : def.contents\n\tconst turn = options.facing ?? 0\n\tconst scale = options.scale ?? 1\n\tconst c = cos(turn)\n\tconst s = sin(turn)\n\t// the way facings turn: a quarter takes what was ahead (+z) to the right (+x)\n\tconst place = (p: Vec2): Vec2 => {\n\t\tconst x = p.x * scale\n\t\tconst z = p.z * scale\n\t\treturn { x: options.at.x + x * c + z * s, z: options.at.z - x * s + z * c }\n\t}\n\tconst ownerOf = (owner: PrefabObject['owner']): PlayerId =>\n\t\towner === 'neutral' ? MAP_NEUTRAL : owner === 'creeps' ? MAP_CREEPS : typeof owner === 'number' ? owner : (options.owner ?? MAP_NEUTRAL)\n\tconst out: SpawnedPrefab = { entities: [], camps: [], areas: [] }\n\t// the areas' ids are the world's: the same in every world played the same way, and in one loaded from a save\n\tlet suffix: number | undefined\n\tcontents.objects?.forEach((object, i) => {\n\t\tif (options.without?.objects?.includes(i)) return\n\t\tconst entity = world.spawn(object.type, ownerOf(object.owner), place(object), {\n\t\t\tfacing: (object.facing ?? 0) + turn,\n\t\t\t...(object.scale !== undefined && { scale: object.scale * scale }),\n\t\t\t...(object.look !== undefined && { look: object.look }),\n\t\t\t...(object.name !== undefined && { name: freeName(world, object.name) }),\n\t\t\t...(object.underConstruction && { underConstruction: true })\n\t\t})\n\t\tif (object.health !== undefined && object.health < 1) entity.health = Math.max(1, Math.round(entity.maxHealth * object.health))\n\t\tout.entities.push(entity)\n\t})\n\tcontents.camps?.forEach((camp, i) => {\n\t\tif (options.without?.camps?.includes(i)) return\n\t\tconst made = spawnCamp(world, MAP_CREEPS, place(camp), camp.units)\n\t\tif (camp.name) made.name = freeName(world, camp.name)\n\t\tout.camps.push(made)\n\t})\n\tcontents.areas?.forEach((area, i) => {\n\t\tif (options.without?.areas?.includes(i)) return\n\t\tconst at = place(area.shape)\n\t\tconst shape: AreaShape = shapeAt(area.shape, at, scale)\n\t\tconst id = `${area.id}#${(suffix ??= world.newId())}`\n\t\tworld.areas.add({ id, shape })\n\t\tout.areas.push(id)\n\t})\n\tcontents.prefabs?.forEach((inside, i) => {\n\t\tif (options.without?.prefabs?.includes(i) || inside.prefab === def.id || within.includes(inside.prefab)) return\n\t\tconst made = spawnWithin(\n\t\t\tworld,\n\t\t\tinside.prefab,\n\t\t\t{\n\t\t\t\tat: place(inside),\n\t\t\t\t...(options.owner !== undefined && { owner: options.owner }),\n\t\t\t\tfacing: turn + (inside.facing ?? 0),\n\t\t\t\tscale: scale * (inside.scale ?? 1)\n\t\t\t},\n\t\t\t[...within, def.id]\n\t\t)\n\t\tout.entities.push(...made.entities)\n\t\tout.camps.push(...made.camps)\n\t\tout.areas.push(...made.areas)\n\t})\n\treturn out\n}\n\n/** A name of the prefab's, free on this world: as it is, or with a number */\nfunction freeName(world: World, name: string): string {\n\tif (!world.named(name)) return name\n\tfor (let n = 2; ; n++) if (!world.named(`${name} ${n}`)) return `${name} ${n}`\n}\n\n/** What a prefab's file holds, as far as the engine reads it: the editor's shape (a copy with a name and a version), or the first files' bare copy */\ninterface PrefabFileLike {\n\tname?: string\n\tversion?: number\n\tcontents?: ClipLike\n\t/** A variant of another prefab of the files, by its name: the fields it overrides and the parts it leaves out, by kind and id */\n\tvariant?: { of: string; over?: Overrides; without?: Without }\n\t/** Prefabs of the files inside it, by name: where, turned and sized, and what it overrides and leaves out of each */\n\tprefabs?: { id: number; prefab: string; x: number; z: number; turn?: number; scale?: number; over?: Overrides; without?: Without }[]\n}\n\ntype Overrides = Partial<Record<string, Record<number, Record<string, unknown>>>>\ntype Without = Partial<Record<string, number[]>>\n\ninterface ClipObject {\n\tid?: number\n\ttype: string\n\towner: PlayerId\n\tx: number\n\tz: number\n\tfacing?: number\n\tscale?: number\n\tlook?: string\n\tname?: string\n\thealth?: number\n\tunderConstruction?: boolean\n}\n\ninterface ClipLike {\n\tkind?: string\n\tobjects?: ClipObject[]\n\tcamps?: { id?: number; x: number; z: number; units: string[]; name?: string }[]\n\tregions?: { id?: number; name: string; shape: AreaShape }[]\n}\n\n/** The lists of a file's copy the engine reads */\nconst KINDS = ['objects', 'camps', 'regions'] as const\n\n/**\n * The id a part of a prefab inside another has in the outer one's copy, as the editor and `prefabsFrom` number it:\n * made from the inner prefab's id there and the part's id in it (itself one of these, a level down), the same each\n * time it is read; below zero, where a prefab's own parts (the map's ids they had) never are\n *\n * @beta\n */\nexport function nestedPartId(nested: number, id: number): number {\n\treturn -(parseInt(hashText(`${nested}/${id}`), 16) || 1)\n}\n\n/**\n * A file read through the others it names, as the editor places it: a variant's source with its overrides, the file's\n * own parts, the prefabs inside it unpacked where it says; what holds itself or names a file there is not is left out\n */\nfunction readThrough(file: PrefabFileLike, name: string, read: (name: string) => PrefabFileLike | undefined, within: readonly string[]): ClipLike {\n\tconst path = [...within, name]\n\tconst out: Required<Omit<ClipLike, 'kind'>> = { objects: [], camps: [], regions: [] }\n\tconst join = (more: ClipLike) => {\n\t\tfor (const kind of KINDS) {\n\t\t\tconst taken = new Set(out[kind].map((part) => part.id))\n\t\t\tfor (const part of more[kind] ?? []) {\n\t\t\t\tif (part.id !== undefined && taken.has(part.id)) {\n\t\t\t\t\tlet next = 1\n\t\t\t\t\twhile (taken.has(next)) next++\n\t\t\t\t\tpart.id = next\n\t\t\t\t}\n\t\t\t\ttaken.add(part.id)\n\t\t\t\t;(out[kind] as unknown[]).push(part)\n\t\t\t}\n\t\t}\n\t}\n\tconst through = (of: string): ClipLike | undefined => {\n\t\tconst other = !path.includes(of) ? read(of) : undefined\n\t\treturn other && readThrough(other, of, read, path)\n\t}\n\tif (file.variant) {\n\t\tconst source = through(file.variant.of)\n\t\tif (source) join(overriddenClip(source, file.variant.over, file.variant.without))\n\t}\n\tjoin(structuredClone(file.contents ?? {}))\n\tfor (const nested of file.prefabs ?? []) {\n\t\tconst inner = through(nested.prefab)\n\t\tif (!inner) continue\n\t\tconst turn = nested.turn ?? 0\n\t\tconst scale = nested.scale ?? 1\n\t\t// the engine's own sines: a prefab read on any machine is the same prefab\n\t\tconst c = cos(turn)\n\t\tconst s = sin(turn)\n\t\tconst place = <T extends { x: number; z: number }>(p: T): T => {\n\t\t\tconst x = p.x * scale\n\t\t\tconst z = p.z * scale\n\t\t\treturn { ...p, x: nested.x + x * c + z * s, z: nested.z - x * s + z * c }\n\t\t}\n\t\tconst placed = overriddenClip(inner, nested.over, nested.without)\n\t\tjoin({\n\t\t\tobjects: (placed.objects ?? []).map((object) => ({\n\t\t\t\t...place(object),\n\t\t\t\tid: nestedPartId(nested.id, object.id ?? 0),\n\t\t\t\tfacing: (object.facing ?? 0) + turn,\n\t\t\t\t...(scale !== 1 && { scale: (object.scale ?? 1) * scale })\n\t\t\t})),\n\t\t\tcamps: (placed.camps ?? []).map((camp) => ({ ...place(camp), id: nestedPartId(nested.id, camp.id ?? 0) })),\n\t\t\tregions: (placed.regions ?? []).map((region) => ({\n\t\t\t\t...region,\n\t\t\t\tid: nestedPartId(nested.id, region.id ?? 0),\n\t\t\t\tshape: shapeAt(region.shape, place(region.shape), scale)\n\t\t\t}))\n\t\t})\n\t}\n\treturn out\n}\n\n/** A copy with fields of its parts overridden and parts left out, by kind and id */\nfunction overriddenClip(clip: ClipLike, over: Overrides | undefined, without: Without | undefined): ClipLike {\n\tconst out: ClipLike = {}\n\tfor (const kind of KINDS) {\n\t\tconst left = new Set(without?.[kind] ?? [])\n\t\tconst fields = over?.[kind] ?? {}\n\t\t;(out[kind] as unknown[]) = (clip[kind] ?? [])\n\t\t\t.filter((part) => part.id === undefined || !left.has(part.id))\n\t\t\t.map((part) => ({ ...structuredClone(part), ...(part.id !== undefined && structuredClone(fields[part.id])) }))\n\t}\n\treturn out\n}\n\n/**\n * The prefabs a designer made in the editor (`prefabs/<name>.prefab.json` of the game's folder), as prefabs of the\n * game's, by their file names: `prefabsFrom(import.meta.glob('./prefabs/*.prefab.json', { eager: true }))`, or any\n * record of name to file. An object of a player's becomes the owner's; scenery, points and paths are left out. A\n * variant is read through its source and a prefab with prefabs inside through those, as the editor places them, from\n * the files given\n *\n * @public\n */\nexport function prefabsFrom(files: Record<string, unknown>, options: { prefix?: string } = {}): PrefabDef[] {\n\tconst byName = new Map<string, PrefabFileLike>()\n\tfor (const [path, data] of Object.entries(files)) {\n\t\tconst file = ((data as { default?: unknown })?.default ?? data) as PrefabFileLike\n\t\tif (file?.contents?.kind !== 'v12-clip') continue\n\t\tbyName.set(file.name ?? path.replace(/^.*[\\\\/]/, '').replace(/\\.prefab\\.json$/, ''), file)\n\t}\n\tconst out: PrefabDef[] = []\n\tfor (const [name, file] of byName) {\n\t\tconst clip = file.variant || file.prefabs?.length ? readThrough(file, name, (of) => byName.get(of), []) : file.contents!\n\t\tout.push({\n\t\t\tid: `${options.prefix ?? ''}${name}`,\n\t\t\tname,\n\t\t\tcontents: {\n\t\t\t\tobjects: (clip.objects ?? []).map(({ owner, ...object }) => ({\n\t\t\t\t\t...object,\n\t\t\t\t\towner: owner === MAP_NEUTRAL ? 'neutral' : owner === MAP_CREEPS ? 'creeps' : 'owner'\n\t\t\t\t})),\n\t\t\t\tcamps: (clip.camps ?? []).map(({ x, z, units, name }) => ({ x, z, units, ...(name && { name }) })),\n\t\t\t\tareas: (clip.regions ?? []).map((region) => ({ id: region.name, shape: region.shape }))\n\t\t\t}\n\t\t})\n\t}\n\treturn out\n}\n"],"mappings":"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"}

package/dist/presetBuildings.js

@@ -0,0 +1,58 @@
+//#region src/presetBuildings.ts
+/**
+* A fountain: a building that keeps the game's aura on who is around it (`aura`, the id of a passive ability with an
+* `aura` effect: a fountain of health's regeneration, a fountain of mana's). It cannot be hurt; a map puts it down
+* for the neutral player, so the aura says `affects: 'all'` to reach everyone (the neutral player is nobody's ally).
+* What is given over the fountain's own goes over it: `presetFountain('healingWaters', { id: 'fountainOfHealth' })`
+*
+* @beta
+*/
+function presetFountain(aura, over = {}) {
+	return {
+		id: "fountain",
+		name: "Fountain",
+		kind: "building",
+		radius: 1.5,
+		footprint: {
+			w: 3,
+			d: 3
+		},
+		stats: { health: 1e3 },
+		sight: 6,
+		invulnerable: true,
+		abilities: [aura],
+		...over
+	};
+}
+/**
+* A marketplace's abilities: one for each trade (`MarketRate`), cast at once (`target: 'none'`), with an `exchange`
+* effect that trades the caster's owner's resources at its rate. A building of the game's lists their ids in its
+* `abilities` (`abilities: market.map((ability) => ability.id)`), the abilities go in the rules' `abilities`. With
+* less than the amount to sell, the player is told and nothing goes. The computer player does not cast them in a
+* fight (their `ai` says not now); its brain's `spells` may
+*
+* @beta
+*/
+function presetMarket(options) {
+	return options.rates.map(({ sell, buy, rate, amount = 100, id, name, hotkey }) => ({
+		id: id ?? `sell-${sell}-for-${buy}`,
+		name: name ?? `Sell ${sell} for ${buy}`,
+		description: `Trades ${amount} ${sell} for ${Math.floor(amount * rate + 1e-9)} ${buy}`,
+		target: "none",
+		maxLevel: 1,
+		...hotkey !== void 0 && { hotkey },
+		...options.cooldown !== void 0 && { cooldown: options.cooldown },
+		effects: [{
+			type: "exchange",
+			sell,
+			buy,
+			rate,
+			amount
+		}],
+		ai: () => null
+	}));
+}
+//#endregion
+export { presetFountain, presetMarket };
+
+//# sourceMappingURL=presetBuildings.js.map

package/dist/presetBuildings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"presetBuildings.js","names":[],"sources":["../src/presetBuildings.ts"],"sourcesContent":["import type { AbilityDef, UnitTypeDef } from './defs'\n\n/*\n * Ready-made places a game takes or leaves, beside its own (campaign plan GP4): a fountain, a building whose aura is\n * the game's, and a marketplace's abilities, one resource traded for another at a rate (`exchange` in `trade.ts`).\n * They say only what there is; the looks, the numbers and who stands where are the game's\n */\n\n/**\n * A fountain: a building that keeps the game's aura on who is around it (`aura`, the id of a passive ability with an\n * `aura` effect: a fountain of health's regeneration, a fountain of mana's). It cannot be hurt; a map puts it down\n * for the neutral player, so the aura says `affects: 'all'` to reach everyone (the neutral player is nobody's ally).\n * What is given over the fountain's own goes over it: `presetFountain('healingWaters', { id: 'fountainOfHealth' })`\n *\n * @beta\n */\nexport function presetFountain(aura: string, over: Partial<UnitTypeDef> = {}): UnitTypeDef {\n\treturn {\n\t\tid: 'fountain',\n\t\tname: 'Fountain',\n\t\tkind: 'building',\n\t\tradius: 1.5,\n\t\tfootprint: { w: 3, d: 3 },\n\t\tstats: { health: 1000 },\n\t\tsight: 6,\n\t\tinvulnerable: true,\n\t\tabilities: [aura],\n\t\t...over\n\t}\n}\n\n/**\n * One trade of a marketplace (`presetMarket`): `amount` of `sell` for `rate` of `buy` for each one sold\n *\n * @beta\n */\nexport interface MarketRate {\n\t/** The resource traded away, by id */\n\tsell: string\n\t/** The resource traded for, by id */\n\tbuy: string\n\t/** How much of `buy` comes for each one of `sell`: 0.5 is 100 lumber for 50 gold */\n\trate: number\n\t/** How much is sold at a time: 100 when left out */\n\tamount?: number\n\t/** The ability's id: `sell-<sell>-for-<buy>` when left out */\n\tid?: string\n\t/** The ability's name: `Sell <sell> for <buy>` when left out */\n\tname?: string\n\t/** The key the ability's button is pressed with */\n\thotkey?: string\n}\n\n/**\n * What `presetMarket` is given: the trades, and the seconds between two of each (none when left out)\n *\n * @beta\n */\nexport interface PresetMarketOptions {\n\t/** The trades, an ability each, in the order of the buttons */\n\trates: readonly MarketRate[]\n\t/** Seconds between two trades of each: none when left out */\n\tcooldown?: number\n}\n\n/**\n * A marketplace's abilities: one for each trade (`MarketRate`), cast at once (`target: 'none'`), with an `exchange`\n * effect that trades the caster's owner's resources at its rate. A building of the game's lists their ids in its\n * `abilities` (`abilities: market.map((ability) => ability.id)`), the abilities go in the rules' `abilities`. With\n * less than the amount to sell, the player is told and nothing goes. The computer player does not cast them in a\n * fight (their `ai` says not now); its brain's `spells` may\n *\n * @beta\n */\nexport function presetMarket(options: PresetMarketOptions): AbilityDef[] {\n\treturn options.rates.map(({ sell, buy, rate, amount = 100, id, name, hotkey }) => ({\n\t\tid: id ?? `sell-${sell}-for-${buy}`,\n\t\tname: name ?? `Sell ${sell} for ${buy}`,\n\t\tdescription: `Trades ${amount} ${sell} for ${Math.floor(amount * rate + 1e-9)} ${buy}`,\n\t\ttarget: 'none',\n\t\tmaxLevel: 1,\n\t\t...(hotkey !== undefined && { hotkey }),\n\t\t...(options.cooldown !== undefined && { cooldown: options.cooldown }),\n\t\teffects: [{ type: 'exchange', sell, buy, rate, amount }],\n\t\t// not a spell for a fight: the computer player trades as its brain says, not as the engine works out of effects\n\t\tai: () => null\n\t}))\n}\n"],"mappings":";;;;;;;;;AAgBA,SAAgB,eAAe,MAAc,OAA6B,CAAC,GAAgB;CAC1F,OAAO;EACN,IAAI;EACJ,MAAM;EACN,MAAM;EACN,QAAQ;EACR,WAAW;GAAE,GAAG;GAAG,GAAG;EAAE;EACxB,OAAO,EAAE,QAAQ,IAAK;EACtB,OAAO;EACP,cAAc;EACd,WAAW,CAAC,IAAI;EAChB,GAAG;CACJ;AACD;;;;;;;;;;AA6CA,SAAgB,aAAa,SAA4C;CACxE,OAAO,QAAQ,MAAM,KAAK,EAAE,MAAM,KAAK,MAAM,SAAS,KAAK,IAAI,MAAM,cAAc;EAClF,IAAI,MAAM,QAAQ,KAAK,OAAO;EAC9B,MAAM,QAAQ,QAAQ,KAAK,OAAO;EAClC,aAAa,UAAU,OAAO,GAAG,KAAK,OAAO,KAAK,MAAM,SAAS,OAAO,IAAI,EAAE,GAAG;EACjF,QAAQ;EACR,UAAU;EACV,GAAI,WAAW,KAAA,KAAa,EAAE,OAAO;EACrC,GAAI,QAAQ,aAAa,KAAA,KAAa,EAAE,UAAU,QAAQ,SAAS;EACnE,SAAS,CAAC;GAAE,MAAM;GAAY;GAAM;GAAK;GAAM;EAAO,CAAC;EAEvD,UAAU;CACX,EAAE;AACH"}

package/dist/presetFoliage.d.ts

@@ -0,0 +1,27 @@
+import type { FoliageStyleDef } from './foliage';
+import type { World } from './world';
+/**
+ * Ready-made kinds of grass to the rules, beside a game's own: what each hides, burns and slows, by the names of the
+ * client's ready-made looks (`presetFoliage`), so a style is the two of one name. And grass grown from the ground's
+ * paint made cells of the layer, for a game whose rules are to see it (`growOnTiles`)
+ */
+/**
+ * Ready-made kinds of grass to the rules (`FoliageStyleDef`), by the names of the client's looks (`presetFoliage`):
+ * `values: [{ value: 1, name: 'Meadow', foliage: presetFoliageStyles.meadow }]`. A meadow burns and grows back, tall
+ * grass, reeds, wheat, a thicket and a hedge hide who stands in them; dry grass burns hottest, snow grass hardly; a
+ * thicket slows those on foot, reeds a little; nothing walks through a hedge (`walkable: false`). A game changes what it
+ * wants: `{ ...presetFoliageStyles.wheat, trample: 'none' }`
+ *
+ * @beta
+ */
+export declare const presetFoliageStyles: Readonly<Record<'meadow' | 'tallGrass' | 'dryGrass' | 'reeds' | 'wheat' | 'snowGrass' | 'thicket' | 'hedge', FoliageStyleDef>>;
+/**
+ * Grass grown from the ground's paint made cells of a layer the rules see: every cell whose tile is one of `tiles`
+ * (by id) and that nothing of the layer is painted on is set to `value` (`world.setCells`: saved, told to the players,
+ * remembered through the fog). What a game calls once, as its world begins, for the grass the client grows on those
+ * tiles (`FoliageLook.on`) to hide and burn as `value`'s style says: from then on they are cells as any painted, and a
+ * tile painted later grows nothing to the rules until it is called again. The cells set
+ *
+ * @beta
+ */
+export declare function growOnTiles(world: World, layer: string, tiles: readonly string[], value: number): number[];

package/dist/presetFoliage.js

@@ -0,0 +1,98 @@
+//#region src/presetFoliage.ts
+/**
+* Ready-made kinds of grass to the rules, beside a game's own: what each hides, burns and slows, by the names of the
+* client's ready-made looks (`presetFoliage`), so a style is the two of one name. And grass grown from the ground's
+* paint made cells of the layer, for a game whose rules are to see it (`growOnTiles`)
+*/
+/**
+* Ready-made kinds of grass to the rules (`FoliageStyleDef`), by the names of the client's looks (`presetFoliage`):
+* `values: [{ value: 1, name: 'Meadow', foliage: presetFoliageStyles.meadow }]`. A meadow burns and grows back, tall
+* grass, reeds, wheat, a thicket and a hedge hide who stands in them; dry grass burns hottest, snow grass hardly; a
+* thicket slows those on foot, reeds a little; nothing walks through a hedge (`walkable: false`). A game changes what it
+* wants: `{ ...presetFoliageStyles.wheat, trample: 'none' }`
+*
+* @beta
+*/
+var presetFoliageStyles = {
+	meadow: {
+		flammable: .6,
+		burns: 6,
+		regrows: 90
+	},
+	tallGrass: {
+		conceals: true,
+		height: 1.4,
+		flammable: 1,
+		burns: 8,
+		regrows: 120
+	},
+	dryGrass: {
+		flammable: 1,
+		burns: 4,
+		fuel: 1.5,
+		regrows: 150
+	},
+	reeds: {
+		conceals: true,
+		height: 1.8,
+		speed: .85,
+		flammable: .3,
+		burns: 6,
+		regrows: 90
+	},
+	wheat: {
+		conceals: true,
+		concealsTaller: false,
+		height: 1.1,
+		flammable: .9,
+		burns: 5,
+		fuel: 1.2,
+		trample: "crush"
+	},
+	snowGrass: {
+		flammable: .1,
+		burns: 3,
+		regrows: 180
+	},
+	thicket: {
+		conceals: true,
+		height: 1.4,
+		speed: .6,
+		flammable: .4,
+		burns: 12,
+		fuel: 1.5,
+		regrows: 240
+	},
+	hedge: {
+		conceals: true,
+		height: 1.5,
+		walkable: false,
+		flammable: .3,
+		burns: 15,
+		fuel: 1.2
+	}
+};
+/**
+* Grass grown from the ground's paint made cells of a layer the rules see: every cell whose tile is one of `tiles`
+* (by id) and that nothing of the layer is painted on is set to `value` (`world.setCells`: saved, told to the players,
+* remembered through the fog). What a game calls once, as its world begins, for the grass the client grows on those
+* tiles (`FoliageLook.on`) to hide and burn as `value`'s style says: from then on they are cells as any painted, and a
+* tile painted later grows nothing to the rules until it is called again. The cells set
+*
+* @beta
+*/
+function growOnTiles(world, layer, tiles, value) {
+	if (!(Number.isInteger(value) && value >= 1 && value <= 255)) throw new Error(`growOnTiles: ${value} is no value of a layer (1 to 255)`);
+	const { terrain, registry } = world;
+	const ids = registry.tileIds;
+	const mask = /* @__PURE__ */ new Uint8Array(256);
+	for (let i = 0; i < ids.length && i < 255; i++) if (tiles.includes(ids[i])) mask[i + 1] = 1;
+	const painted = terrain.cells[layer];
+	const cells = [];
+	for (let c = 0, n = terrain.width * terrain.depth; c < n; c++) if (mask[terrain.tiles[c]] && !painted?.[c]) cells.push(c);
+	return cells.length ? world.setCells(layer, cells, value) : [];
+}
+//#endregion
+export { growOnTiles, presetFoliageStyles };
+
+//# sourceMappingURL=presetFoliage.js.map

package/dist/presetFoliage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"presetFoliage.js","names":[],"sources":["../src/presetFoliage.ts"],"sourcesContent":["import type { FoliageStyleDef } from './foliage'\nimport type { World } from './world'\n\n/**\n * Ready-made kinds of grass to the rules, beside a game's own: what each hides, burns and slows, by the names of the\n * client's ready-made looks (`presetFoliage`), so a style is the two of one name. And grass grown from the ground's\n * paint made cells of the layer, for a game whose rules are to see it (`growOnTiles`)\n */\n\n/**\n * Ready-made kinds of grass to the rules (`FoliageStyleDef`), by the names of the client's looks (`presetFoliage`):\n * `values: [{ value: 1, name: 'Meadow', foliage: presetFoliageStyles.meadow }]`. A meadow burns and grows back, tall\n * grass, reeds, wheat, a thicket and a hedge hide who stands in them; dry grass burns hottest, snow grass hardly; a\n * thicket slows those on foot, reeds a little; nothing walks through a hedge (`walkable: false`). A game changes what it\n * wants: `{ ...presetFoliageStyles.wheat, trample: 'none' }`\n *\n * @beta\n */\nexport const presetFoliageStyles: Readonly<\n\tRecord<'meadow' | 'tallGrass' | 'dryGrass' | 'reeds' | 'wheat' | 'snowGrass' | 'thicket' | 'hedge', FoliageStyleDef>\n> = {\n\tmeadow: { flammable: 0.6, burns: 6, regrows: 90 },\n\ttallGrass: { conceals: true, height: 1.4, flammable: 1, burns: 8, regrows: 120 },\n\tdryGrass: { flammable: 1, burns: 4, fuel: 1.5, regrows: 150 },\n\treeds: { conceals: true, height: 1.8, speed: 0.85, flammable: 0.3, burns: 6, regrows: 90 },\n\twheat: { conceals: true, concealsTaller: false, height: 1.1, flammable: 0.9, burns: 5, fuel: 1.2, trample: 'crush' },\n\tsnowGrass: { flammable: 0.1, burns: 3, regrows: 180 },\n\tthicket: { conceals: true, height: 1.4, speed: 0.6, flammable: 0.4, burns: 12, fuel: 1.5, regrows: 240 },\n\thedge: { conceals: true, height: 1.5, walkable: false, flammable: 0.3, burns: 15, fuel: 1.2 }\n}\n\n/**\n * Grass grown from the ground's paint made cells of a layer the rules see: every cell whose tile is one of `tiles`\n * (by id) and that nothing of the layer is painted on is set to `value` (`world.setCells`: saved, told to the players,\n * remembered through the fog). What a game calls once, as its world begins, for the grass the client grows on those\n * tiles (`FoliageLook.on`) to hide and burn as `value`'s style says: from then on they are cells as any painted, and a\n * tile painted later grows nothing to the rules until it is called again. The cells set\n *\n * @beta\n */\nexport function growOnTiles(world: World, layer: string, tiles: readonly string[], value: number): number[] {\n\tif (!(Number.isInteger(value) && value >= 1 && value <= 255)) throw new Error(`growOnTiles: ${value} is no value of a layer (1 to 255)`)\n\tconst { terrain, registry } = world\n\tconst ids = registry.tileIds\n\tconst mask = new Uint8Array(256)\n\tfor (let i = 0; i < ids.length && i < 255; i++) if (tiles.includes(ids[i])) mask[i + 1] = 1\n\tconst painted = terrain.cells[layer]\n\tconst cells: number[] = []\n\tfor (let c = 0, n = terrain.width * terrain.depth; c < n; c++) if (mask[terrain.tiles[c]] && !painted?.[c]) cells.push(c)\n\treturn cells.length ? world.setCells(layer, cells, value) : []\n}\n"],"mappings":";;;;;;;;;;;;;;;AAkBA,IAAa,sBAET;CACH,QAAQ;EAAE,WAAW;EAAK,OAAO;EAAG,SAAS;CAAG;CAChD,WAAW;EAAE,UAAU;EAAM,QAAQ;EAAK,WAAW;EAAG,OAAO;EAAG,SAAS;CAAI;CAC/E,UAAU;EAAE,WAAW;EAAG,OAAO;EAAG,MAAM;EAAK,SAAS;CAAI;CAC5D,OAAO;EAAE,UAAU;EAAM,QAAQ;EAAK,OAAO;EAAM,WAAW;EAAK,OAAO;EAAG,SAAS;CAAG;CACzF,OAAO;EAAE,UAAU;EAAM,gBAAgB;EAAO,QAAQ;EAAK,WAAW;EAAK,OAAO;EAAG,MAAM;EAAK,SAAS;CAAQ;CACnH,WAAW;EAAE,WAAW;EAAK,OAAO;EAAG,SAAS;CAAI;CACpD,SAAS;EAAE,UAAU;EAAM,QAAQ;EAAK,OAAO;EAAK,WAAW;EAAK,OAAO;EAAI,MAAM;EAAK,SAAS;CAAI;CACvG,OAAO;EAAE,UAAU;EAAM,QAAQ;EAAK,UAAU;EAAO,WAAW;EAAK,OAAO;EAAI,MAAM;CAAI;AAC7F;;;;;;;;;;AAWA,SAAgB,YAAY,OAAc,OAAe,OAA0B,OAAyB;CAC3G,IAAI,EAAE,OAAO,UAAU,KAAK,KAAK,SAAS,KAAK,SAAS,MAAM,MAAM,IAAI,MAAM,gBAAgB,MAAM,mCAAmC;CACvI,MAAM,EAAE,SAAS,aAAa;CAC9B,MAAM,MAAM,SAAS;CACrB,MAAM,uBAAO,IAAI,WAAW,GAAG;CAC/B,KAAK,IAAI,IAAI,GAAG,IAAI,IAAI,UAAU,IAAI,KAAK,KAAK,IAAI,MAAM,SAAS,IAAI,EAAE,GAAG,KAAK,IAAI,KAAK;CAC1F,MAAM,UAAU,QAAQ,MAAM;CAC9B,MAAM,QAAkB,CAAC;CACzB,KAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,QAAQ,QAAQ,OAAO,IAAI,GAAG,KAAK,IAAI,KAAK,QAAQ,MAAM,OAAO,CAAC,UAAU,IAAI,MAAM,KAAK,CAAC;CACxH,OAAO,MAAM,SAAS,MAAM,SAAS,OAAO,OAAO,KAAK,IAAI,CAAC;AAC9D"}

package/dist/presetGround.js

@@ -0,0 +1,65 @@
+import { defineCellLayer } from "./cellLayers.js";
+import { defineTile } from "./tiles.js";
+//#region src/presetGround.ts
+/**
+* Ready-made grounds a game takes or leaves, beside its own: the tiles of an RTS's ground (grass, dark grass, dirt,
+* road, sand, rock, snow), which the client draws with its `TILE_LOOKS`, and the blight a race spoils ground with,
+* which the client draws with its `blightLook`. They say only what there is; what they do is the game's
+*/
+/**
+* The tiles of an RTS's ground, by the ids the client's `TILE_LOOKS` has looks for: `tiles: presetTiles` in the rules,
+* `tiles: TILE_LOOKS` in the view. A game adds its own beside them, or takes some (`presetTiles.filter(...)`)
+*
+* @beta
+*/
+var presetTiles = [
+	defineTile({
+		id: "grass",
+		name: "Grass"
+	}),
+	defineTile({
+		id: "darkGrass",
+		name: "Dark grass"
+	}),
+	defineTile({
+		id: "dirt",
+		name: "Dirt"
+	}),
+	defineTile({
+		id: "road",
+		name: "Road"
+	}),
+	defineTile({
+		id: "sand",
+		name: "Sand"
+	}),
+	defineTile({
+		id: "rock",
+		name: "Rock"
+	}),
+	defineTile({
+		id: "snow",
+		name: "Snow"
+	})
+];
+/**
+* Blight: ground spoiled, a layer of cells a map's maker paints and the rules spread (`world.setCells('blight', …)`),
+* drawn by the client's `blightLook`. What it does (who builds on it, who heals on it) is the game's: melee's
+* undead in the example
+*
+* @beta
+*/
+var presetBlight = defineCellLayer({
+	id: "blight",
+	name: "Blight",
+	description: "Spoiled ground: what the game says of it, a race that builds on it, one that heals on it",
+	color: [
+		.45,
+		.3,
+		.55
+	]
+});
+//#endregion
+export { presetBlight, presetTiles };
+
+//# sourceMappingURL=presetGround.js.map

package/dist/presetGround.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"presetGround.js","names":[],"sources":["../src/presetGround.ts"],"sourcesContent":["import { type CellLayerDef, defineCellLayer } from './cellLayers'\nimport { type TileDef, defineTile } from './tiles'\n\n/**\n * Ready-made grounds a game takes or leaves, beside its own: the tiles of an RTS's ground (grass, dark grass, dirt,\n * road, sand, rock, snow), which the client draws with its `TILE_LOOKS`, and the blight a race spoils ground with,\n * which the client draws with its `blightLook`. They say only what there is; what they do is the game's\n */\n\n/**\n * The tiles of an RTS's ground, by the ids the client's `TILE_LOOKS` has looks for: `tiles: presetTiles` in the rules,\n * `tiles: TILE_LOOKS` in the view. A game adds its own beside them, or takes some (`presetTiles.filter(...)`)\n *\n * @beta\n */\nexport const presetTiles: readonly TileDef[] = [\n\tdefineTile({ id: 'grass', name: 'Grass' }),\n\tdefineTile({ id: 'darkGrass', name: 'Dark grass' }),\n\tdefineTile({ id: 'dirt', name: 'Dirt' }),\n\tdefineTile({ id: 'road', name: 'Road' }),\n\tdefineTile({ id: 'sand', name: 'Sand' }),\n\tdefineTile({ id: 'rock', name: 'Rock' }),\n\tdefineTile({ id: 'snow', name: 'Snow' })\n]\n\n/**\n * Blight: ground spoiled, a layer of cells a map's maker paints and the rules spread (`world.setCells('blight', …)`),\n * drawn by the client's `blightLook`. What it does (who builds on it, who heals on it) is the game's: melee's\n * undead in the example\n *\n * @beta\n */\nexport const presetBlight: CellLayerDef = defineCellLayer({\n\tid: 'blight',\n\tname: 'Blight',\n\tdescription: 'Spoiled ground: what the game says of it, a race that builds on it, one that heals on it',\n\tcolor: [0.45, 0.3, 0.55]\n})\n"],"mappings":";;;;;;;;;;;;;;AAeA,IAAa,cAAkC;CAC9C,WAAW;EAAE,IAAI;EAAS,MAAM;CAAQ,CAAC;CACzC,WAAW;EAAE,IAAI;EAAa,MAAM;CAAa,CAAC;CAClD,WAAW;EAAE,IAAI;EAAQ,MAAM;CAAO,CAAC;CACvC,WAAW;EAAE,IAAI;EAAQ,MAAM;CAAO,CAAC;CACvC,WAAW;EAAE,IAAI;EAAQ,MAAM;CAAO,CAAC;CACvC,WAAW;EAAE,IAAI;EAAQ,MAAM;CAAO,CAAC;CACvC,WAAW;EAAE,IAAI;EAAQ,MAAM;CAAO,CAAC;AACxC;;;;;;;;AASA,IAAa,eAA6B,gBAAgB;CACzD,IAAI;CACJ,MAAM;CACN,aAAa;CACb,OAAO;EAAC;EAAM;EAAK;CAAI;AACxB,CAAC"}

package/dist/proxies.d.ts

@@ -0,0 +1,12 @@
+import type { EffectContext } from './abilities/effects';
+import type { ProxyOrigin } from './defs';
+import type { Entity } from './entity';
+/**
+ * The units of the caster's an effect with a proxy origin goes off from (`ProxyOrigin`), in the order it goes off from
+ * them: those of its type that are the caster's (put down by it: `madeBy`; or its owner's where nothing says who put one
+ * down), within its `range` of the caster and `near` where it was aimed, and of those the ones it picks. The caster is
+ * not among them (`ProxyOrigin.caster` says when it goes off from it too). For a game's own effect, and a screen
+ *
+ * @beta
+ */
+export declare function proxiesOf(context: Pick<EffectContext, 'world' | 'caster' | 'point'>, origin: ProxyOrigin): Entity[];

package/dist/proxies.js

@@ -0,0 +1,79 @@
+import { hypot } from "./exactMath.js";
+//#region src/proxies.ts
+/** Who put a unit down, where the ground objects pack says (`madeBy`): read by its id, so that this brings in none of the pack */
+var MADE_BY = "core.madeBy";
+/** Whether a unit is the caster's: put down by it, or, where nothing says who put it down, its owner's */
+function isOf(world, unit, caster) {
+	const component = world.registry.component(MADE_BY);
+	const made = component && unit.get(component);
+	return made ? made.by === caster.id : unit.owner === caster.owner;
+}
+/**
+* The units of the caster's an effect with a proxy origin goes off from (`ProxyOrigin`), in the order it goes off from
+* them: those of its type that are the caster's (put down by it: `madeBy`; or its owner's where nothing says who put one
+* down), within its `range` of the caster and `near` where it was aimed, and of those the ones it picks. The caster is
+* not among them (`ProxyOrigin.caster` says when it goes off from it too). For a game's own effect, and a screen
+*
+* @beta
+*/
+function proxiesOf(context, origin) {
+	const { world, caster, point } = context;
+	const found = [];
+	const candidates = origin.range === void 0 ? world.units.values() : world.spatial.query(caster.pos.x, caster.pos.z, origin.range + 2);
+	for (const unit of candidates) {
+		if (unit === caster || !unit.alive || unit.hidden || unit.def.id !== origin.proxy || !isOf(world, unit, caster)) continue;
+		if (origin.range !== void 0 && hypot(unit.pos.x - caster.pos.x, unit.pos.z - caster.pos.z) > origin.range) continue;
+		if (origin.near !== void 0 && hypot(unit.pos.x - point.x, unit.pos.z - point.z) > origin.near) continue;
+		found.push(unit);
+	}
+	found.sort((a, b) => a.id - b.id);
+	switch (origin.pick ?? "nearest") {
+		case "all": return found;
+		case "newest": return found.slice(-1);
+		case "oldest": return found.slice(0, 1);
+		default: {
+			let best;
+			let gap = Infinity;
+			for (const unit of found) {
+				const d = hypot(unit.pos.x - point.x, unit.pos.z - point.z);
+				if (d < gap) [best, gap] = [unit, d];
+			}
+			return best ? [best] : [];
+		}
+	}
+}
+/**
+* Runs an effect with a proxy origin (`EffectCommon.origin`): once from the caster where it says so, and once from each
+* proxy it picks, that one the `origin` (its place the `point` with `at: 'proxy'`, and the `target` with `target`)
+*
+* @internal
+*/
+function fromProxies(context, effect, each) {
+	const origin = effect.origin;
+	const picked = proxiesOf(context, origin);
+	const fromCaster = origin.caster === true || origin.caster === "otherwise" && !picked.length;
+	const atProxy = origin.at === "proxy";
+	if (fromCaster) each(atProxy ? {
+		...context,
+		point: {
+			x: context.caster.pos.x,
+			z: context.caster.pos.z
+		}
+	} : context);
+	for (const proxy of picked) {
+		if (!proxy.alive) continue;
+		each({
+			...context,
+			origin: proxy,
+			...atProxy && { point: {
+				x: proxy.pos.x,
+				z: proxy.pos.z
+			} },
+			...origin.target && { target: proxy }
+		});
+	}
+}
+//#endregion
+export { fromProxies, proxiesOf };
+
+//# sourceMappingURL=proxies.js.map