@v12-engine/engine 0.1.1 → 0.4.0

package/dist/ai/knowledge.js

@@ -0,0 +1,804 @@
+import { distSq } from "../math.js";
+import { heroOfState } from "../hero.js";
+import "./reach.js";
+//#region src/ai/knowledge.ts
+var LIMITS = {
+	sightings: 12,
+	workers: 40,
+	heroes: 16,
+	structures: 400,
+	lost: 64,
+	events: 48,
+	attacks: 20,
+	history: 36
+};
+var empty = () => ({
+	v: 1,
+	tick: 0,
+	structures: [],
+	army: [],
+	workers: [],
+	heroes: [],
+	types: {},
+	looked: {
+		cols: 0,
+		rows: 0,
+		ticks: []
+	},
+	lost: [],
+	attacks: [],
+	gathered: {},
+	history: [],
+	pings: [],
+	damage: [],
+	deaths: []
+});
+var at = (point) => ({
+	x: point.x,
+	z: point.z
+});
+/** Keeps the last `limit` of a list (the newest, for lists kept oldest first) */
+function trimOldest(list, limit) {
+	if (list.length > limit) list.splice(0, list.length - limit);
+}
+/**
+* What a computer player remembers of the enemy, the map and itself, with when (`Brain.knowledge`). Brought up to date
+* once a think from the view; asked through its parts: `enemy` (structures, bases, army seen, workers, heroes, tech),
+* `map` (when a place was last looked at), `own` (losses, attacks sent, income), `events` (pings, damage, deaths heard).
+* Plain data underneath (`data`), saved with the brain
+*
+* @beta
+*/
+var Knowledge = class {
+	kept;
+	/** Its id among the brain's areas: what its memory and its report are kept under */
+	id = "knowledge";
+	/** What the log says where a save's memory of it is of a shape it does not read */
+	afresh = "the save remembers what the computer player knew in a shape this brain does not read: it starts afresh";
+	/** What it remembers, as plain data. Replaced as a whole by `restore` */
+	data = empty();
+	/** The enemy: structures, bases, army, workers, heroes, tech */
+	enemy;
+	/** The map: when each place was last in sight */
+	map;
+	/** One's own: losses, attacks sent, income */
+	own;
+	/** What was heard: pings, damage to friends, deaths */
+	events;
+	/** @internal The view of the last update: for what is asked of the map now */
+	view;
+	/** @internal The seat's fog as of the last update */
+	fog;
+	/** Where in the fog each cell of the map is read: found again when the fog or the map is of another size */
+	sample;
+	/** The options it runs with: those given over the defaults, the limits being the built-in ones */
+	options;
+	constructor(options = {}, size, kept = true) {
+		this.kept = kept;
+		this.options = {
+			armyFor: options.armyFor ?? 180,
+			keepFor: options.keepFor ?? 300,
+			mergeRadius: options.mergeRadius ?? 16,
+			historyEvery: options.historyEvery ?? 5,
+			army: options.army,
+			limits: {
+				...LIMITS,
+				...options.limits
+			}
+		};
+		this.enemy = new EnemyKnowledge(this);
+		this.map = new MapKnowledge(this);
+		this.own = new OwnKnowledge(this);
+		this.events = new HeardEvents(this);
+		if (size) this.size(size.width, size.depth);
+	}
+	/** Makes what is remembered of the map the size of a map of this many units: forgotten where it was another size */
+	size(width, depth) {
+		const cols = Math.max(1, Math.ceil(width / 8));
+		const rows = Math.max(1, Math.ceil(depth / 8));
+		const looked = this.data.looked;
+		if (looked.cols !== cols || looked.rows !== rows) this.data.looked = {
+			cols,
+			rows,
+			ticks: new Array(cols * rows).fill(-1)
+		};
+	}
+	/** The tick it was last brought up to date */
+	get tick() {
+		return this.data.tick;
+	}
+	/** @internal Seconds into the game of a tick, at the seat's rate */
+	seconds(ticks) {
+		return ticks / (this.view?.session.tickRate ?? 1);
+	}
+	/** @internal The tick so many seconds before the last update */
+	since(seconds) {
+		if (seconds === void 0) return -Infinity;
+		return this.data.tick - seconds * (this.view?.session.tickRate ?? 1);
+	}
+	/**
+	* Brings it up to date from a think's view. `before` is the view of the think before: what the dead of this think
+	* were (a death says only an id). What the brain calls as each think begins, after the view is made
+	*/
+	update(view, before) {
+		const { data, options } = this;
+		const tick = view.tick;
+		const rate = view.session.tickRate;
+		this.view = view;
+		this.enemy.reset();
+		data.tick = tick;
+		const sees = this.lookAround(view);
+		const known = /* @__PURE__ */ new Set();
+		const byId = new Map(data.structures.map((each) => [each.id, each]));
+		for (const building of view.enemies.known().buildings()) {
+			known.add(building.id);
+			let seen = byId.get(building.id);
+			if (!seen) {
+				seen = {
+					id: building.id,
+					type: building.type,
+					owner: building.owner,
+					at: at(building),
+					first: tick,
+					last: tick
+				};
+				data.structures.push(seen);
+				byId.set(building.id, seen);
+			}
+			seen.type = building.type;
+			seen.at = at(building);
+			if (building.visible) seen.last = tick;
+			delete seen.gone;
+		}
+		const goneFor = options.keepFor * rate;
+		data.structures = data.structures.filter((each) => {
+			if (!known.has(each.id) && each.gone === void 0) each.gone = tick;
+			return each.gone === void 0 || tick - each.gone <= goneFor;
+		});
+		trimOldest(data.structures, options.limits.structures);
+		const now = {};
+		for (const entity of view.enemies) now[entity.type] = (now[entity.type] ?? 0) + 1;
+		for (const [type, count] of Object.entries(now)) {
+			const seen = data.types[type] ??= {
+				first: tick,
+				last: tick,
+				most: 0
+			};
+			seen.last = tick;
+			seen.most = Math.max(seen.most, count);
+		}
+		this.seeArmy(view, sees);
+		this.seeUnits(view, sees);
+		this.hear(view, before);
+		this.count(view);
+	}
+	/** Brings what was last looked at up to date from the seat's fog: what is in sight now, by cell (1 for in sight) */
+	/**
+	* Reads the think's picture through this view without remembering anything of it: for a think a game loaded from a
+	* save goes on with (`BrainMemory.thinking`), whose picture the saved game remembered already, so that what is restored
+	* is as it was after that; only what is asked of the map now needs the view it is asked through
+	*/
+	resume(view) {
+		this.view = view;
+		this.fog = view.session.fog();
+		this.size(view.session.terrain.width, view.session.terrain.depth);
+		this.enemy.reset();
+	}
+	lookAround(view) {
+		const { width, depth } = view.session.terrain;
+		this.size(width, depth);
+		const { cols, rows } = this.data.looked;
+		const ticks = this.data.looked.ticks;
+		const fog = view.session.fog();
+		this.fog = fog;
+		const sees = new Uint8Array(cols * rows);
+		const tick = view.tick;
+		if (fog.revealed || !fog.visible.length) {
+			sees.fill(1);
+			ticks.fill(tick);
+			return sees;
+		}
+		let sample = this.sample;
+		if (!sample || sample.fog !== fog.width * 65536 + fog.depth || sample.cells.length !== cols * rows) {
+			const cells = new Int32Array(cols * rows);
+			for (let r = 0; r < rows; r++) {
+				const fz = Math.min(fog.depth - 1, Math.floor((r + .5) * 8 / depth * fog.depth));
+				for (let c = 0; c < cols; c++) cells[r * cols + c] = fz * fog.width + Math.min(fog.width - 1, Math.floor((c + .5) * 8 / width * fog.width));
+			}
+			sample = this.sample = {
+				fog: fog.width * 65536 + fog.depth,
+				cells
+			};
+		}
+		const { visible } = fog;
+		const { cells } = sample;
+		for (let i = 0; i < cells.length; i++) {
+			if (!visible[cells[i]]) continue;
+			sees[i] = 1;
+			ticks[i] = tick;
+		}
+		return sees;
+	}
+	/** @internal The cell of a point, in what is remembered of the map: -1 off it */
+	cell(point) {
+		const { cols, rows } = this.data.looked;
+		const c = Math.floor(point.x / 8);
+		const r = Math.floor(point.z / 8);
+		if (c < 0 || r < 0 || c >= cols || r >= rows) return -1;
+		return r * cols + c;
+	}
+	/**
+	* The enemy's fighters in sight, grouped by nearness into sightings. A newer sighting replaces the older ones near
+	* it (the army moved); an older one whose place is in sight with no sighting near is dropped (no one is there now)
+	*/
+	seeArmy(view, sees) {
+		const { data, options } = this;
+		const tick = view.tick;
+		const merge = options.mergeRadius * options.mergeRadius;
+		const fighters = options.army ? view.enemies.units().where((entity) => options.army(entity, view)) : view.enemies.units().fighters();
+		const groups = [];
+		for (const unit of fighters) {
+			if (unit.health <= 0) continue;
+			const group = groups.find((each) => distSq(each[0], unit) <= merge);
+			if (group) group.push(unit);
+			else groups.push([unit]);
+		}
+		const fresh = groups.map((group) => {
+			let x = 0;
+			let z = 0;
+			let health = 0;
+			let strength = 0;
+			let heroes = 0;
+			const types = {};
+			const owners = /* @__PURE__ */ new Map();
+			for (const unit of group) {
+				x += unit.x;
+				z += unit.z;
+				health += unit.health;
+				strength += view.strength.of(unit);
+				if (view.hasRole(unit, "hero")) heroes++;
+				types[unit.type] = (types[unit.type] ?? 0) + 1;
+				owners.set(unit.owner, (owners.get(unit.owner) ?? 0) + 1);
+			}
+			let owner = group[0].owner;
+			for (const [player, count] of owners) if (count > owners.get(owner)) owner = player;
+			return {
+				at: {
+					x: x / group.length,
+					z: z / group.length
+				},
+				tick,
+				owner,
+				count: group.length,
+				health,
+				strength,
+				types,
+				heroes
+			};
+		});
+		const oldest = tick - options.armyFor * view.session.tickRate;
+		const kept = data.army.filter((old) => {
+			if (old.tick < oldest) return false;
+			if (fresh.some((each) => distSq(each.at, old.at) <= merge)) return false;
+			const cell = this.cell(old.at);
+			return cell < 0 || !sees[cell];
+		});
+		data.army = [...fresh, ...kept].slice(0, options.limits.sightings);
+	}
+	/**
+	* The enemy's workers and heroes in sight, by id, where they were. A worker whose place is in sight and who is not
+	* there is forgotten; a hero is kept where last seen (there are few, and where they went matters)
+	*/
+	seeUnits(view, sees) {
+		const { data, options } = this;
+		const tick = view.tick;
+		const workers = new Map(data.workers.map((each) => [each.id, each]));
+		for (const unit of view.enemies.units()) {
+			if (!(view.hasRole(unit, "worker") || view.hasRole(unit, "gatherer") && !view.hasRole(unit, "soldier"))) continue;
+			const seen = workers.get(unit.id);
+			if (seen) {
+				seen.at = at(unit);
+				seen.tick = tick;
+			} else workers.set(unit.id, {
+				id: unit.id,
+				type: unit.type,
+				owner: unit.owner,
+				at: at(unit),
+				tick
+			});
+		}
+		const oldest = tick - options.armyFor * view.session.tickRate;
+		data.workers = [...workers.values()].filter((each) => {
+			if (each.tick === tick) return true;
+			const cell = this.cell(each.at);
+			return each.tick >= oldest && (cell < 0 || !sees[cell]);
+		});
+		data.workers.sort((a, b) => b.tick - a.tick || a.id - b.id);
+		data.workers.length = Math.min(data.workers.length, options.limits.workers);
+		const heroes = new Map(data.heroes.map((each) => [each.id, each]));
+		for (const hero of view.enemies.heroes()) {
+			const seen = heroes.get(hero.id) ?? {
+				id: hero.id,
+				type: hero.type,
+				owner: hero.owner,
+				at: at(hero),
+				tick
+			};
+			seen.type = hero.type;
+			seen.at = at(hero);
+			seen.tick = tick;
+			const level = heroOfState(hero)?.level;
+			if (level !== void 0) seen.level = level;
+			delete seen.died;
+			heroes.set(hero.id, seen);
+		}
+		data.heroes = [...heroes.values()];
+		data.heroes.sort((a, b) => b.tick - a.tick || a.id - b.id);
+		data.heroes.length = Math.min(data.heroes.length, options.limits.heroes);
+	}
+	/** What the think's events say: deaths (one's own among them, as losses), pings, damage to one's own and allies' */
+	hear(view, before) {
+		const { data, options } = this;
+		const tick = view.tick;
+		const limit = options.limits.events;
+		for (const death of view.events.of("death")) {
+			const was = before?.byId(death.id) ?? view.byId(death.id);
+			if (!was) continue;
+			const by = death.killerType;
+			const seen = {
+				tick,
+				id: was.id,
+				type: was.type,
+				owner: was.owner,
+				at: at(was),
+				...by && { by }
+			};
+			data.deaths.push(seen);
+			if (was.owner === view.playerId) data.lost.push({
+				id: was.id,
+				type: was.type,
+				at: seen.at,
+				tick,
+				...by && { by }
+			});
+			const worker = data.workers.findIndex((each) => each.id === was.id);
+			if (worker >= 0) data.workers.splice(worker, 1);
+			const hero = data.heroes.find((each) => each.id === was.id);
+			if (hero) hero.died = tick;
+		}
+		trimOldest(data.deaths, limit);
+		trimOldest(data.lost, options.limits.lost);
+		for (const ping of view.events.of("ping")) data.pings.push({
+			tick,
+			player: ping.player,
+			at: {
+				x: ping.x,
+				z: ping.z
+			},
+			kind: ping.kind
+		});
+		trimOldest(data.pings, limit);
+		const damage = view.events.of("damage");
+		if (damage.length) {
+			const byEntity = /* @__PURE__ */ new Map();
+			for (const hit of damage) {
+				const target = view.byId(hit.id) ?? before?.byId(hit.id);
+				if (!target || !view.isFriendly(target)) continue;
+				const line = byEntity.get(hit.id);
+				if (line) line.amount += hit.amount;
+				else byEntity.set(hit.id, {
+					tick,
+					id: hit.id,
+					type: target.type,
+					owner: target.owner,
+					at: at(target),
+					amount: hit.amount,
+					...hit.sourceType && { by: hit.sourceType }
+				});
+			}
+			for (const line of byEntity.values()) data.damage.push(line);
+			trimOldest(data.damage, limit);
+		}
+		this.forgetOlder(this.since(options.keepFor), false);
+	}
+	/** What was gathered: every rise in what the player has, added up; sampled every `historyEvery` seconds */
+	count(view) {
+		const { data, options } = this;
+		const resources = view.me.resources;
+		if (data.had) for (const [kind, amount] of Object.entries(resources)) {
+			const rise = amount - (data.had[kind] ?? 0);
+			if (rise > 0) data.gathered[kind] = (data.gathered[kind] ?? 0) + rise;
+		}
+		data.had = { ...resources };
+		const last = data.history[data.history.length - 1];
+		if (!last || view.tick - last.tick >= options.historyEvery * view.session.tickRate) {
+			data.history.push({
+				tick: view.tick,
+				gathered: { ...data.gathered }
+			});
+			trimOldest(data.history, options.limits.history);
+		}
+	}
+	/** Forgets what is older than so many seconds: sightings, workers, losses, attacks, what was heard, structures long gone */
+	forget(olderThan) {
+		this.forgetOlder(this.since(olderThan), true);
+	}
+	forgetOlder(oldest, all) {
+		const { data } = this;
+		const keep = (list) => list.filter((each) => each.tick >= oldest);
+		data.lost = keep(data.lost);
+		data.attacks = keep(data.attacks);
+		data.pings = keep(data.pings);
+		data.damage = keep(data.damage);
+		data.deaths = keep(data.deaths);
+		if (!all) return;
+		data.army = keep(data.army);
+		data.workers = keep(data.workers);
+		data.heroes = keep(data.heroes);
+		data.structures = data.structures.filter((each) => each.gone === void 0 || each.gone >= oldest);
+		this.enemy.reset();
+	}
+	/** What it remembers, as plain data for a save: a copy */
+	/** Whether it has anything to remember now: one that does not is left out of a save */
+	remembers() {
+		return this.kept;
+	}
+	/** Gives a copy of what is known, as plain data for a save of the brain */
+	save() {
+		const { looked } = this.data;
+		const copy = structuredClone({
+			...this.data,
+			looked: void 0
+		});
+		copy.looked = {
+			cols: looked.cols,
+			rows: looked.rows,
+			ticks: looked.ticks.slice()
+		};
+		return copy;
+	}
+	/** Takes back what `save` gave. Memory of another shape is dropped: it starts afresh */
+	restore(memory) {
+		const data = memory;
+		if (!data || typeof data !== "object" || data.v !== 1) return false;
+		this.data = {
+			...empty(),
+			...structuredClone(data)
+		};
+		this.data.army = this.data.army.filter((sighting) => typeof sighting.strength === "number");
+		this.enemy.reset();
+		return true;
+	}
+	/** What it knows, in short, for the debug tools: bases, the army seen with its age, the tech seen */
+	inspect() {
+		const age = (tick) => Math.round(this.seconds(this.data.tick - tick));
+		return {
+			bases: this.enemy.bases().map((base) => ({
+				owner: base.owner,
+				at: [Math.round(base.at.x), Math.round(base.at.z)],
+				structures: base.structures.length,
+				seen: age(base.last),
+				...base.gone && { gone: true }
+			})),
+			army: this.data.army.map((each) => ({
+				at: [Math.round(each.at.x), Math.round(each.at.z)],
+				count: each.count,
+				seen: age(each.tick)
+			})),
+			tech: this.enemy.techSeen(),
+			lost: this.data.lost.length
+		};
+	}
+};
+/**
+* What a computer player remembers of its enemies (`knowledge.enemy`): their structures and bases, their army as last
+* seen, their workers and heroes, the types and tech seen. Creeps are no one's enemy here
+*
+* @beta
+*/
+var EnemyKnowledge = class {
+	knowledge;
+	basesFound;
+	trainedBy;
+	constructor(knowledge) {
+		this.knowledge = knowledge;
+	}
+	/** @internal Forgets what was worked out of the data: it changed */
+	reset() {
+		this.basesFound = void 0;
+	}
+	/** Their structures remembered and not known gone (`gone: true` for those too), of one owner where given */
+	structures(options = {}) {
+		return this.knowledge.data.structures.filter((each) => (options.gone || each.gone === void 0) && (options.owner === void 0 || each.owner === options.owner));
+	}
+	/**
+	* Their bases: the structures remembered, gone ones too, clustered by owner around what takes deposits (a hall), or
+	* around any structure where none does. The first seen of each owner's first; `gone` where all of it is known gone
+	*/
+	bases(owner) {
+		const all = this.basesFound ??= this.cluster();
+		return owner === void 0 ? all : all.filter((base) => base.owner === owner);
+	}
+	cluster() {
+		const { knowledge } = this;
+		const registry = knowledge.view?.registry;
+		const reach = 576;
+		const takesDeposits = (each) => !!registry?.units.has(each.type) && !!registry.unit(each.type).dropOff;
+		const structures = [...knowledge.data.structures].sort((a, b) => a.first - b.first || a.id - b.id);
+		const bases = [];
+		const centreOf = (each) => bases.find((base) => base.owner === each.owner && distSq(base.at, each.at) < reach);
+		for (const each of structures) {
+			if (!takesDeposits(each) || centreOf(each)) continue;
+			bases.push({
+				owner: each.owner,
+				at: at(each.at),
+				first: each.first,
+				last: each.last,
+				structures: [],
+				hall: true,
+				gone: false,
+				expansion: false
+			});
+		}
+		for (const each of structures) {
+			let base = centreOf(each);
+			if (!base) {
+				base = {
+					owner: each.owner,
+					at: at(each.at),
+					first: each.first,
+					last: each.last,
+					structures: [],
+					hall: false,
+					gone: false,
+					expansion: false
+				};
+				bases.push(base);
+			}
+			base.structures.push(each);
+			base.first = Math.min(base.first, each.first);
+			base.last = Math.max(base.last, each.last);
+		}
+		const firstOf = /* @__PURE__ */ new Set();
+		bases.sort((a, b) => a.first - b.first || a.owner - b.owner);
+		for (const base of bases) {
+			base.gone = base.structures.every((each) => each.gone !== void 0);
+			if (!base.hall) continue;
+			if (firstOf.has(base.owner)) base.expansion = true;
+			else firstOf.add(base.owner);
+		}
+		return bases;
+	}
+	/** Their bases beyond the first of each owner's, with a hall: where they expanded to, as far as seen */
+	expansionsSeen() {
+		return this.bases().filter((base) => base.expansion && !base.gone);
+	}
+	/** Their army as last seen, in groups, newest first; only those seen within so many seconds where given */
+	armySeen(withinSeconds) {
+		const oldest = this.knowledge.since(withinSeconds);
+		return this.knowledge.data.army.filter((each) => each.tick >= oldest);
+	}
+	/** Their workers as last seen, newest first; only those seen within so many seconds where given */
+	workersSeen(withinSeconds) {
+		const oldest = this.knowledge.since(withinSeconds);
+		return this.knowledge.data.workers.filter((each) => each.tick >= oldest);
+	}
+	/** Their heroes as last seen, newest first: type, level, where, and `died` when seen to die */
+	heroesSeen() {
+		return this.knowledge.data.heroes;
+	}
+	/** The unit and structure types of theirs seen, with when and the most seen at once */
+	typesSeen() {
+		return this.knowledge.data.types;
+	}
+	/** The most of a type of theirs seen at once: 0 for one never seen */
+	mostSeen(type) {
+		return this.knowledge.data.types[type]?.most ?? 0;
+	}
+	/**
+	* What they have, as far as what was seen tells: the types seen; what those require, named as `UnitTypeDef.requires`
+	* names them; and the building that trains a type, where only one does (a gryphon means an aviary, and what an aviary
+	* requires). Sorted, for the same answer every time
+	*/
+	techSeen() {
+		const registry = this.knowledge.view?.registry;
+		const tech = /* @__PURE__ */ new Set();
+		const add = (id) => {
+			if (tech.has(id)) return;
+			tech.add(id);
+			if (!registry?.units.has(id)) return;
+			for (const need of registry.unit(id).requires ?? []) add(need);
+			const trainers = this.trainersOf(id);
+			if (trainers.length === 1) add(trainers[0]);
+		};
+		for (const type of Object.keys(this.knowledge.data.types)) add(type);
+		return [...tech].sort();
+	}
+	/** The building types that train a unit type, found once for the game's definitions */
+	trainersOf(type) {
+		const registry = this.knowledge.view?.registry;
+		if (!registry) return [];
+		if (this.trainedBy?.registry !== registry) {
+			const by = /* @__PURE__ */ new Map();
+			for (const def of registry.units.all()) for (const trained of def.trains ?? []) (by.get(trained) ?? by.set(trained, []).get(trained)).push(def.id);
+			this.trainedBy = {
+				registry,
+				by
+			};
+		}
+		return this.trainedBy.by.get(type) ?? [];
+	}
+	/** Takes in what a type seen was, where the game or an older save tells: as if seen, `count` at once, at a tick */
+	sawType(type, count, tick = this.knowledge.tick) {
+		const seen = this.knowledge.data.types[type] ??= {
+			first: tick,
+			last: tick,
+			most: 0
+		};
+		seen.last = Math.max(seen.last, tick);
+		seen.most = Math.max(seen.most, count);
+	}
+};
+/**
+* What a computer player remembers of the map (`knowledge.map`): when each place was last in sight. The cells are of
+* the view's grid (8 units)
+*
+* @beta
+*/
+var MapKnowledge = class {
+	knowledge;
+	constructor(knowledge) {
+		this.knowledge = knowledge;
+	}
+	/** The tick a place was last in sight of the seat's team: none for a place never seen */
+	lastLooked(point) {
+		const cell = this.knowledge.cell(point);
+		const tick = cell < 0 ? -1 : this.knowledge.data.looked.ticks[cell] ?? -1;
+		return tick < 0 ? void 0 : tick;
+	}
+	/** Seconds since a place was last in sight: `Infinity` for one never seen */
+	sinceLooked(point) {
+		const tick = this.lastLooked(point);
+		return tick === void 0 ? Infinity : this.knowledge.seconds(this.knowledge.tick - tick);
+	}
+	/** Whether a place is in sight now, as of the last update */
+	inSight(point) {
+		return this.lastLooked(point) === this.knowledge.tick && this.knowledge.view !== void 0;
+	}
+	/** Whether the seat's team has explored a place: seen it once, as the fog says */
+	explored(point) {
+		const { fog, view } = this.knowledge;
+		if (!fog || !view) return this.lastLooked(point) !== void 0;
+		if (fog.revealed || !fog.explored.length) return true;
+		const { width, depth } = view.session.terrain;
+		const fx = Math.floor(point.x / width * fog.width);
+		const fz = Math.floor(point.z / depth * fog.depth);
+		if (fx < 0 || fz < 0 || fx >= fog.width || fz >= fog.depth) return false;
+		return !!fog.explored[fz * fog.width + fx];
+	}
+	/** Takes in that a place was looked at, at a tick: where the game or an older save tells */
+	look(point, tick = this.knowledge.tick) {
+		const cell = this.knowledge.cell(point);
+		const ticks = this.knowledge.data.looked.ticks;
+		if (cell >= 0) ticks[cell] = Math.max(ticks[cell] ?? -1, tick);
+	}
+	/**
+	* The map's mines (`view.mines`), each with when its place was last looked at and whose base is by it, as far as
+	* known: where to expand, where to look for theirs
+	*/
+	mines() {
+		const view = this.knowledge.view;
+		if (!view) return [];
+		const mine = view.bases();
+		const theirs = this.knowledge.enemy.bases().filter((base) => base.hall && !base.gone);
+		const reach = 576;
+		return view.mines().map((each) => {
+			const looked = this.lastLooked(each);
+			const taken = mine.some((base) => distSq(base.at, each) < reach) ? view.playerId : theirs.find((base) => distSq(base.at, each) < reach)?.owner;
+			return {
+				...each,
+				...looked !== void 0 && { looked },
+				...taken !== void 0 && { taken }
+			};
+		});
+	}
+	/** The map's creep camps, as the seat knows them (`view.camps`) */
+	camps() {
+		return this.knowledge.view?.camps() ?? [];
+	}
+};
+/**
+* What a computer player remembers of itself (`knowledge.own`): what it lost, the attacks it sent, what it gathered
+*
+* @beta
+*/
+var OwnKnowledge = class {
+	knowledge;
+	constructor(knowledge) {
+		this.knowledge = knowledge;
+	}
+	/** What of its own died, oldest first; only within so many seconds where given */
+	lost(withinSeconds) {
+		const oldest = this.knowledge.since(withinSeconds);
+		return this.knowledge.data.lost.filter((each) => each.tick >= oldest);
+	}
+	/** What of its own died within a distance of a place: "we are being raided here" */
+	lostNear(point, radius, withinSeconds) {
+		const reach = radius * radius;
+		return this.lost(withinSeconds).filter((each) => distSq(each.at, point) <= reach);
+	}
+	/** Notes an attack sent, for whoever asks later (`attacks`): what a module that sends an army calls */
+	attackSent(point, count) {
+		const { data, options } = this.knowledge;
+		data.attacks.push({
+			tick: data.tick,
+			at: at(point),
+			count
+		});
+		trimOldest(data.attacks, options.limits.attacks);
+	}
+	/** The attacks sent, oldest first; only within so many seconds where given */
+	attacks(withinSeconds) {
+		const oldest = this.knowledge.since(withinSeconds);
+		return this.knowledge.data.attacks.filter((each) => each.tick >= oldest);
+	}
+	/**
+	* What it gathers of a resource a minute, over the last so many seconds (60): from the rises in what it has, so it
+	* is at least this (what was gathered and spent between two thinks does not show). Bounty counts as gathered
+	*/
+	income(kind, seconds = 60) {
+		const { data } = this.knowledge;
+		const rate = this.knowledge.view?.session.tickRate ?? 1;
+		const from = data.tick - seconds * rate;
+		const sample = data.history.find((each) => each.tick >= from) ?? data.history[0];
+		if (!sample) return 0;
+		const elapsed = (data.tick - sample.tick) / rate;
+		if (elapsed <= 0) return 0;
+		return ((data.gathered[kind] ?? 0) - (sample.gathered[kind] ?? 0)) / elapsed * 60;
+	}
+	/** The income of every resource gathered so far, a minute (`income`) */
+	incomes(seconds = 60) {
+		const result = {};
+		for (const kind of Object.keys(this.knowledge.data.gathered)) result[kind] = this.income(kind, seconds);
+		return result;
+	}
+	/** What was gathered of each resource since the game began, as far as the rises tell */
+	get gathered() {
+		return this.knowledge.data.gathered;
+	}
+	/** The samples of what was gathered, oldest first */
+	get history() {
+		return this.knowledge.data.history;
+	}
+};
+/**
+* What a computer player heard (`knowledge.events`): pings, damage to its own and its allies', deaths, each with its
+* tick, the oldest first
+*
+* @beta
+*/
+var HeardEvents = class {
+	knowledge;
+	constructor(knowledge) {
+		this.knowledge = knowledge;
+	}
+	/** Pings heard; only within so many seconds where given */
+	pings(withinSeconds) {
+		const oldest = this.knowledge.since(withinSeconds);
+		return this.knowledge.data.pings.filter((each) => each.tick >= oldest);
+	}
+	/** Damage seen done to its own and its allies' entities, a line an entity a think; only within so many seconds where given */
+	damage(withinSeconds) {
+		const oldest = this.knowledge.since(withinSeconds);
+		return this.knowledge.data.damage.filter((each) => each.tick >= oldest);
+	}
+	/** Deaths seen, anyone's; only within so many seconds where given */
+	deaths(withinSeconds) {
+		const oldest = this.knowledge.since(withinSeconds);
+		return this.knowledge.data.deaths.filter((each) => each.tick >= oldest);
+	}
+};
+//#endregion
+export { EnemyKnowledge, HeardEvents, Knowledge, MapKnowledge, OwnKnowledge };
+
+//# sourceMappingURL=knowledge.js.map