@v12-engine/engine 0.1.0 → 0.4.0

package/dist/fog.js

@@ -0,0 +1,333 @@
+import { clamp } from "./math.js";
+import { packBytes, unpackBytes } from "./bytes.js";
+//#region src/fog.ts
+/**
+* The state of a cell the team has not seen yet
+*
+* @internal
+*/
+var FOG_UNEXPLORED = 0;
+/**
+* The state of a cell the team has seen but does not see now
+*
+* @internal
+*/
+var FOG_EXPLORED = 1;
+/**
+* The state of a cell the team sees now
+*
+* @internal
+*/
+var FOG_VISIBLE = 2;
+/**
+* Bit positions are 0..31: JavaScript bitwise operators work on 32 bit integers
+*
+* @internal
+*/
+var MAX_FOG_TEAMS = 32;
+/** Whether the middle of a cell of a row is in a circle: `across` is the square of how far the row's middle is from the circle's */
+var inside = (cx, x, across, r2) => (cx + .5 - x) * (cx + .5 - x) + across <= r2;
+/**
+* What each team sees and has seen of the map, by cell, and the bit each team has in `Entity.seenBy`
+*
+* @beta
+*/
+var FogOfWar = class {
+	width;
+	depth;
+	visible = /* @__PURE__ */ new Map();
+	explored = /* @__PURE__ */ new Map();
+	revealed = /* @__PURE__ */ new Set();
+	/**
+	* One bit per team, for per-entity bitmasks like `Entity.seenBy`. Team ids come from the map and can be
+	* any number (the creeps are team 1000), so they are numbered 0, 1, 2... here instead of being used as
+	* bit positions directly: `1 << 1000` is `1 << 8` in JavaScript and would mix up two teams.
+	*/
+	bits = /* @__PURE__ */ new Map();
+	levels;
+	/**
+	* What is being lit during an update (`beginUpdate`), a bit a cell, a row of the map `words` of 32 bits: a row of a
+	* circle is a word or two, not hundreds of cells. Written into the grids as the update ends
+	*/
+	lit = /* @__PURE__ */ new Map();
+	words;
+	updating = false;
+	/**
+	* Whether `lit` holds what each team sees now, as the grids do: from the end of an update until the grids are written
+	* otherwise (a reveal outside an update, a save taken back)
+	*/
+	litIsSight = false;
+	/** The cells at or under each level, as bits: what a viewer on that level sees of what it lights. Made as they are first asked for */
+	levelMasks = /* @__PURE__ */ new Map();
+	/** The highest level of the ground: a viewer on it or above sees everything it lights. -1 until worked out */
+	top = -1;
+	/** Bumped every time visibility is recomputed */
+	version = 0;
+	constructor(width, depth, teams, levels) {
+		this.width = width;
+		this.depth = depth;
+		this.levels = levels ?? new Uint8Array(width * depth);
+		this.words = Math.ceil(width / 32);
+		if (teams.length > 32) throw new Error(`Fog of war supports at most 32 teams, got ${teams.length}`);
+		for (const team of teams) this.makeTeam(team);
+	}
+	/** Gives a team that has none yet fog of its own: a player moved to a new team mid-game. Nothing for one there is */
+	addTeam(team) {
+		if (this.visible.has(team)) return;
+		this.makeTeam(team);
+		this.version++;
+	}
+	/**
+	* Whether the whole map is explored from the start (`FogSettings.startExplored`, `MapDef.explored`): every team's, and
+	* the teams' made from now on. What stands on it and is no player's is then known to every team from the first moment
+	* (the sessions' `TeamMemory.startKnown`). Set with `exploreFromStart`
+	*/
+	exploredFromStart = false;
+	/** Grids for a team, and the first bit no other team has */
+	makeTeam(team, bit = this.freeBit()) {
+		this.visible.set(team, new Uint8Array(this.width * this.depth));
+		this.explored.set(team, new Uint8Array(this.width * this.depth).fill(this.exploredFromStart ? 1 : 0));
+		this.bits.set(team, bit);
+		this.lit.set(team, new Uint32Array(this.words * this.depth));
+	}
+	freeBit() {
+		const taken = new Set(this.bits.values());
+		for (let place = 0; place < 32; place++) if (!taken.has(1 << place)) return 1 << place;
+		throw new Error(`Fog of war supports at most 32 teams`);
+	}
+	/** The team's bit in per-entity team masks. 0 for a team without fog (neutral), which then never shows up in one */
+	/** What each team sees and has explored, for a save, with each team's bit */
+	save() {
+		const save = {
+			version: this.version,
+			revealed: [...this.revealed],
+			teams: {},
+			bits: Object.fromEntries(this.bits),
+			...this.exploredFromStart && { exploredFromStart: true }
+		};
+		for (const team of this.teams) save.teams[team] = {
+			visible: packBytes(this.visible.get(team)),
+			explored: packBytes(this.explored.get(team))
+		};
+		return save;
+	}
+	/** Takes the fog back from a save, teams and revealed ones too; throws when a team's cells are missing or of another size */
+	restore(save) {
+		const cells = this.width * this.depth;
+		if (save.bits) {
+			for (const team of this.teams) {
+				this.visible.delete(team);
+				this.explored.delete(team);
+				this.lit.delete(team);
+			}
+			this.bits.clear();
+			for (const [team, bit] of Object.entries(save.bits)) this.makeTeam(Number(team), bit);
+		}
+		for (const team of this.teams) {
+			const saved = save.teams[team];
+			const visible = saved && unpackBytes(saved.visible, cells);
+			const explored = saved && unpackBytes(saved.explored, cells);
+			if (!visible || !explored) throw new Error(`Save: the fog of team ${team} is missing or not the size of the map`);
+			this.visible.get(team).set(visible);
+			this.explored.get(team).set(explored);
+		}
+		this.litIsSight = false;
+		this.revealed.clear();
+		for (const team of save.revealed) this.revealed.add(team);
+		this.exploredFromStart = !!save.exploredFromStart;
+		this.version = save.version;
+	}
+	/** The bit a team has in per-entity bitmasks such as `Entity.seenBy`; 0 for a team that is not known */
+	teamBit(team) {
+		return this.bits.get(team) ?? 0;
+	}
+	/** The teams the fog holds cells for */
+	get teams() {
+		return [...this.visible.keys()];
+	}
+	/** Debug switch: the team sees everything */
+	setRevealed(team, revealed) {
+		if (revealed) this.revealed.add(team);
+		else this.revealed.delete(team);
+		this.version++;
+	}
+	/** Whether the team is shown everything (`setRevealed`) */
+	isRevealed(team) {
+		return this.revealed.has(team);
+	}
+	/**
+	* Starts working out what is seen: what is lit from here to `endUpdate` is collected as bits, and the grids
+	* are written when it ends, so `visible` and `explored` say what they did before until then
+	*/
+	beginUpdate() {
+		this.updating = true;
+		this.litIsSight = false;
+		for (const bits of this.lit.values()) bits.fill(0);
+	}
+	/** Ends the update begun by `beginUpdate`: writes what was lit into the grids, so that visibility changes at once */
+	endUpdate() {
+		this.updating = false;
+		const { width, depth, words } = this;
+		for (const [team, bits] of this.lit) {
+			const visible = this.visible.get(team);
+			const explored = this.explored.get(team);
+			visible.fill(0);
+			for (let cz = 0; cz < depth; cz++) for (let w = 0; w < words; w++) {
+				let word = bits[cz * words + w];
+				if (word === 0) continue;
+				const row = cz * width + w * 32;
+				if (word === 4294967295) {
+					for (let i = row; i < row + 32; i++) {
+						visible[i] = 1;
+						explored[i] = 1;
+					}
+					continue;
+				}
+				while (word !== 0) {
+					const low = word & -word;
+					const i = row + 31 - Math.clz32(low);
+					visible[i] = 1;
+					explored[i] = 1;
+					word ^= low;
+				}
+			}
+		}
+		this.litIsSight = true;
+		this.version++;
+	}
+	/**
+	* What a team sees now as bits, a bit a cell, the lowest first: a row of the map `ceil(width / 32)` words, each row
+	* starting a word. As the last update (`endUpdate`) worked it out: undefined where the grids were written otherwise
+	* since (a reveal outside an update, a save taken back), or the team has no fog. Read, never written to
+	*
+	* @internal
+	*/
+	sightBits(team) {
+		return this.litIsSight ? this.lit.get(team) : void 0;
+	}
+	/**
+	* Says the ground's levels changed (`Terrain.levels` written to while the world runs): what a viewer on a level sees
+	* is worked out from them once, and again after this
+	*
+	* @beta
+	*/
+	levelsChanged() {
+		this.levelMasks.clear();
+		this.top = -1;
+	}
+	highest() {
+		if (this.top < 0) {
+			let top = 0;
+			for (const level of this.levels) if (level > top) top = level;
+			this.top = top;
+		}
+		return this.top;
+	}
+	maskOf(level) {
+		let mask = this.levelMasks.get(level);
+		if (!mask) {
+			const { width, depth, words, levels } = this;
+			mask = new Uint32Array(words * depth);
+			for (let cz = 0; cz < depth; cz++) for (let cx = 0; cx < width; cx++) if (levels[cz * width + cx] <= level) mask[cz * words + (cx >> 5)] |= 1 << (cx & 31);
+			this.levelMasks.set(level, mask);
+		}
+		return mask;
+	}
+	/** Lights up what a viewer at the point sees. Ground above the viewer's `level` stays dark, so a flyer passes Infinity */
+	reveal(team, x, z, radius, level = Infinity) {
+		const visible = this.visible.get(team);
+		const explored = this.explored.get(team);
+		if (!visible || !explored) return;
+		const { width, depth, words } = this;
+		const minZ = clamp(Math.floor(z - radius), 0, depth - 1);
+		const maxZ = clamp(Math.ceil(z + radius), 0, depth - 1);
+		const r2 = radius * radius;
+		const bits = this.updating ? this.lit.get(team) : null;
+		const mask = bits && level < this.highest() ? this.maskOf(level) : null;
+		for (let cz = minZ; cz <= maxZ; cz++) {
+			const dz = cz + .5 - z;
+			const across = dz * dz;
+			if (across > r2) continue;
+			const half = Math.sqrt(r2 - across);
+			let from = Math.max(Math.ceil(x - half - .5), 0);
+			let to = Math.min(Math.floor(x + half - .5), width - 1);
+			while (from <= to && !inside(from, x, across, r2)) from++;
+			while (to >= from && !inside(to, x, across, r2)) to--;
+			while (from > 0 && inside(from - 1, x, across, r2)) from--;
+			while (to < width - 1 && inside(to + 1, x, across, r2)) to++;
+			if (to < from) continue;
+			if (!bits) {
+				const { levels } = this;
+				for (let cx = from; cx <= to; cx++) {
+					const i = cz * width + cx;
+					if (levels[i] > level) continue;
+					visible[i] = 1;
+					explored[i] = 1;
+				}
+				continue;
+			}
+			const first = from >> 5;
+			const last = to >> 5;
+			const row = cz * words;
+			const head = -1 << (from & 31);
+			const tail = -1 >>> 31 - (to & 31);
+			if (first === last) bits[row + first] |= mask ? head & tail & mask[row + first] : head & tail;
+			else {
+				bits[row + first] |= mask ? head & mask[row + first] : head;
+				for (let w = first + 1; w < last; w++) bits[row + w] |= mask ? mask[row + w] : -1;
+				bits[row + last] |= mask ? tail & mask[row + last] : tail;
+			}
+		}
+	}
+	/** The state of the cell at (x, z) for the team: `FOG_VISIBLE` when it is revealed, else visible, explored or unexplored */
+	stateAt(team, x, z) {
+		if (this.revealed.has(team)) return 2;
+		const visible = this.visible.get(team);
+		if (!visible) return 0;
+		const cx = clamp(Math.floor(x), 0, this.width - 1);
+		const i = clamp(Math.floor(z), 0, this.depth - 1) * this.width + cx;
+		if (visible[i]) return 2;
+		return this.explored.get(team)[i] ? 1 : 0;
+	}
+	/** Whether the team sees the cell at (x, z) now */
+	isVisible(team, x, z) {
+		return this.stateAt(team, x, z) === 2;
+	}
+	/** Whether the team has seen the cell at (x, z) at some time */
+	isExplored(team, x, z) {
+		return this.stateAt(team, x, z) !== 0;
+	}
+	/** A team has seen every cell once: the map starts explored for it */
+	exploreAll(team) {
+		this.explored.get(team)?.fill(1);
+		this.version++;
+	}
+	/**
+	* The whole map explored from the start, for every team and the teams to come (`exploredFromStart`), or no longer:
+	* then each team has explored what it sees now, and no more (a debug switch, mid-game)
+	*
+	* @beta
+	*/
+	exploreFromStart(on) {
+		this.exploredFromStart = on;
+		for (const team of this.teams) {
+			const explored = this.explored.get(team);
+			if (on) explored.fill(1);
+			else explored.set(this.visible.get(team));
+		}
+		this.version++;
+	}
+	/** Raw per cell state for rendering */
+	cells(team) {
+		const visible = this.visible.get(team);
+		const explored = this.explored.get(team);
+		return visible && explored ? {
+			visible,
+			explored
+		} : null;
+	}
+};
+//#endregion
+export { FOG_EXPLORED, FOG_UNEXPLORED, FOG_VISIBLE, FogOfWar, MAX_FOG_TEAMS };
+
+//# sourceMappingURL=fog.js.map

