@v12-engine/engine 0.1.0 → 0.4.0

package/dist/foliageRegrowth.js

@@ -0,0 +1,332 @@
+import { defineComponent } from "./components.js";
+//#region src/foliageRegrowth.ts
+/** The most cells of a layer grown back (or set growing) a tick: the rest the next ticks, in their order */
+var REGROW_A_TICK = 1024;
+/** What a list is cut back to its waiting part at: once this much of it is done, and half */
+var COMPACT_AT = 1024;
+/** Seconds a cell takes to grow back once it starts by itself, where its style does not say (`FoliageStyleDef.grows`) */
+var GROWS = 10;
+/** What names a cell's entry now (`FoliageRegrowth.index`): when it is due, and whether it is to stand whole then or start growing */
+var keyOf = (due, grow) => due * 2 + (grow < 0 ? 1 : 0);
+/**
+* Where a foliage pack keeps its regrowth (`FoliageRegrowth`), on the pack: for its world state's save to find
+*
+* @internal
+*/
+var REGROWTH = Symbol("foliage regrowth");
+/** The regrowth of a world's game: none where it has no foliage pack */
+var regrowthOf = (world) => (world.registry.assembly?.rules.packs?.find((pack) => REGROWTH in pack))?.[REGROWTH];
+/**
+* What waits to grow back in a world (`RegrowState`): plain data, kept by a save as what is still to come, each list
+* from its waiting part
+*
+* @internal
+*/
+var regrowState = /* @__PURE__ */ defineComponent({
+	id: "foliage.regrow",
+	default: () => ({}),
+	save: (state, world) => saved(state, regrowthOf(world))
+});
+/** A save's copy of what waits: each list from its waiting part, without what was passed over (given a new time since) */
+function saved(state, regrowth) {
+	const copy = {};
+	for (const layer of Object.keys(state).sort()) {
+		const queue = state[layer];
+		const at = regrowth?.indexOf(queue);
+		const kept = {
+			cells: [],
+			due: [],
+			grow: [],
+			by: [],
+			head: 0
+		};
+		for (let i = queue.head; i < queue.cells.length; i++) {
+			if (at && at[queue.cells[i]] !== keyOf(queue.due[i], queue.grow[i])) continue;
+			kept.cells.push(queue.cells[i]);
+			kept.due.push(queue.due[i]);
+			kept.grow.push(queue.grow[i]);
+			kept.by.push(queue.by[i]);
+		}
+		if (kept.cells.length) copy[layer] = kept;
+	}
+	return copy;
+}
+/**
+* Grass growing back, the pack's: what each of its styles says of it, and what a tick and the calls do with a world's
+* `regrowState`. One a pack, for every world of its game: the cells' times now (`at`) are kept by the list they are of
+*
+* @internal
+*/
+var FoliageRegrowth = class {
+	host;
+	/** The system that runs it */
+	system;
+	/** Each list's cells' entries now, by cell: the one still to come (`keyOf`), -1 for none */
+	index = /* @__PURE__ */ new WeakMap();
+	styles;
+	/** Scratch of a tick: what grows whole, starts growing, and for how long, of a layer */
+	whole = [];
+	wholeBy = [];
+	starting = [];
+	startingFor = [];
+	constructor(host) {
+		this.host = host;
+		this.system = {
+			name: "foliage.regrow",
+			phase: "resolve",
+			update: (world) => {
+				if (!world.states.has(regrowState)) return;
+				this.tick(world, world.state(regrowState));
+			}
+		};
+	}
+	/** Each cell's time now of a list (`index`): none where it was never asked for in this process (a save's, loaded) */
+	indexOf(queue) {
+		return this.index.get(queue);
+	}
+	/** How each style grows back, worked out once for a game's layers of cells and its tick */
+	stylesOf(world) {
+		const { cellLayers } = world.registry;
+		if (this.styles?.of === cellLayers && this.styles.dt === world.dt) return this.styles;
+		const game = {
+			cellLayers,
+			packs: world.registry.assembly?.rules.packs
+		};
+		const styles = {
+			of: cellLayers,
+			dt: world.dt,
+			after: [],
+			grows: []
+		};
+		for (const layer of this.host.layers) {
+			const after = (/* @__PURE__ */ new Int32Array(256)).fill(-1);
+			const grows = /* @__PURE__ */ new Int32Array(256);
+			for (let value = 1; value < 256; value++) {
+				const style = this.host.style(game, layer, value);
+				const regrows = style?.regrows;
+				if (typeof regrows === "number" && Number.isFinite(regrows)) after[value] = Math.max(1, Math.round(Math.max(0, regrows) / world.dt));
+				grows[value] = Math.max(0, Math.round(Math.max(0, style?.grows ?? GROWS) / world.dt));
+			}
+			styles.after.push(after);
+			styles.grows.push(grows);
+		}
+		return this.styles = styles;
+	}
+	/** A layer's list of a world, made where it has none; and its cells' times now, worked out of it where they were not kept */
+	queueOf(world, l) {
+		const state = world.state(regrowState);
+		const layer = this.host.layers[l];
+		const queue = state[layer] ??= {
+			cells: [],
+			due: [],
+			grow: [],
+			by: [],
+			head: 0
+		};
+		let at = this.index.get(queue);
+		if (!at) {
+			at = new Float64Array(world.terrain.width * world.terrain.depth).fill(-1);
+			for (let i = queue.head; i < queue.cells.length; i++) at[queue.cells[i]] = keyOf(queue.due[i], queue.grow[i]);
+			this.index.set(queue, at);
+		}
+		return {
+			queue,
+			at
+		};
+	}
+	/**
+	* Cells of a layer were ruined or burnt (in order of their indices): each to grow back by itself where its style
+	* says (`regrows`), and nothing it waited for before; never where its style does not
+	*/
+	ruined(world, l, cells) {
+		if (!cells.length) return;
+		const { after, grows } = this.stylesOf(world);
+		const values = world.terrain.cells[this.host.layers[l]];
+		const waits = after[l];
+		let any = false;
+		for (let i = 0; i < cells.length && !any; i++) any = waits[values?.[cells[i]] ?? 0] >= 0;
+		if (!any) {
+			if (!world.states.has(regrowState) || !world.state(regrowState)[this.host.layers[l]]) return;
+			const { at } = this.queueOf(world, l);
+			for (const cell of cells) at[cell] = -1;
+			return;
+		}
+		const { queue, at } = this.queueOf(world, l);
+		const add = [];
+		for (const cell of cells) {
+			const value = values?.[cell] ?? 0;
+			const wait = waits[value];
+			if (wait < 0) {
+				at[cell] = -1;
+				continue;
+			}
+			add.push({
+				cell,
+				due: world.tick + wait,
+				grow: grows[l][value]
+			});
+		}
+		this.add(queue, at, add.map((each) => each.cell), add.map((each) => each.due), add.map((each) => each.grow), void 0);
+	}
+	/**
+	* Has cells of a layer grow back (`regrow`): those ruined or burnt, and those growing where it is at once. Over
+	* `over` ticks (growing, whole at its end), or at once (0). The cells that started to, in order
+	*/
+	regrow(world, l, cells, over, by) {
+		const { state } = this.host;
+		const terrain = world.terrain;
+		const values = terrain.cells[this.host.layers[l]];
+		const states = terrain.cells[this.host.states[l]];
+		const now = over <= 0;
+		const which = cells.filter((cell) => {
+			if (!values?.[cell]) return false;
+			const was = states?.[cell] ?? state.whole;
+			return was === state.flattened || was === state.cut || was === state.burnt || now && was === state.growing;
+		});
+		if (!which.length) return which;
+		const layer = this.host.layers[l];
+		if (now) {
+			world.setCells(this.host.states[l], which, state.whole);
+			if (world.states.has(regrowState) && world.state(regrowState)[layer]) {
+				const { at } = this.queueOf(world, l);
+				for (const cell of which) at[cell] = -1;
+			}
+			this.host.regrown(world, layer, which, by);
+			return which;
+		}
+		world.setCells(this.host.states[l], which, state.growing, { over: over * world.dt });
+		const { queue, at } = this.queueOf(world, l);
+		this.add(queue, at, which, which.map(() => world.tick + over), which.map(() => -1), by);
+		return which;
+	}
+	/**
+	* Entries into a list, in its order (by when due, then by cell): merged in from the end, so that what comes after
+	* all that waits (as most does) costs only its own room. Each cell's time now is the one given; one given twice is
+	* there once (as a cell given the same entry again)
+	*/
+	add(queue, at, cells, due, grow, by) {
+		if (!cells.length) return;
+		const order = cells.map((_, k) => k);
+		order.sort((a, b) => due[a] - due[b] || cells[a] - cells[b]);
+		const fresh = [];
+		for (const k of order) {
+			const key = keyOf(due[k], grow[k]);
+			if (at[cells[k]] === key) continue;
+			at[cells[k]] = key;
+			fresh.push(k);
+		}
+		if (!fresh.length) return;
+		this.compact(queue);
+		let i = queue.cells.length - 1;
+		let j = fresh.length - 1;
+		for (let k = 0; k < fresh.length; k++) {
+			queue.cells.push(0);
+			queue.due.push(0);
+			queue.grow.push(0);
+			queue.by.push(0);
+		}
+		for (let w = queue.cells.length - 1; j >= 0; w--) {
+			const k = fresh[j];
+			if (i >= queue.head && (queue.due[i] > due[k] || queue.due[i] === due[k] && queue.cells[i] > cells[k])) {
+				queue.cells[w] = queue.cells[i];
+				queue.due[w] = queue.due[i];
+				queue.grow[w] = queue.grow[i];
+				queue.by[w] = queue.by[i];
+				i--;
+			} else {
+				queue.cells[w] = cells[k];
+				queue.due[w] = due[k];
+				queue.grow[w] = grow[k];
+				queue.by[w] = by ?? 0;
+				j--;
+			}
+		}
+	}
+	/** A list cut back to its waiting part, where much of it is done */
+	compact(queue) {
+		const { head } = queue;
+		if (head < COMPACT_AT || head * 2 < queue.cells.length) return;
+		queue.cells.splice(0, head);
+		queue.due.splice(0, head);
+		queue.grow.splice(0, head);
+		queue.by.splice(0, head);
+		queue.head = 0;
+	}
+	/**
+	* A tick: of each layer's list, the cells due by now, at most `REGROW_A_TICK`, in their order: those whose time it
+	* still is (not given another since, still ruined or growing, still grass) start growing (one `setCells` for each
+	* length of growing) or stand whole (one `setCells`, told by whom)
+	*/
+	tick(world, state) {
+		const { tick } = world;
+		const { layers } = this.host;
+		for (let l = 0; l < layers.length; l++) {
+			const queue = state[layers[l]];
+			if (!queue || queue.head >= queue.cells.length || queue.due[queue.head] > tick) continue;
+			this.layerTick(world, l, queue);
+		}
+	}
+	/** A tick of a layer's list that has cells due (`tick`) */
+	layerTick(world, l, queue) {
+		const { state, layers, states } = this.host;
+		const { tick, terrain } = world;
+		const { at } = this.queueOf(world, l);
+		const values = terrain.cells[layers[l]];
+		const kept = terrain.cells[states[l]];
+		const { whole, wholeBy, starting, startingFor } = this;
+		whole.length = wholeBy.length = starting.length = startingFor.length = 0;
+		let done = 0;
+		let i = queue.head;
+		for (; i < queue.cells.length && queue.due[i] <= tick && done < REGROW_A_TICK; i++) {
+			const cell = queue.cells[i];
+			if (at[cell] !== keyOf(queue.due[i], queue.grow[i])) continue;
+			at[cell] = -1;
+			const was = kept?.[cell] ?? state.whole;
+			if (!values?.[cell]) continue;
+			const grow = queue.grow[i];
+			if (grow < 0) {
+				if (was !== state.growing) continue;
+				whole.push(cell);
+				wholeBy.push(queue.by[i]);
+			} else {
+				if (was !== state.flattened && was !== state.cut && was !== state.burnt) continue;
+				if (grow === 0) {
+					whole.push(cell);
+					wholeBy.push(0);
+				} else {
+					starting.push(cell);
+					startingFor.push(grow);
+				}
+			}
+			done++;
+		}
+		queue.head = i;
+		if (queue.head >= queue.cells.length) {
+			queue.cells.length = queue.due.length = queue.grow.length = queue.by.length = 0;
+			queue.head = 0;
+		} else this.compact(queue);
+		const layer = layers[l];
+		if (whole.length) {
+			world.setCells(states[l], whole, state.whole);
+			const first = wholeBy[0];
+			if (wholeBy.every((by) => by === first)) this.host.regrown(world, layer, [...whole], first);
+			else for (const by of [...new Set(wholeBy)]) {
+				const cells = whole.filter((_, k) => wholeBy[k] === by);
+				this.host.regrown(world, layer, cells, by);
+			}
+		}
+		if (starting.length) {
+			const lengths = [...new Set(startingFor)];
+			for (const length of lengths) {
+				const cells = lengths.length === 1 ? starting : starting.filter((_, k) => startingFor[k] === length);
+				world.setCells(states[l], cells, state.growing, { over: length * world.dt });
+				const { queue: now, at: times } = this.queueOf(world, l);
+				this.add(now, times, cells, cells.map(() => tick + length), cells.map(() => -1), void 0);
+			}
+		}
+	}
+};
+//#endregion
+export { FoliageRegrowth, REGROWTH, regrowState };
+
+//# sourceMappingURL=foliageRegrowth.js.map

package/dist/foliageRegrowth.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"foliageRegrowth.js","names":[],"sources":["../src/foliageRegrowth.ts"],"sourcesContent":["import { defineComponent } from './components'\nimport type { CellLayerDef } from './cellLayers'\nimport type { FOLIAGE_STATE, FoliageStyleDef } from './foliage'\nimport type { GamePack } from './packs/pack'\nimport type { System } from './registry'\nimport type { World } from './world'\n\n/*\n * Grass growing back. A cell cut, crushed, scorched or burnt comes back by itself where its style says (`regrows`: so\n * many seconds after, then `grows` seconds growing), or when the game says (`regrow`). What the rules keep for it is\n * the world's (`regrowState`, saved): each layer's cells waiting, in the order they are due (then by cell), each with\n * what it does then: start growing (for so many ticks), or stand whole. A tick looks at the front of each layer's list\n * alone, and does at most `REGROW_A_TICK` cells of it; nothing is done while nothing waits, and a list waiting on its\n * first cell costs a comparison. A cell given a new time (ruined again, regrown by the game) keeps its old place in the\n * list, which is passed over when it comes up: each cell's entry now is kept beside the list (`at`: when it is due and\n * what it does then, `keyOf`; not saved), and a save keeps only what is still to come\n */\n\n/** The most cells of a layer grown back (or set growing) a tick: the rest the next ticks, in their order */\nconst REGROW_A_TICK = 1024\n\n/** What a list is cut back to its waiting part at: once this much of it is done, and half */\nconst COMPACT_AT = 1024\n\n/** Seconds a cell takes to grow back once it starts by itself, where its style does not say (`FoliageStyleDef.grows`) */\nconst GROWS = 10\n\n/** A layer's cells waiting to grow back, in the order they are due, then by cell, from `head` */\ninterface RegrowQueue {\n\t/** The cells, by index */\n\tcells: number[]\n\t/** The tick each is due at */\n\tdue: number[]\n\t/** What each does then: starts growing for so many ticks (0: whole at once), or stands whole (-1: it grew) */\n\tgrow: number[]\n\t/** Who had it grow back, by id: 0 for nobody (by itself) */\n\tby: number[]\n\t/** Where the waiting part starts: what is before it is done */\n\thead: number\n}\n\n/** What names a cell's entry now (`FoliageRegrowth.index`): when it is due, and whether it is to stand whole then or start growing */\nconst keyOf = (due: number, grow: number): number => due * 2 + (grow < 0 ? 1 : 0)\n\n/** The cells of the pack's layers that wait to grow back, by layer (`RegrowQueue`) */\ntype RegrowState = Record<string, RegrowQueue>\n\n/**\n * Where a foliage pack keeps its regrowth (`FoliageRegrowth`), on the pack: for its world state's save to find\n *\n * @internal\n */\nexport const REGROWTH = Symbol('foliage regrowth')\n\n/** The regrowth of a world's game: none where it has no foliage pack */\nconst regrowthOf = (world: World): FoliageRegrowth | undefined =>\n\t(world.registry.assembly?.rules.packs?.find((pack) => REGROWTH in pack) as (GamePack & { [REGROWTH]: FoliageRegrowth }) | undefined)?.[REGROWTH]\n\n/**\n * What waits to grow back in a world (`RegrowState`): plain data, kept by a save as what is still to come, each list\n * from its waiting part\n *\n * @internal\n */\nexport const regrowState = /* @__PURE__ */ defineComponent<RegrowState>({\n\tid: 'foliage.regrow',\n\tdefault: () => ({}),\n\tsave: (state, world) => saved(state, regrowthOf(world))\n})\n\n/** A save's copy of what waits: each list from its waiting part, without what was passed over (given a new time since) */\nfunction saved(state: RegrowState, regrowth: FoliageRegrowth | undefined): RegrowState {\n\tconst copy: RegrowState = {}\n\tfor (const layer of Object.keys(state).sort()) {\n\t\tconst queue = state[layer]\n\t\tconst at = regrowth?.indexOf(queue)\n\t\tconst kept: RegrowQueue = { cells: [], due: [], grow: [], by: [], head: 0 }\n\t\tfor (let i = queue.head; i < queue.cells.length; i++) {\n\t\t\tif (at && at[queue.cells[i]] !== keyOf(queue.due[i], queue.grow[i])) continue\n\t\t\tkept.cells.push(queue.cells[i])\n\t\t\tkept.due.push(queue.due[i])\n\t\t\tkept.grow.push(queue.grow[i])\n\t\t\tkept.by.push(queue.by[i])\n\t\t}\n\t\tif (kept.cells.length) copy[layer] = kept\n\t}\n\treturn copy\n}\n\n/** What the pack tells its regrowth of itself: its layers, their state layers, its styles, and how to tell of what grew */\nexport interface RegrowthHost {\n\t/** The pack's layers, in order */\n\treadonly layers: readonly string[]\n\t/** Each layer's state layer */\n\treadonly states: readonly string[]\n\t/** The values of the state layer (`FOLIAGE_STATE`) */\n\treadonly state: typeof FOLIAGE_STATE\n\t/** What a style is to the rules (`foliageStyle`) */\n\tstyle(game: { cellLayers: readonly CellLayerDef[]; packs?: readonly GamePack[] }, layer: string, value: number): FoliageStyleDef | undefined\n\t/** Cells stood whole again (`foliageRegrown`), by whom where someone had them */\n\tregrown(world: World, layer: string, cells: number[], by: number): void\n}\n\n/** How each style of the pack's layers grows back, by layer and value, in ticks of a game */\ninterface RegrowStyles {\n\t/** The layers of cells it was worked out of */\n\tof: readonly CellLayerDef[]\n\t/** The length of a tick it was worked out for */\n\tdt: number\n\t/** By layer, by value: ticks after it is ruined that it starts to grow back by itself; -1 for never */\n\tafter: Int32Array[]\n\t/** By layer, by value: ticks it grows over once it starts by itself */\n\tgrows: Int32Array[]\n}\n\n/**\n * Grass growing back, the pack's: what each of its styles says of it, and what a tick and the calls do with a world's\n * `regrowState`. One a pack, for every world of its game: the cells' times now (`at`) are kept by the list they are of\n *\n * @internal\n */\nexport class FoliageRegrowth {\n\t/** The system that runs it */\n\treadonly system: System\n\t/** Each list's cells' entries now, by cell: the one still to come (`keyOf`), -1 for none */\n\tprivate readonly index = new WeakMap<RegrowQueue, Float64Array>()\n\tprivate styles: RegrowStyles | undefined\n\t/** Scratch of a tick: what grows whole, starts growing, and for how long, of a layer */\n\tprivate readonly whole: number[] = []\n\tprivate readonly wholeBy: number[] = []\n\tprivate readonly starting: number[] = []\n\tprivate readonly startingFor: number[] = []\n\n\tconstructor(private readonly host: RegrowthHost) {\n\t\tthis.system = {\n\t\t\tname: 'foliage.regrow',\n\t\t\tphase: 'resolve',\n\t\t\tupdate: (world) => {\n\t\t\t\t// nothing ever waited to grow back: nothing to look at\n\t\t\t\tif (!world.states.has(regrowState)) return\n\t\t\t\tthis.tick(world, world.state(regrowState))\n\t\t\t}\n\t\t}\n\t}\n\n\t/** Each cell's time now of a list (`index`): none where it was never asked for in this process (a save's, loaded) */\n\tindexOf(queue: RegrowQueue): Float64Array | undefined {\n\t\treturn this.index.get(queue)\n\t}\n\n\t/** How each style grows back, worked out once for a game's layers of cells and its tick */\n\tprivate stylesOf(world: World): RegrowStyles {\n\t\tconst { cellLayers } = world.registry\n\t\tif (this.styles?.of === cellLayers && this.styles.dt === world.dt) return this.styles\n\t\tconst game = { cellLayers, packs: world.registry.assembly?.rules.packs }\n\t\tconst styles: RegrowStyles = { of: cellLayers, dt: world.dt, after: [], grows: [] }\n\t\tfor (const layer of this.host.layers) {\n\t\t\tconst after = new Int32Array(256).fill(-1)\n\t\t\tconst grows = new Int32Array(256)\n\t\t\tfor (let value = 1; value < 256; value++) {\n\t\t\t\tconst style = this.host.style(game, layer, value)\n\t\t\t\tconst regrows = style?.regrows\n\t\t\t\tif (typeof regrows === 'number' && Number.isFinite(regrows)) after[value] = Math.max(1, Math.round(Math.max(0, regrows) / world.dt))\n\t\t\t\tgrows[value] = Math.max(0, Math.round(Math.max(0, style?.grows ?? GROWS) / world.dt))\n\t\t\t}\n\t\t\tstyles.after.push(after)\n\t\t\tstyles.grows.push(grows)\n\t\t}\n\t\treturn (this.styles = styles)\n\t}\n\n\t/** A layer's list of a world, made where it has none; and its cells' times now, worked out of it where they were not kept */\n\tprivate queueOf(world: World, l: number): { queue: RegrowQueue; at: Float64Array } {\n\t\tconst state = world.state(regrowState)\n\t\tconst layer = this.host.layers[l]\n\t\tconst queue = (state[layer] ??= { cells: [], due: [], grow: [], by: [], head: 0 })\n\t\tlet at = this.index.get(queue)\n\t\tif (!at) {\n\t\t\t// (a list of a save holds only what is still to come: one entry a cell)\n\t\t\tat = new Float64Array(world.terrain.width * world.terrain.depth).fill(-1)\n\t\t\tfor (let i = queue.head; i < queue.cells.length; i++) at[queue.cells[i]] = keyOf(queue.due[i], queue.grow[i])\n\t\t\tthis.index.set(queue, at)\n\t\t}\n\t\treturn { queue, at }\n\t}\n\n\t/**\n\t * Cells of a layer were ruined or burnt (in order of their indices): each to grow back by itself where its style\n\t * says (`regrows`), and nothing it waited for before; never where its style does not\n\t */\n\truined(world: World, l: number, cells: readonly number[]): void {\n\t\tif (!cells.length) return\n\t\tconst { after, grows } = this.stylesOf(world)\n\t\tconst values = world.terrain.cells[this.host.layers[l]]\n\t\tconst waits = after[l]\n\t\t// nothing to wait for: no list made, and what waited in one waits no more\n\t\tlet any = false\n\t\tfor (let i = 0; i < cells.length && !any; i++) any = waits[values?.[cells[i]] ?? 0] >= 0\n\t\tif (!any) {\n\t\t\tif (!world.states.has(regrowState) || !world.state(regrowState)[this.host.layers[l]]) return\n\t\t\tconst { at } = this.queueOf(world, l)\n\t\t\tfor (const cell of cells) at[cell] = -1\n\t\t\treturn\n\t\t}\n\t\tconst { queue, at } = this.queueOf(world, l)\n\t\tconst add: { cell: number; due: number; grow: number }[] = []\n\t\tfor (const cell of cells) {\n\t\t\tconst value = values?.[cell] ?? 0\n\t\t\tconst wait = waits[value]\n\t\t\tif (wait < 0) {\n\t\t\t\tat[cell] = -1\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\tadd.push({ cell, due: world.tick + wait, grow: grows[l][value] })\n\t\t}\n\t\tthis.add(\n\t\t\tqueue,\n\t\t\tat,\n\t\t\tadd.map((each) => each.cell),\n\t\t\tadd.map((each) => each.due),\n\t\t\tadd.map((each) => each.grow),\n\t\t\tundefined\n\t\t)\n\t}\n\n\t/**\n\t * Has cells of a layer grow back (`regrow`): those ruined or burnt, and those growing where it is at once. Over\n\t * `over` ticks (growing, whole at its end), or at once (0). The cells that started to, in order\n\t */\n\tregrow(world: World, l: number, cells: readonly number[], over: number, by: number): number[] {\n\t\tconst { state } = this.host\n\t\tconst terrain = world.terrain\n\t\tconst values = terrain.cells[this.host.layers[l]]\n\t\tconst states = terrain.cells[this.host.states[l]]\n\t\tconst now = over <= 0\n\t\tconst which = cells.filter((cell) => {\n\t\t\tif (!values?.[cell]) return false\n\t\t\tconst was = states?.[cell] ?? state.whole\n\t\t\treturn was === state.flattened || was === state.cut || was === state.burnt || (now && was === state.growing)\n\t\t})\n\t\tif (!which.length) return which\n\t\tconst layer = this.host.layers[l]\n\t\tif (now) {\n\t\t\tworld.setCells(this.host.states[l], which, state.whole)\n\t\t\t// nothing waits for them any more\n\t\t\tif (world.states.has(regrowState) && world.state(regrowState)[layer]) {\n\t\t\t\tconst { at } = this.queueOf(world, l)\n\t\t\t\tfor (const cell of which) at[cell] = -1\n\t\t\t}\n\t\t\tthis.host.regrown(world, layer, which, by)\n\t\t\treturn which\n\t\t}\n\t\tworld.setCells(this.host.states[l], which, state.growing, { over: over * world.dt })\n\t\tconst { queue, at } = this.queueOf(world, l)\n\t\tthis.add(\n\t\t\tqueue,\n\t\t\tat,\n\t\t\twhich,\n\t\t\twhich.map(() => world.tick + over),\n\t\t\twhich.map(() => -1),\n\t\t\tby\n\t\t)\n\t\treturn which\n\t}\n\n\t/**\n\t * Entries into a list, in its order (by when due, then by cell): merged in from the end, so that what comes after\n\t * all that waits (as most does) costs only its own room. Each cell's time now is the one given; one given twice is\n\t * there once (as a cell given the same entry again)\n\t */\n\tprivate add(\n\t\tqueue: RegrowQueue,\n\t\tat: Float64Array,\n\t\tcells: readonly number[],\n\t\tdue: readonly number[],\n\t\tgrow: readonly number[],\n\t\tby: number | undefined\n\t): void {\n\t\tif (!cells.length) return\n\t\tconst order = cells.map((_, k) => k)\n\t\torder.sort((a, b) => due[a] - due[b] || cells[a] - cells[b])\n\t\tconst fresh: number[] = []\n\t\tfor (const k of order) {\n\t\t\tconst key = keyOf(due[k], grow[k])\n\t\t\tif (at[cells[k]] === key) continue\n\t\t\tat[cells[k]] = key\n\t\t\tfresh.push(k)\n\t\t}\n\t\tif (!fresh.length) return\n\t\tthis.compact(queue)\n\t\tlet i = queue.cells.length - 1\n\t\tlet j = fresh.length - 1\n\t\tfor (let k = 0; k < fresh.length; k++) {\n\t\t\tqueue.cells.push(0)\n\t\t\tqueue.due.push(0)\n\t\t\tqueue.grow.push(0)\n\t\t\tqueue.by.push(0)\n\t\t}\n\t\tfor (let w = queue.cells.length - 1; j >= 0; w--) {\n\t\t\tconst k = fresh[j]\n\t\t\tif (i >= queue.head && (queue.due[i] > due[k] || (queue.due[i] === due[k] && queue.cells[i] > cells[k]))) {\n\t\t\t\tqueue.cells[w] = queue.cells[i]\n\t\t\t\tqueue.due[w] = queue.due[i]\n\t\t\t\tqueue.grow[w] = queue.grow[i]\n\t\t\t\tqueue.by[w] = queue.by[i]\n\t\t\t\ti--\n\t\t\t} else {\n\t\t\t\tqueue.cells[w] = cells[k]\n\t\t\t\tqueue.due[w] = due[k]\n\t\t\t\tqueue.grow[w] = grow[k]\n\t\t\t\tqueue.by[w] = by ?? 0\n\t\t\t\tj--\n\t\t\t}\n\t\t}\n\t}\n\n\t/** A list cut back to its waiting part, where much of it is done */\n\tprivate compact(queue: RegrowQueue): void {\n\t\tconst { head } = queue\n\t\tif (head < COMPACT_AT || head * 2 < queue.cells.length) return\n\t\tqueue.cells.splice(0, head)\n\t\tqueue.due.splice(0, head)\n\t\tqueue.grow.splice(0, head)\n\t\tqueue.by.splice(0, head)\n\t\tqueue.head = 0\n\t}\n\n\t/**\n\t * A tick: of each layer's list, the cells due by now, at most `REGROW_A_TICK`, in their order: those whose time it\n\t * still is (not given another since, still ruined or growing, still grass) start growing (one `setCells` for each\n\t * length of growing) or stand whole (one `setCells`, told by whom)\n\t */\n\tprivate tick(world: World, state: RegrowState): void {\n\t\tconst { tick } = world\n\t\tconst { layers } = this.host\n\t\tfor (let l = 0; l < layers.length; l++) {\n\t\t\tconst queue = state[layers[l]]\n\t\t\tif (!queue || queue.head >= queue.cells.length || queue.due[queue.head] > tick) continue\n\t\t\tthis.layerTick(world, l, queue)\n\t\t}\n\t}\n\n\t/** A tick of a layer's list that has cells due (`tick`) */\n\tprivate layerTick(world: World, l: number, queue: RegrowQueue): void {\n\t\tconst { state, layers, states } = this.host\n\t\tconst { tick, terrain } = world\n\t\tconst { at } = this.queueOf(world, l)\n\t\tconst values = terrain.cells[layers[l]]\n\t\tconst kept = terrain.cells[states[l]]\n\t\tconst { whole, wholeBy, starting, startingFor } = this\n\t\twhole.length = wholeBy.length = starting.length = startingFor.length = 0\n\t\tlet done = 0\n\t\tlet i = queue.head\n\t\tfor (; i < queue.cells.length && queue.due[i] <= tick && done < REGROW_A_TICK; i++) {\n\t\t\tconst cell = queue.cells[i]\n\t\t\tif (at[cell] !== keyOf(queue.due[i], queue.grow[i])) continue\n\t\t\tat[cell] = -1\n\t\t\tconst was = kept?.[cell] ?? state.whole\n\t\t\tif (!values?.[cell]) continue\n\t\t\tconst grow = queue.grow[i]\n\t\t\tif (grow < 0) {\n\t\t\t\tif (was !== state.growing) continue\n\t\t\t\twhole.push(cell)\n\t\t\t\twholeBy.push(queue.by[i])\n\t\t\t} else {\n\t\t\t\tif (was !== state.flattened && was !== state.cut && was !== state.burnt) continue\n\t\t\t\tif (grow === 0) {\n\t\t\t\t\twhole.push(cell)\n\t\t\t\t\twholeBy.push(0)\n\t\t\t\t} else {\n\t\t\t\t\tstarting.push(cell)\n\t\t\t\t\tstartingFor.push(grow)\n\t\t\t\t}\n\t\t\t}\n\t\t\tdone++\n\t\t}\n\t\tqueue.head = i\n\t\tif (queue.head >= queue.cells.length) {\n\t\t\tqueue.cells.length = queue.due.length = queue.grow.length = queue.by.length = 0\n\t\t\tqueue.head = 0\n\t\t} else this.compact(queue)\n\t\tconst layer = layers[l]\n\t\tif (whole.length) {\n\t\t\tworld.setCells(states[l], whole, state.whole)\n\t\t\t// told by whom: one event for each who had them, in the order they come first\n\t\t\tconst first = wholeBy[0]\n\t\t\tif (wholeBy.every((by) => by === first)) this.host.regrown(world, layer, [...whole], first)\n\t\t\telse\n\t\t\t\tfor (const by of [...new Set(wholeBy)]) {\n\t\t\t\t\tconst cells = whole.filter((_, k) => wholeBy[k] === by)\n\t\t\t\t\tthis.host.regrown(world, layer, cells, by)\n\t\t\t\t}\n\t\t}\n\t\tif (starting.length) {\n\t\t\t// growing, each length of it apart: the screens are told how long each takes\n\t\t\tconst lengths = [...new Set(startingFor)]\n\t\t\tfor (const length of lengths) {\n\t\t\t\tconst cells = lengths.length === 1 ? starting : starting.filter((_, k) => startingFor[k] === length)\n\t\t\t\tworld.setCells(states[l], cells, state.growing, { over: length * world.dt })\n\t\t\t\tconst { queue: now, at: times } = this.queueOf(world, l)\n\t\t\t\tthis.add(\n\t\t\t\t\tnow,\n\t\t\t\t\ttimes,\n\t\t\t\t\tcells,\n\t\t\t\t\tcells.map(() => tick + length),\n\t\t\t\t\tcells.map(() => -1),\n\t\t\t\t\tundefined\n\t\t\t\t)\n\t\t\t}\n\t\t}\n\t}\n}\n"],"mappings":"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"}