package/dist/fog.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fog.js","names":[],"sources":["../src/fog.ts"],"sourcesContent":["import { packBytes, unpackBytes } from './bytes'\nimport { clamp } from './math'\n\n/**\n * The state of a cell the team has not seen yet\n *\n * @internal\n */\nexport const FOG_UNEXPLORED = 0\n/**\n * The state of a cell the team has seen but does not see now\n *\n * @internal\n */\nexport const FOG_EXPLORED = 1\n/**\n * The state of a cell the team sees now\n *\n * @internal\n */\nexport const FOG_VISIBLE = 2\n\n/**\n * Bit positions are 0..31: JavaScript bitwise operators work on 32 bit integers\n *\n * @internal\n */\nexport const MAX_FOG_TEAMS = 32\n\n/**\n * Per team visibility of the map, one cell per world unit.\n *\n * Each team has two grids. `visible` is what the team sees right now and is cleared and drawn again\n * on every update. `explored` only ever gets set: ground the team has looked at at least once, which\n * is drawn as the dimmed \"explored\" fog and lets players build there.\n */\n/** The fog in a save, see `FogOfWar.save` */\nexport interface FogSave {\n\tversion: number\n\trevealed: number[]\n\t/** Cells of each team, packed */\n\tteams: Record<number, { visible: string; explored: string }>\n\t/**\n\t * Each team's bit in the masks entities keep (`Entity.seenBy`): in the order teams first had fog, which a world loaded\n\t * from the save would not know otherwise once a player has moved to another team. Saves from before it numbered them\n\t * from the teams the world was made with\n\t */\n\tbits?: Record<number, number>\n\t/** Whether the map is explored from the start, for the teams to come too (`FogOfWar.exploredFromStart`) */\n\texploredFromStart?: true\n}\n\n/** Whether the middle of a cell of a row is in a circle: `across` is the square of how far the row's middle is from the circle's */\nconst inside = (cx: number, x: number, across: number, r2: number): boolean => (cx + 0.5 - x) * (cx + 0.5 - x) + across <= r2\n\n/**\n * What each team sees and has seen of the map, by cell, and the bit each team has in `Entity.seenBy`\n *\n * @beta\n */\nexport class FogOfWar {\n\t// (the maps below hold a team's cells for every team of `teams`, made together in the constructor: a `get(team)!` on\n\t// one of those teams cannot miss)\n\tprivate readonly visible = new Map<number, Uint8Array>()\n\tprivate readonly explored = new Map<number, Uint8Array>()\n\tprivate readonly revealed = new Set<number>()\n\t/**\n\t * One bit per team, for per-entity bitmasks like `Entity.seenBy`. Team ids come from the map and can be\n\t * any number (the creeps are team 1000), so they are numbered 0, 1, 2... here instead of being used as\n\t * bit positions directly: `1 << 1000` is `1 << 8` in JavaScript and would mix up two teams.\n\t */\n\tprivate readonly bits = new Map<number, number>()\n\tprivate readonly levels: Uint8Array\n\t/**\n\t * What is being lit during an update (`beginUpdate`), a bit a cell, a row of the map `words` of 32 bits: a row of a\n\t * circle is a word or two, not hundreds of cells. Written into the grids as the update ends\n\t */\n\tprivate readonly lit = new Map<number, Uint32Array>()\n\tprivate readonly words: number\n\tprivate updating = false\n\t/**\n\t * Whether `lit` holds what each team sees now, as the grids do: from the end of an update until the grids are written\n\t * otherwise (a reveal outside an update, a save taken back)\n\t */\n\tprivate litIsSight = false\n\t/** The cells at or under each level, as bits: what a viewer on that level sees of what it lights. Made as they are first asked for */\n\tprivate readonly levelMasks = new Map<number, Uint32Array>()\n\t/** The highest level of the ground: a viewer on it or above sees everything it lights. -1 until worked out */\n\tprivate top = -1\n\t/** Bumped every time visibility is recomputed */\n\tversion = 0\n\n\tconstructor(\n\t\t/** The map's width in cells */\n\t\treadonly width: number,\n\t\t/** The map's depth in cells */\n\t\treadonly depth: number,\n\t\tteams: number[],\n\t\t/** Level of every cell: nobody sees up a cliff. All on the ground floor when left out */\n\t\tlevels?: Uint8Array\n\t) {\n\t\tthis.levels = levels ?? new Uint8Array(width * depth)\n\t\tthis.words = Math.ceil(width / 32)\n\t\tif (teams.length > MAX_FOG_TEAMS) throw new Error(`Fog of war supports at most ${MAX_FOG_TEAMS} teams, got ${teams.length}`)\n\t\tfor (const team of teams) this.makeTeam(team)\n\t}\n\n\t/** Gives a team that has none yet fog of its own: a player moved to a new team mid-game. Nothing for one there is */\n\taddTeam(team: number): void {\n\t\tif (this.visible.has(team)) return\n\t\tthis.makeTeam(team)\n\t\tthis.version++\n\t}\n\n\t/**\n\t * Whether the whole map is explored from the start (`FogSettings.startExplored`, `MapDef.explored`): every team's, and\n\t * the teams' made from now on. What stands on it and is no player's is then known to every team from the first moment\n\t * (the sessions' `TeamMemory.startKnown`). Set with `exploreFromStart`\n\t */\n\texploredFromStart = false\n\n\t/** Grids for a team, and the first bit no other team has */\n\tprivate makeTeam(team: number, bit = this.freeBit()): void {\n\t\tthis.visible.set(team, new Uint8Array(this.width * this.depth))\n\t\tthis.explored.set(team, new Uint8Array(this.width * this.depth).fill(this.exploredFromStart ? 1 : 0))\n\t\tthis.bits.set(team, bit)\n\t\tthis.lit.set(team, new Uint32Array(this.words * this.depth))\n\t}\n\n\tprivate freeBit(): number {\n\t\tconst taken = new Set(this.bits.values())\n\t\tfor (let place = 0; place < MAX_FOG_TEAMS; place++) if (!taken.has(1 << place)) return 1 << place\n\t\tthrow new Error(`Fog of war supports at most ${MAX_FOG_TEAMS} teams`)\n\t}\n\n\t/** The team's bit in per-entity team masks. 0 for a team without fog (neutral), which then never shows up in one */\n\t/** What each team sees and has explored, for a save, with each team's bit */\n\tsave(): FogSave {\n\t\tconst save: FogSave = {\n\t\t\tversion: this.version,\n\t\t\trevealed: [...this.revealed],\n\t\t\tteams: {},\n\t\t\tbits: Object.fromEntries(this.bits),\n\t\t\t...(this.exploredFromStart && { exploredFromStart: true })\n\t\t}\n\t\tfor (const team of this.teams) save.teams[team] = { visible: packBytes(this.visible.get(team)!), explored: packBytes(this.explored.get(team)!) }\n\t\treturn save\n\t}\n\n\t/** Takes the fog back from a save, teams and revealed ones too; throws when a team's cells are missing or of another size */\n\trestore(save: FogSave): void {\n\t\tconst cells = this.width * this.depth\n\t\tif (save.bits) {\n\t\t\t// the teams as the saved world had them, each with its bit: those of players who moved since, too\n\t\t\tfor (const team of this.teams) {\n\t\t\t\tthis.visible.delete(team)\n\t\t\t\tthis.explored.delete(team)\n\t\t\t\tthis.lit.delete(team)\n\t\t\t}\n\t\t\tthis.bits.clear()\n\t\t\tfor (const [team, bit] of Object.entries(save.bits)) this.makeTeam(Number(team), bit)\n\t\t}\n\t\tfor (const team of this.teams) {\n\t\t\tconst saved = save.teams[team]\n\t\t\tconst visible = saved && unpackBytes(saved.visible, cells)\n\t\t\tconst explored = saved && unpackBytes(saved.explored, cells)\n\t\t\tif (!visible || !explored) throw new Error(`Save: the fog of team ${team} is missing or not the size of the map`)\n\t\t\tthis.visible.get(team)!.set(visible)\n\t\t\tthis.explored.get(team)!.set(explored)\n\t\t}\n\t\t// the grids from the save, the bits still of the update before (or none)\n\t\tthis.litIsSight = false\n\t\tthis.revealed.clear()\n\t\tfor (const team of save.revealed) this.revealed.add(team)\n\t\tthis.exploredFromStart = !!save.exploredFromStart\n\t\tthis.version = save.version\n\t}\n\n\t/** The bit a team has in per-entity bitmasks such as `Entity.seenBy`; 0 for a team that is not known */\n\tteamBit(team: number): number {\n\t\treturn this.bits.get(team) ?? 0\n\t}\n\n\t/** The teams the fog holds cells for */\n\tget teams(): number[] {\n\t\treturn [...this.visible.keys()]\n\t}\n\n\t/** Debug switch: the team sees everything */\n\tsetRevealed(team: number, revealed: boolean): void {\n\t\tif (revealed) this.revealed.add(team)\n\t\telse this.revealed.delete(team)\n\t\tthis.version++\n\t}\n\n\t/** Whether the team is shown everything (`setRevealed`) */\n\tisRevealed(team: number): boolean {\n\t\treturn this.revealed.has(team)\n\t}\n\n\t/**\n\t * Starts working out what is seen: what is lit from here to `endUpdate` is collected as bits, and the grids\n\t * are written when it ends, so `visible` and `explored` say what they did before until then\n\t */\n\tbeginUpdate(): void {\n\t\tthis.updating = true\n\t\tthis.litIsSight = false\n\t\tfor (const bits of this.lit.values()) bits.fill(0)\n\t}\n\n\t/** Ends the update begun by `beginUpdate`: writes what was lit into the grids, so that visibility changes at once */\n\tendUpdate(): void {\n\t\tthis.updating = false\n\t\tconst { width, depth, words } = this\n\t\tfor (const [team, bits] of this.lit) {\n\t\t\tconst visible = this.visible.get(team)!\n\t\t\tconst explored = this.explored.get(team)!\n\t\t\tvisible.fill(0)\n\t\t\tfor (let cz = 0; cz < depth; cz++) {\n\t\t\t\tfor (let w = 0; w < words; w++) {\n\t\t\t\t\tlet word = bits[cz * words + w]\n\t\t\t\t\tif (word === 0) continue\n\t\t\t\t\tconst row = cz * width + w * 32\n\t\t\t\t\tif (word === 0xffffffff) {\n\t\t\t\t\t\tfor (let i = row; i < row + 32; i++) {\n\t\t\t\t\t\t\tvisible[i] = 1\n\t\t\t\t\t\t\texplored[i] = 1\n\t\t\t\t\t\t}\n\t\t\t\t\t\tcontinue\n\t\t\t\t\t}\n\t\t\t\t\twhile (word !== 0) {\n\t\t\t\t\t\tconst low = word & -word\n\t\t\t\t\t\tconst i = row + 31 - Math.clz32(low)\n\t\t\t\t\t\tvisible[i] = 1\n\t\t\t\t\t\texplored[i] = 1\n\t\t\t\t\t\tword ^= low\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tthis.litIsSight = true\n\t\tthis.version++\n\t}\n\n\t/**\n\t * What a team sees now as bits, a bit a cell, the lowest first: a row of the map `ceil(width / 32)` words, each row\n\t * starting a word. As the last update (`endUpdate`) worked it out: undefined where the grids were written otherwise\n\t * since (a reveal outside an update, a save taken back), or the team has no fog. Read, never written to\n\t *\n\t * @internal\n\t */\n\tsightBits(team: number): Uint32Array | undefined {\n\t\treturn this.litIsSight ? this.lit.get(team) : undefined\n\t}\n\n\t/**\n\t * Says the ground's levels changed (`Terrain.levels` written to while the world runs): what a viewer on a level sees\n\t * is worked out from them once, and again after this\n\t *\n\t * @beta\n\t */\n\tlevelsChanged(): void {\n\t\tthis.levelMasks.clear()\n\t\tthis.top = -1\n\t}\n\n\tprivate highest(): number {\n\t\tif (this.top < 0) {\n\t\t\tlet top = 0\n\t\t\tfor (const level of this.levels) if (level > top) top = level\n\t\t\tthis.top = top\n\t\t}\n\t\treturn this.top\n\t}\n\n\tprivate maskOf(level: number): Uint32Array {\n\t\tlet mask = this.levelMasks.get(level)\n\t\tif (!mask) {\n\t\t\tconst { width, depth, words, levels } = this\n\t\t\tmask = new Uint32Array(words * depth)\n\t\t\tfor (let cz = 0; cz < depth; cz++) {\n\t\t\t\tfor (let cx = 0; cx < width; cx++) if (levels[cz * width + cx] <= level) mask[cz * words + (cx >> 5)] |= 1 << (cx & 31)\n\t\t\t}\n\t\t\tthis.levelMasks.set(level, mask)\n\t\t}\n\t\treturn mask\n\t}\n\n\t/** Lights up what a viewer at the point sees. Ground above the viewer's `level` stays dark, so a flyer passes Infinity */\n\treveal(team: number, x: number, z: number, radius: number, level = Infinity): void {\n\t\tconst visible = this.visible.get(team)\n\t\tconst explored = this.explored.get(team)\n\t\tif (!visible || !explored) return\n\t\tconst { width, depth, words } = this\n\t\tconst minZ = clamp(Math.floor(z - radius), 0, depth - 1)\n\t\tconst maxZ = clamp(Math.ceil(z + radius), 0, depth - 1)\n\t\tconst r2 = radius * radius\n\t\tconst bits = this.updating ? this.lit.get(team)! : null\n\t\tconst mask = bits && level < this.highest() ? this.maskOf(level) : null\n\t\tfor (let cz = minZ; cz <= maxZ; cz++) {\n\t\t\tconst dz = cz + 0.5 - z\n\t\t\tconst across = dz * dz\n\t\t\tif (across > r2) continue\n\t\t\t// the cells of the row whose middle is in the circle: from the root, then made exact (the same test as ever)\n\t\t\tconst half = Math.sqrt(r2 - across)\n\t\t\tlet from = Math.max(Math.ceil(x - half - 0.5), 0)\n\t\t\tlet to = Math.min(Math.floor(x + half - 0.5), width - 1)\n\t\t\twhile (from <= to && !inside(from, x, across, r2)) from++\n\t\t\twhile (to >= from && !inside(to, x, across, r2)) to--\n\t\t\twhile (from > 0 && inside(from - 1, x, across, r2)) from--\n\t\t\twhile (to < width - 1 && inside(to + 1, x, across, r2)) to++\n\t\t\tif (to < from) continue\n\t\t\tif (!bits) {\n\t\t\t\t// outside an update: the grids at once\n\t\t\t\tconst { levels } = this\n\t\t\t\tfor (let cx = from; cx <= to; cx++) {\n\t\t\t\t\tconst i = cz * width + cx\n\t\t\t\t\tif (levels[i] > level) continue\n\t\t\t\t\tvisible[i] = 1\n\t\t\t\t\texplored[i] = 1\n\t\t\t\t}\n\t\t\t\tcontinue\n\t\t\t}\n\t\t\tconst first = from >> 5\n\t\t\tconst last = to >> 5\n\t\t\tconst row = cz * words\n\t\t\tconst head = -1 << (from & 31)\n\t\t\tconst tail = -1 >>> (31 - (to & 31))\n\t\t\tif (first === last) bits[row + first] |= mask ? head & tail & mask[row + first] : head & tail\n\t\t\telse {\n\t\t\t\tbits[row + first] |= mask ? head & mask[row + first] : head\n\t\t\t\tfor (let w = first + 1; w < last; w++) bits[row + w] |= mask ? mask[row + w] : -1\n\t\t\t\tbits[row + last] |= mask ? tail & mask[row + last] : tail\n\t\t\t}\n\t\t}\n\t}\n\n\t/** The state of the cell at (x, z) for the team: `FOG_VISIBLE` when it is revealed, else visible, explored or unexplored */\n\tstateAt(team: number, x: number, z: number): number {\n\t\tif (this.revealed.has(team)) return FOG_VISIBLE\n\t\tconst visible = this.visible.get(team)\n\t\tif (!visible) return FOG_UNEXPLORED\n\t\tconst cx = clamp(Math.floor(x), 0, this.width - 1)\n\t\tconst cz = clamp(Math.floor(z), 0, this.depth - 1)\n\t\tconst i = cz * this.width + cx\n\t\tif (visible[i]) return FOG_VISIBLE\n\t\treturn this.explored.get(team)![i] ? FOG_EXPLORED : FOG_UNEXPLORED\n\t}\n\n\t/** Whether the team sees the cell at (x, z) now */\n\tisVisible(team: number, x: number, z: number): boolean {\n\t\treturn this.stateAt(team, x, z) === FOG_VISIBLE\n\t}\n\n\t/** Whether the team has seen the cell at (x, z) at some time */\n\tisExplored(team: number, x: number, z: number): boolean {\n\t\treturn this.stateAt(team, x, z) !== FOG_UNEXPLORED\n\t}\n\n\t/** A team has seen every cell once: the map starts explored for it */\n\texploreAll(team: number): void {\n\t\tthis.explored.get(team)?.fill(1)\n\t\tthis.version++\n\t}\n\n\t/**\n\t * The whole map explored from the start, for every team and the teams to come (`exploredFromStart`), or no longer:\n\t * then each team has explored what it sees now, and no more (a debug switch, mid-game)\n\t *\n\t * @beta\n\t */\n\texploreFromStart(on: boolean): void {\n\t\tthis.exploredFromStart = on\n\t\tfor (const team of this.teams) {\n\t\t\tconst explored = this.explored.get(team)!\n\t\t\tif (on) explored.fill(1)\n\t\t\telse explored.set(this.visible.get(team)!)\n\t\t}\n\t\tthis.version++\n\t}\n\n\t/** Raw per cell state for rendering */\n\tcells(team: number): { visible: Uint8Array; explored: Uint8Array } | null {\n\t\tconst visible = this.visible.get(team)\n\t\tconst explored = this.explored.get(team)\n\t\treturn visible && explored ? { visible, explored } : null\n\t}\n}\n"],"mappings":"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"}