package/dist/formState.d.ts

@@ -0,0 +1,67 @@
+import type { FormCooldowns, MorphBack } from './defs';
+import type { AbilityState, Entity } from './entity';
+/**
+ * A hero in one of its forms (`form`, `takeForm`): what it was, what turns it back, what it learns in the form and
+ * what of its own it put away meanwhile
+ *
+ * @beta
+ */
+export interface Form {
+    /** The unit type it was, and turns back into */
+    from: string;
+    /** The ability that made it, whose cast in the form turns it back (with `ability` in `back`) */
+    by?: string;
+    /** The game's time, in seconds, it took the form */
+    at: number;
+    /** The game's time it turns back at, for a form that lasts a while (`back` has `time`) */
+    until?: number;
+    /** What turns it back */
+    back: MorphBack[];
+    /** What it learns in the form, in order: what the HUD's card and hero panel show, and what its points go into */
+    learns: string[];
+    /**
+     * Of what it learns in the form, those whose level is that of one of its own (`HeroForm.levels`), by id: a point put
+     * into one in the form goes to its own too
+     */
+    linked?: Record<string, string>;
+    /** What becomes of the cooldowns of what is put away and what is brought (`HeroForm.cooldowns`): run down by the time away when left out */
+    cooldowns?: FormCooldowns;
+    /** What it could cast as itself and cannot in the form, as it was: given back as it turns back, their cooldowns run down meanwhile */
+    kept: AbilityState[];
+    /** What it could cast as itself, by id, in its order */
+    own: string[];
+}
+/**
+ * What every player who sees a hero in a form is told of it (`form`)
+ *
+ * @beta
+ */
+export interface FormSent {
+    /** The unit type it is as itself */
+    from: string;
+    /** The ability that made it */
+    by?: string;
+    /** The game's time it turns back at, for a form that lasts a while */
+    until?: number;
+    /** What it learns in the form, in order */
+    learns: string[];
+}
+/**
+ * On a hero in one of its forms: see `Form`. Saved with it, told to everyone who sees it, and filed in the world's index
+ *
+ * @beta
+ */
+export declare const form: import("./components").Component<Form, FormSent>;
+/**
+ * The form a hero is in, none when it is itself (`form`)
+ *
+ * @beta
+ */
+export declare const formOf: (entity: Entity) => Form | undefined;
+/**
+ * What a hero learns, in order: what its form says while it is in one (`takeForm`), its type's (`HeroDef.learns`)
+ * otherwise. Nothing for what is no hero
+ *
+ * @beta
+ */
+export declare function learnsOf(entity: Entity): readonly string[];

package/dist/formState.js

@@ -0,0 +1,65 @@
+import { defineComponent } from "./components.js";
+//#region src/formState.ts
+/**
+* What a hero in one of its forms carries (E2E-PLAN LB2): the `form` component, and what it learns there. Apart from
+* `forms.ts`, which turns it into the form and back, so that what reads it (the heroes' learning) loads nothing of morphing
+*/
+/**
+* On a hero in one of its forms: see `Form`. Saved with it, told to everyone who sees it, and filed in the world's index
+*
+* @beta
+*/
+var form = defineComponent({
+	id: "core.form",
+	replicate: "everyone",
+	index: true,
+	snapshot: ({ from, by, until, learns }) => ({
+		from,
+		by,
+		until,
+		learns
+	}),
+	same: (a, b) => a.from === b.from && a.by === b.by && a.until === b.until && a.learns.join() === b.learns.join(),
+	refs: (saved) => {
+		const value = saved;
+		return {
+			units: [value.from],
+			abilities: [
+				...value.learns,
+				...value.own,
+				...Object.values(value.linked ?? {})
+			]
+		};
+	}
+});
+/**
+* The form a hero is in, none when it is itself (`form`)
+*
+* @beta
+*/
+var formOf = (entity) => entity.get(form);
+/**
+* What a hero learns, in order: what its form says while it is in one (`takeForm`), its type's (`HeroDef.learns`)
+* otherwise. Nothing for what is no hero
+*
+* @beta
+*/
+function learnsOf(entity) {
+	return entity.get(form)?.learns ?? entity.def.hero?.learns ?? [];
+}
+/**
+* A point put into an ability in a form goes to the hero's own whose level it has too (`Form.linked`), so that it has
+* it as itself. Called by `learn`
+*
+* @internal
+*/
+function learnedInForm(entity, ability) {
+	const own = entity.get(form)?.linked?.[ability];
+	if (!own || own === ability) return;
+	const kept = entity.get(form).kept.find((kept) => kept.id === own);
+	if (kept) kept.level++;
+}
+//#endregion
+export { form, formOf, learnedInForm, learnsOf };
+
+//# sourceMappingURL=formState.js.map

package/dist/formState.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"formState.js","names":[],"sources":["../src/formState.ts"],"sourcesContent":["/**\n * What a hero in one of its forms carries (E2E-PLAN LB2): the `form` component, and what it learns there. Apart from\n * `forms.ts`, which turns it into the form and back, so that what reads it (the heroes' learning) loads nothing of morphing\n */\nimport { defineComponent } from './components'\nimport type { FormCooldowns, MorphBack } from './defs'\nimport type { AbilityState, Entity } from './entity'\n\n/**\n * A hero in one of its forms (`form`, `takeForm`): what it was, what turns it back, what it learns in the form and\n * what of its own it put away meanwhile\n *\n * @beta\n */\nexport interface Form {\n\t/** The unit type it was, and turns back into */\n\tfrom: string\n\t/** The ability that made it, whose cast in the form turns it back (with `ability` in `back`) */\n\tby?: string\n\t/** The game's time, in seconds, it took the form */\n\tat: number\n\t/** The game's time it turns back at, for a form that lasts a while (`back` has `time`) */\n\tuntil?: number\n\t/** What turns it back */\n\tback: MorphBack[]\n\t/** What it learns in the form, in order: what the HUD's card and hero panel show, and what its points go into */\n\tlearns: string[]\n\t/**\n\t * Of what it learns in the form, those whose level is that of one of its own (`HeroForm.levels`), by id: a point put\n\t * into one in the form goes to its own too\n\t */\n\tlinked?: Record<string, string>\n\t/** What becomes of the cooldowns of what is put away and what is brought (`HeroForm.cooldowns`): run down by the time away when left out */\n\tcooldowns?: FormCooldowns\n\t/** What it could cast as itself and cannot in the form, as it was: given back as it turns back, their cooldowns run down meanwhile */\n\tkept: AbilityState[]\n\t/** What it could cast as itself, by id, in its order */\n\town: string[]\n}\n\n/**\n * What every player who sees a hero in a form is told of it (`form`)\n *\n * @beta\n */\nexport interface FormSent {\n\t/** The unit type it is as itself */\n\tfrom: string\n\t/** The ability that made it */\n\tby?: string\n\t/** The game's time it turns back at, for a form that lasts a while */\n\tuntil?: number\n\t/** What it learns in the form, in order */\n\tlearns: string[]\n}\n\n/**\n * On a hero in one of its forms: see `Form`. Saved with it, told to everyone who sees it, and filed in the world's index\n *\n * @beta\n */\nexport const form = defineComponent<Form, FormSent>({ id: 'core.form', replicate: 'everyone',\n\tindex: true,\n\tsnapshot: ({ from, by, until, learns }) => ({ from, by, until, learns }),\n\tsame: (a, b) => a.from === b.from && a.by === b.by && a.until === b.until && a.learns.join() === b.learns.join(),\n\trefs: (saved) => {\n\t\tconst value = saved as Form\n\t\treturn { units: [value.from], abilities: [...value.learns, ...value.own, ...Object.values(value.linked ?? {})] }\n\t} })\n\n/**\n * The form a hero is in, none when it is itself (`form`)\n *\n * @beta\n */\nexport const formOf = (entity: Entity): Form | undefined => entity.get(form)\n\n/**\n * What a hero learns, in order: what its form says while it is in one (`takeForm`), its type's (`HeroDef.learns`)\n * otherwise. Nothing for what is no hero\n *\n * @beta\n */\nexport function learnsOf(entity: Entity): readonly string[] {\n\treturn entity.get(form)?.learns ?? entity.def.hero?.learns ?? []\n}\n\n/**\n * A point put into an ability in a form goes to the hero's own whose level it has too (`Form.linked`), so that it has\n * it as itself. Called by `learn`\n *\n * @internal\n */\nexport function learnedInForm(entity: Entity, ability: string): void {\n\tconst own = entity.get(form)?.linked?.[ability]\n\tif (!own || own === ability) return\n\tconst kept = entity.get(form)!.kept.find((kept) => kept.id === own)\n\tif (kept) kept.level++\n}\n"],"mappings":";;;;;;;;;;;AA6DA,IAAa,OAAO,gBAAgC;CAAE,IAAI;CAAa,WAAW;CACjF,OAAO;CACP,WAAW,EAAE,MAAM,IAAI,OAAO,cAAc;EAAE;EAAM;EAAI;EAAO;CAAO;CACtE,OAAO,GAAG,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,SAAS,EAAE,OAAO,KAAK,MAAM,EAAE,OAAO,KAAK;CAC/G,OAAO,UAAU;EAChB,MAAM,QAAQ;EACd,OAAO;GAAE,OAAO,CAAC,MAAM,IAAI;GAAG,WAAW;IAAC,GAAG,MAAM;IAAQ,GAAG,MAAM;IAAK,GAAG,OAAO,OAAO,MAAM,UAAU,CAAC,CAAC;GAAC;EAAE;CAChH;AAAE,CAAC;;;;;;AAOJ,IAAa,UAAU,WAAqC,OAAO,IAAI,IAAI;;;;;;;AAQ3E,SAAgB,SAAS,QAAmC;CAC3D,OAAO,OAAO,IAAI,IAAI,CAAC,EAAE,UAAU,OAAO,IAAI,MAAM,UAAU,CAAC;AAChE;;;;;;;AAQA,SAAgB,cAAc,QAAgB,SAAuB;CACpE,MAAM,MAAM,OAAO,IAAI,IAAI,CAAC,EAAE,SAAS;CACvC,IAAI,CAAC,OAAO,QAAQ,SAAS;CAC7B,MAAM,OAAO,OAAO,IAAI,IAAI,CAAC,CAAE,KAAK,MAAM,SAAS,KAAK,OAAO,GAAG;CAClE,IAAI,MAAM,KAAK;AAChB"}

package/dist/formation.d.ts

@@ -1,6 +1,7 @@
 import type { Entity, EntityId } from './entity';
 import type { Vec2 } from './math';
 import type { Navigation } from './navigation/navigation';
+import type { Registry } from './registry';
 import type { World } from './world';
 /**
  * What a formation lays units out with: the group, where it is sent, the way there, and the room each unit takes.
@@ -10,9 +11,11 @@ import type { World } from './world';
  * @beta
  */
 export interface FormationContext {
+    /** The world the formation is laid out in */
     readonly world: World;
     /** The units laid out: those that walk, or those that fly, apart */
     readonly units: readonly Entity[];
+    /** Where the units are sent */
     readonly target: Vec2;
     /** The navigation they go on, to find where they can stand */
     readonly nav: Navigation;
@@ -22,6 +25,11 @@ export interface FormationContext {
     readonly forward: Vec2;
     /** To the right of `forward`, a unit long */
     readonly right: Vec2;
+    /**
+     * Whether the player turned the formation by hand (a right-click dragged: `OrderInit.facing`): `forward` is then
+     * the way they dragged, not the way of travel, and a formation that keeps a group's own shape lays it out anew
+     */
+    readonly turned: boolean;
     /** Room a unit takes: twice the biggest radius among them, and a gap of `FORMATION_GAP` */
     readonly spacing: number;
     /** A point in the world, `x` to the right of the target and `z` forward of it */
@@ -30,14 +38,15 @@ export interface FormationContext {
     snap(point: Vec2): Vec2;
 }
 /**
- * How units ordered to a point together are laid out around it (`OrderInit.formation`, `GameRules.movement.formation`): a
+ * How units ordered to a point together are laid out around it (`OrderInit.formation`, `RuleSettings.movement.formation`): a
  * shape, which the engine fits the units to, or the places themselves. The engine's own are `rows`, `circle`,
- * `square` and `none` (`coreFormations`); a game adds its own (`GameModule.formations`), and changes any laid out
+ * `square` and `none` (`coreFormations`); a game adds its own (`Rules.formations`), and changes any laid out
  * with the `formation` hook
  *
  * @beta
  */
 export interface FormationDef {
+    /** The formation's id, which an order names it by */
     id: string;
     /** What the player sees it called */
     name: string;
@@ -76,15 +85,15 @@ export declare function fitToPlaces(context: FormationContext, places: readonly
 export declare const rowsFormation: FormationDef;
 /**
  * A circle: a ring around the target, the first place at the front, and rings within it where one is not enough for
- * them all. The rings are a `spacing` apart, the first a `spacing` out: as many as it takes, the outer ones full
+ * them all, a `spacing` apart, down to the middle. As few rings as hold them, and the units shared out among them as
+ * their room goes: a disc as thick everywhere, every ring's places even, the outer ring first
  *
  * @beta
  */
 export declare const circleFormation: FormationDef;
 /**
- * A square: units along the edges of one around the target, the first place at the front's middle, and squares
- * within it where one is not enough for them all. The squares are a `spacing` apart, the first a `spacing` out: as
- * many as it takes, the outer ones full
+ * A square: a block of rows a `spacing` apart, as many across as deep (one row fewer where that holds them), filled to
+ * the middle, the front row first. Where they do not fill the last row, the back one, those in it stand in its middle
  *
  * @beta
  */
@@ -104,8 +113,37 @@ export declare const coreFormations: readonly FormationDef[];
 /**
  * Individual destinations for a group ordered to the same point, in a formation (`rowsFormation` when none is
  * given), and what the `formation` hook makes of them. Units that walk and units that fly are laid out apart, each
- * on their own navigation (`world.navFor`)
+ * on their own navigation (`world.navFor`). `facing`, where the player turned the formation by hand, is the way it
+ * faces (a direction as an entity's `facing` is), over the way of travel
+ *
+ * @beta
+ */
+export declare function formationPoints(world: World, units: readonly Entity[], target: Vec2, formation?: FormationDef, facing?: number): Map<EntityId, Vec2>;
+/**
+ * A unit as a preview of a formation knows it: where it stands and how big it is
  *
  * @beta
  */
-export declare function formationPoints(world: World, units: readonly Entity[], target: Vec2, formation?: FormationDef): Map<EntityId, Vec2>;
+export interface FormationUnit {
+    /** The unit's entity id */
+    readonly id: EntityId;
+    /** Where it stands, in cells */
+    readonly pos: Vec2;
+    /** Its collision radius, in cells */
+    readonly radius: number;
+}
+/**
+ * Where a group would stand if sent to a target in a formation (by id, `rows` when unknown), from what a player's
+ * screen knows of the units: what the ghosts of a right-click dragged are drawn from (`GameSession.formationPlaces`).
+ * The same shapes as `formationPoints` gives, units that walk and units that fly each on their own navigation; the
+ * `formation` hook (the simulation's) and a formation that reads `FormationContext.world` take no part, and the order
+ * itself lays the group out as it will
+ *
+ * @beta
+ */
+export declare function formationPreview(registry: Registry, units: readonly (FormationUnit & {
+    readonly flying?: boolean;
+})[], target: Vec2, navs: {
+    readonly nav: Navigation;
+    readonly air: Navigation;
+}, id: string, facing?: number): Map<EntityId, Vec2>;