@v12-engine/engine 0.1.0 → 0.4.0

package/dist/ai/view.js

@@ -0,0 +1,677 @@
+import { distSq } from "../math.js";
+import { builtSoFar } from "../systems/construction.js";
+import { inShape } from "../areas.js";
+import { findRoles, reachableTypes } from "./roles.js";
+import { Strength } from "./strength.js";
+import "./reach.js";
+import { ThreatMap } from "./threat.js";
+//#region src/ai/view.ts
+/** A set this small is scanned for what is near rather than asked of the grid: the grid pays for itself only on big sets */
+var SCAN = 24;
+/**
+* A set of entities as the view gives them, in the snapshot's order, with the questions a brain asks as methods, each
+* giving a set again, so that they chain: `ai.view.mine.withRole('worker').idle()`, `ai.view.enemies.near(home,
+* 20).fighters()`. It reads as an array (`length`, `for..of`, `map`, `filter`, `find`, `some`, `every`, `forEach`,
+* `first`, `at`; `items` is the plain array) but is not one: `map` and `filter` give plain arrays, `where` gives a set.
+* (Not an `Array` subclass on purpose: the engines run `filter` and `find` on one several times slower, species
+* lookup, and a think asks dozens.) A set is of one think: it reads the view it came from
+*
+* @beta
+*/
+var UnitSet = class UnitSet {
+	view;
+	items;
+	/** What this set remembers beside what is in sight (`known`): the structures seen before, for the view's own sets */
+	remembered;
+	/** The answers to the questions that are asked again and again, by their name */
+	memo;
+	idSet;
+	strengthSum;
+	constructor(view, items = [], remembered) {
+		this.view = view;
+		this.items = items;
+		this.remembered = remembered;
+	}
+	/** How many */
+	get length() {
+		return this.items.length;
+	}
+	/** Iterates the set's entities in order */
+	[Symbol.iterator]() {
+		return this.items[Symbol.iterator]();
+	}
+	/** The first of them: none in an empty set */
+	first() {
+		return this.items[0];
+	}
+	/** Some of them, as an array's `slice` takes them: as a set */
+	slice(start, end) {
+		return this.make(this.items.slice(start, end));
+	}
+	/** The one at an index, from the end for a negative one */
+	at(index) {
+		return this.items.at(index);
+	}
+	/** As an array does: a plain array */
+	map(fn) {
+		return this.items.map(fn);
+	}
+	/** As an array does: a plain array. `where` gives a set */
+	filter(fn) {
+		return this.items.filter(fn);
+	}
+	/** The first entity `fn` is true for, or nothing; `fn` is given the entity and its index */
+	find(fn) {
+		return this.items.find(fn);
+	}
+	/** Whether `fn` is true for any entity of the set */
+	some(fn) {
+		return this.items.some(fn);
+	}
+	/** Whether `fn` is true for every entity of the set */
+	every(fn) {
+		return this.items.every(fn);
+	}
+	/** Calls `fn` with each entity and its index, in order */
+	forEach(fn) {
+		this.items.forEach(fn);
+	}
+	/** A set of these, of the same view */
+	make(items) {
+		return new UnitSet(this.view, items);
+	}
+	/** The answer to a question asked by name, worked out once */
+	cached(key, answer) {
+		this.memo ??= /* @__PURE__ */ new Map();
+		let found = this.memo.get(key);
+		if (!found) this.memo.set(key, found = answer());
+		return found;
+	}
+	/** Those that satisfy a predicate, as a set */
+	where(predicate) {
+		const { view } = this;
+		return this.make(this.items.filter((entity) => predicate(entity, view.def(entity))));
+	}
+	/** Those of a unit type, or that count as it (`UnitTypeDef.provides`: a keep is a town hall too) */
+	ofType(type) {
+		return this.cached(`type:${type}`, () => this.where((entity, def) => entity.type === type || !!def.provides?.includes(type)));
+	}
+	/** Those whose type has a role (`AiRole`: `'worker'`, `'hall'`, a game's own word) */
+	withRole(role) {
+		return this.cached(`role:${role}`, () => {
+			const { roles } = this.view;
+			return this.make(this.items.filter((entity) => roles.has(entity.type, role)));
+		});
+	}
+	/** Those whose type has a tag: the kit's (`ranged`, `melee`, `hitsAir`) or the game's (`UnitTypeDef.ai.tags`) */
+	withTag(tag) {
+		return this.cached(`tag:${tag}`, () => {
+			const { roles } = this.view;
+			return this.make(this.items.filter((entity) => roles.hasTag(entity.type, tag)));
+		});
+	}
+	/** Those that fight: soldiers and heroes */
+	fighters() {
+		return this.cached("fighters", () => {
+			const { roles } = this.view;
+			return this.make(this.items.filter((entity) => roles.has(entity.type, "soldier") || roles.has(entity.type, "hero")));
+		});
+	}
+	/** Those that gather and build (role `worker`) */
+	workers() {
+		return this.withRole("worker");
+	}
+	/** The heroes among them */
+	heroes() {
+		return this.withRole("hero");
+	}
+	/** The buildings among them, under construction too (`finished` leaves those out) */
+	buildings() {
+		return this.cached("buildings", () => this.where((_, def) => def.kind === "building"));
+	}
+	/** The units among them: what moves, buildings and resources left out */
+	units() {
+		return this.cached("units", () => this.where((_, def) => def.kind === "unit"));
+	}
+	/** Those that stand finished: not under construction (a building turning into another type stands) */
+	finished() {
+		return this.cached("finished", () => this.make(this.items.filter((entity) => builtSoFar(entity) === void 0)));
+	}
+	/** Those of mine with nothing to do: no order, and not inside something (a worker in a mine). Only one's own say what they do */
+	idle() {
+		return this.cached("idle", () => this.make(this.items.filter((entity) => !!entity.own && !entity.own.order && !entity.own.hidden)));
+	}
+	/** Those in sight now: a structure seen before and out of sight is not (`EntityState.visible`) */
+	visible() {
+		return this.cached("visible", () => this.make(this.items.filter((entity) => entity.visible)));
+	}
+	/** Those with health left */
+	alive() {
+		return this.cached("alive", () => this.make(this.items.filter((entity) => entity.health > 0)));
+	}
+	/** Deposits of a resource with something left in them (a gold mine, a tree): for the view's `resources` */
+	ofResource(kind) {
+		return this.cached(`resource:${kind}`, () => this.where((entity, def) => (entity.resource ?? 0) > 0 && def.resource?.id === kind));
+	}
+	/** Those of a player */
+	ofOwner(player) {
+		return this.cached(`owner:${player}`, () => this.make(this.items.filter((entity) => entity.owner === player)));
+	}
+	/**
+	* Those within a distance of a point, in the snapshot's order. A big set is asked of the view's grid, a small one is
+	* scanned: the answer is the same
+	*/
+	near(point, radius) {
+		const reach = radius * radius;
+		if (this.items.length <= SCAN) return this.make(this.items.filter((entity) => distSq(entity, point) <= reach));
+		const ids = this.ids();
+		return this.make(this.view.gridNear(point, radius).filter((entity) => ids.has(entity.id) && distSq(entity, point) <= reach));
+	}
+	/** The one nearest a point: none in an empty set. The first of two as near */
+	nearest(point) {
+		let best;
+		let bestDistance = Infinity;
+		for (const entity of this.items) {
+			const d = distSq(entity, point);
+			if (d < bestDistance) {
+				bestDistance = d;
+				best = entity;
+			}
+		}
+		return best;
+	}
+	/** The middle of them: none for an empty set */
+	centre() {
+		const { items } = this;
+		if (!items.length) return void 0;
+		let x = 0;
+		let z = 0;
+		for (const entity of items) {
+			x += entity.x;
+			z += entity.z;
+		}
+		return {
+			x: x / items.length,
+			z: z / items.length
+		};
+	}
+	/**
+	* How strong they are together: the strength of each (`Strength.of`: by its stats and the health it has left),
+	* summed. 0 for what does not fight. Against someone in particular, ask `view.strength.odds(these, those)`
+	*/
+	strength() {
+		return this.strengthSum ??= this.view.strength.sum(this.items);
+	}
+	/** Their ids, as a set: for "is it one of these" */
+	ids() {
+		return this.idSet ??= new Set(this.items.map((entity) => entity.id));
+	}
+	/** Whether an entity, by id, is one of these */
+	has(id) {
+		return this.ids().has(id);
+	}
+	/** These and another set's, together, in the snapshot's order, each once */
+	and(other) {
+		const { view } = this;
+		const all = [...this.items, ...other.items.filter((entity) => !this.has(entity.id))];
+		all.sort((a, b) => view.indexOf(a) - view.indexOf(b));
+		return this.make(all);
+	}
+	/**
+	* These and what is remembered of them beside what is in sight: for `view.enemies`, the enemy structures seen before
+	* and out of sight now (`visible: false`), which may be gone. Ask it of the view's set before narrowing it
+	* (`view.enemies.known().buildings()`): a narrowed set remembers nothing more
+	*/
+	known() {
+		if (!this.remembered?.length) return this;
+		return this.cached("known", () => this.and(this.make(this.remembered)));
+	}
+};
+/** The coarse grid of the view: every entity in the cell its place falls in, for what is near a point */
+var Grid = class {
+	index;
+	cells;
+	cols;
+	rows;
+	constructor(width, depth, index) {
+		this.index = index;
+		this.cols = Math.max(1, Math.ceil(width / 8));
+		this.rows = Math.max(1, Math.ceil(depth / 8));
+		this.cells = new Array(this.cols * this.rows);
+	}
+	col(x) {
+		return Math.min(this.cols - 1, Math.max(0, Math.floor(x / 8)));
+	}
+	row(z) {
+		return Math.min(this.rows - 1, Math.max(0, Math.floor(z / 8)));
+	}
+	add(entity) {
+		const index = this.row(entity.z) * this.cols + this.col(entity.x);
+		(this.cells[index] ??= []).push(entity);
+	}
+	/** Everything in the cells a circle touches, in the snapshot's order: more than what is within the circle */
+	near(point, radius) {
+		const found = [];
+		const c0 = this.col(point.x - radius);
+		const c1 = this.col(point.x + radius);
+		const r0 = this.row(point.z - radius);
+		const r1 = this.row(point.z + radius);
+		for (let r = r0; r <= r1; r++) for (let c = c0; c <= c1; c++) {
+			const cell = this.cells[r * this.cols + c];
+			if (cell) for (const entity of cell) found.push(entity);
+		}
+		const { index } = this;
+		found.sort((a, b) => index.get(a.id) - index.get(b.id));
+		return found;
+	}
+};
+/**
+* The events of a think, by kind (`AiView.events`): what happened in the tick of the picture that cannot be read from
+* the state (deaths, damage, pings, the game's own)
+*
+* @beta
+*/
+var ViewEvents = class {
+	all;
+	byType;
+	constructor(all) {
+		this.all = all;
+	}
+	/** The events of one kind, typed: `events.of('death')`, `events.of('ping')` */
+	of(type) {
+		if (!this.byType) {
+			this.byType = /* @__PURE__ */ new Map();
+			for (const event of this.all) {
+				let list = this.byType.get(event.type);
+				if (!list) this.byType.set(event.type, list = []);
+				list.push(event);
+			}
+		}
+		return this.byType.get(type) ?? [];
+	}
+	/** What an event of the game's own said this tick (`defineEvent`, replicated to this player), each time it was emitted */
+	game(key) {
+		return this.of("game").filter((event) => event.event === key.id).map((event) => event.payload);
+	}
+};
+/**
+* A computer player's reading of its picture of the game (`Brain.view`): the snapshot of its seat, indexed once a
+* think and queried as sets (`UnitSet`): `mine`, `allies`, `enemies` (what is in sight now; `enemies.known()` adds
+* the structures remembered), `hostile` (enemies and creeps), `creeps`, `neutral`, `resources`, `all`; the player's
+* own state (`me`); what unit types are for (`roles`, `typesOf`); where things are (`near`, `home`, `bases`, `mines`,
+* `camps`, `regions`); how strong things are (`strength`: `odds`, `matchup`, `counterFor`) and where the strength
+* is (`threat`, the map made when first asked); what the game tells this player (`report`, `component`,
+* `events.game`); and the map's facts (`canPlace`, `findPath`, `cellAt`). Made from the snapshot as the think begins; a set of
+* it is good for the think
+*
+* @beta
+*/
+var AiView = class {
+	snapshot;
+	session;
+	/** The game's definitions, as the seat has them */
+	registry;
+	/** The player it reads for */
+	playerId;
+	/** Every entity the player knows of, in the snapshot's order: in sight, and the structures remembered */
+	all;
+	/** The player's own units and buildings */
+	mine;
+	/** The allies' units and buildings (one's own left out) */
+	allies;
+	/** The enemies' units and buildings in sight now, creeps left out. `enemies.known()` adds their structures seen before */
+	enemies;
+	/** Whatever attacks the player and is in sight: enemies and creeps */
+	hostile;
+	/** The creeps in sight: hostile to everyone, no one's rival */
+	creeps;
+	/** What is nobody's and not a resource, in sight: a shop, a neutral building. `neutral.known()` adds those seen before */
+	neutral;
+	/** The deposits the player knows of: mines and trees in sight, and those seen before (`ofResource(kind)` for one kind) */
+	resources;
+	/** Every player, as the snapshot has them */
+	players;
+	/** The player a brain plays: resources, supply, tech, heroes, objectives. Mutable for the think */
+	me;
+	/** What happened in the tick of the picture, by kind */
+	events;
+	/** What unit types are for, by the game's definitions: found once, kept while they stand */
+	roles;
+	/** The unit types the player has or can come to make: what the roles are narrowed to for it (`typesOf`) */
+	reachable;
+	/**
+	* How strong things are: a unit, a group, one force against another (`odds`), what answers what (`counterFor`). The
+	* kit's formula unless the brain was given one; what a type's numbers come to is kept between thinks
+	*/
+	strength;
+	threatMap;
+	grid;
+	byIdMap = /* @__PURE__ */ new Map();
+	indexById = /* @__PURE__ */ new Map();
+	playerById = /* @__PURE__ */ new Map();
+	namesMap = /* @__PURE__ */ new Map();
+	typesByRole;
+	/** The race the view's reach was found for: a player given another race finds it anew */
+	race;
+	basesFound;
+	lanesFound;
+	constructor(snapshot, session, options = {}) {
+		this.snapshot = snapshot;
+		this.session = session;
+		const { registry, playerId, terrain } = session;
+		this.registry = registry;
+		this.playerId = playerId;
+		this.players = snapshot.players;
+		for (const player of snapshot.players) this.playerById.set(player.id, player);
+		const self = this.playerById.get(playerId);
+		this.me = meOf(self, playerId);
+		this.events = new ViewEvents(snapshot.events);
+		this.grid = new Grid(terrain.width, terrain.depth, this.indexById);
+		const mine = [];
+		const allies = [];
+		const enemies = [];
+		const enemiesRemembered = [];
+		const hostile = [];
+		const hostileRemembered = [];
+		const creeps = [];
+		const creepsRemembered = [];
+		const neutral = [];
+		const neutralRemembered = [];
+		const resources = [];
+		const ownedTypes = /* @__PURE__ */ new Set();
+		snapshot.entities.forEach((entity, index) => {
+			this.byIdMap.set(entity.id, entity);
+			this.indexById.set(entity.id, index);
+			this.grid.add(entity);
+			if (entity.name !== void 0) this.namesMap.set(entity.name, entity);
+			if (entity.owner === playerId) {
+				mine.push(entity);
+				ownedTypes.add(entity.type);
+				return;
+			}
+			if (registry.units.has(entity.type) && registry.unit(entity.type).kind === "resource") {
+				resources.push(entity);
+				return;
+			}
+			const owner = this.playerById.get(entity.owner);
+			if (!owner) return;
+			if (owner.creeps) (entity.visible ? creeps : creepsRemembered).push(entity);
+			switch (owner.relation) {
+				case "ally":
+					if (!owner.creeps) allies.push(entity);
+					break;
+				case "enemy":
+					(entity.visible ? hostile : hostileRemembered).push(entity);
+					if (!owner.creeps) (entity.visible ? enemies : enemiesRemembered).push(entity);
+					break;
+				default: if (!owner.creeps) (entity.visible ? neutral : neutralRemembered).push(entity);
+			}
+		});
+		this.all = new UnitSet(this, snapshot.entities);
+		this.mine = new UnitSet(this, mine);
+		this.allies = new UnitSet(this, allies);
+		this.enemies = new UnitSet(this, enemies, enemiesRemembered);
+		this.hostile = new UnitSet(this, hostile, hostileRemembered);
+		this.creeps = new UnitSet(this, creeps, creepsRemembered);
+		this.neutral = new UnitSet(this, neutral, neutralRemembered);
+		this.resources = new UnitSet(this, resources);
+		const before = options.before;
+		const player = {
+			id: playerId,
+			race: self?.race,
+			availability: self?.own?.availability
+		};
+		this.race = self?.race;
+		this.roles = before?.roles ?? findRoles(registry, player, options.roles);
+		let kept = before && before.race === this.race && sameAvailability(before.me.availability, player.availability) ? before : void 0;
+		if (kept) {
+			const reach = kept.reachable;
+			for (const type of ownedTypes) if (!reach.has(type)) kept = void 0;
+		}
+		this.reachable = kept?.reachable ?? reachableTypes(registry, player, ownedTypes);
+		this.typesByRole = kept?.typesByRole ?? /* @__PURE__ */ new Map();
+		const formula = options.strength ?? before?.strength.formula;
+		this.strength = before && before.strength.formula === formula ? before.strength : new Strength(registry, formula);
+		this.strength.view = this;
+	}
+	/**
+	* Where the strength is: an influence map over the picture, the friendly and the enemy strength that reaches each
+	* cell of a coarse grid, by layer (`threat.at(point)`, `around`, `hot`). Made when first asked, once a think
+	*/
+	get threat() {
+		return this.threatMap ??= new ThreatMap(this);
+	}
+	/** @internal What is in the cells of the grid a circle touches, in the snapshot's order: for a set's `near` */
+	gridNear(point, radius) {
+		return this.grid.near(point, radius);
+	}
+	/** The tick of the picture */
+	get tick() {
+		return this.snapshot.tick;
+	}
+	/** Seconds into the game, as of the picture */
+	get time() {
+		return this.snapshot.tick / this.session.tickRate;
+	}
+	/** Items lying on the ground where the player sees it */
+	get items() {
+		return this.snapshot.items;
+	}
+	/** What the game tells the player about itself (`Rules.report`): a wave number, a score */
+	get report() {
+		return this.snapshot.report;
+	}
+	/** An entity the player knows of, by id: none for one gone, or never seen */
+	byId(id) {
+		return id === void 0 ? void 0 : this.byIdMap.get(id);
+	}
+	/** @internal Where an entity comes in the snapshot: for sets to keep its order */
+	indexOf(entity) {
+		return this.indexById.get(entity.id) ?? Infinity;
+	}
+	/** The definition of an entity's type */
+	def(entity) {
+		return this.registry.unit(entity.type);
+	}
+	/** A player, by id */
+	player(id) {
+		return this.playerById.get(id);
+	}
+	/** What an entity's owner is to the player: `self`, `ally`, `enemy`, `neutral`. Creeps are `enemy` */
+	relation(entity) {
+		return this.playerById.get(entity.owner)?.relation;
+	}
+	/** Whether an entity is a rival's, or a creep */
+	isHostile(entity) {
+		return this.relation(entity) === "enemy";
+	}
+	/** Whether an entity is a creep's */
+	isCreep(entity) {
+		return !!this.playerById.get(entity.owner)?.creeps;
+	}
+	/** Whether an entity is the player's own or an ally's */
+	isFriendly(entity) {
+		const relation = this.relation(entity);
+		return relation === "self" || relation === "ally";
+	}
+	/** The roles of an entity's type, or of a type by id */
+	roleOf(entity) {
+		return this.roles.of(typeof entity === "string" ? entity : entity.type);
+	}
+	/** Whether an entity's type, or a type by id, has a role */
+	hasRole(entity, role) {
+		return this.roles.has(typeof entity === "string" ? entity : entity.type, role);
+	}
+	/**
+	* The unit types with a role that are the player's own: those it has or can come to make (`reachable`), in the
+	* game's order, so that the first of a kind is the one meant first. A game of two races gives each player its own
+	*/
+	typesOf(role) {
+		let found = this.typesByRole.get(role);
+		if (!found) this.typesByRole.set(role, found = this.roles.types(role).filter((def) => this.reachable.has(def.id)));
+		return found;
+	}
+	/** Whether the player has the finished buildings something asks for (`UnitTypeDef.requires`) */
+	has(requires) {
+		return (requires ?? []).every((id) => this.me.tech.includes(id));
+	}
+	/** The player's home: its first hall, or its first building where it has no hall. None with no buildings */
+	home() {
+		return this.mine.withRole("hall").first() ?? this.mine.buildings().first();
+	}
+	/**
+	* The player's bases: its buildings clustered around what takes deposits (halls, what stands on a mine), each to
+	* the nearest of those within reach; and where there is nothing that takes deposits (a game with no economy), around
+	* any building, the clusters made as the buildings come. Home first
+	*/
+	bases() {
+		if (this.basesFound) return this.basesFound;
+		const buildings = this.mine.buildings();
+		const reach = 576;
+		const centres = [];
+		for (const building of buildings) {
+			if (!this.def(building).dropOff || centres.some((centre) => distSq(building, centre) < reach)) continue;
+			centres.push(building);
+		}
+		const members = /* @__PURE__ */ new Map();
+		for (const centre of centres) members.set(centre.id, []);
+		for (const building of buildings) {
+			let best;
+			let bestDistance = reach;
+			for (const centre of centres) {
+				const d = distSq(building, centre);
+				if (d < bestDistance) {
+					bestDistance = d;
+					best = centre;
+				}
+			}
+			if (!best) {
+				best = building;
+				centres.push(building);
+				members.set(building.id, []);
+			}
+			members.get(best.id).push(building);
+		}
+		return this.basesFound = centres.map((centre) => ({
+			at: {
+				x: centre.x,
+				z: centre.z
+			},
+			centre,
+			buildings: new UnitSet(this, members.get(centre.id))
+		}));
+	}
+	/** The deposits near a base, in sight or remembered: what it gathers from */
+	resourcesNear(base, radius = 24) {
+		return this.resources.near("at" in base ? base.at : base, radius);
+	}
+	/**
+	* Where the game's money is mined, as the map shows them, under the fog too (`GameSession.mines`): what a computer
+	* player looks to for another hall. Where the session does not say, the deposits of the money it knows of
+	*/
+	mines() {
+		const known = this.session.can.computer?.mines();
+		if (known) return known;
+		const money = this.registry.currency ?? this.registry.resources[0]?.id ?? "";
+		return this.resources.ofResource(money).map((mine) => ({
+			id: mine.id,
+			x: mine.x,
+			z: mine.z
+		}));
+	}
+	/** The creep camps of the map: where they are is part of the map, which everyone knows */
+	camps() {
+		return this.session.camps();
+	}
+	/**
+	* The lanes of the map (`GameSession.lanes`: its paths with a spawner of each side at their ends), as the map shows
+	* them: none where the session does not say, or the map has none. Read once a think
+	*/
+	lanes() {
+		return this.lanesFound ??= this.session.can.computer?.lanes() ?? [];
+	}
+	/** The regions of the map, by name, as the map was made */
+	get regions() {
+		return this.session.regions;
+	}
+	/** A region of the map, by name */
+	region(name) {
+		return this.session.regions.find((region) => region.name === name);
+	}
+	/** Whether a point is in a named region of the map. False for a region the map does not have */
+	inRegion(name, point) {
+		const region = this.region(name);
+		return !!region && inShape(region.shape, point);
+	}
+	/** An entity the map or the rules named (`world.named`), where the player knows of it: "the gate", "the hero" */
+	named(name) {
+		return this.namesMap.get(name);
+	}
+	/** What the game replicates to this player of an entity (`Component.replicate`), with the component's type */
+	component(entity, component) {
+		return entity.components?.[component.id];
+	}
+	/** Whether the player could build this here, as far as it can tell: no on ground it has not explored */
+	canPlace(unitType, point) {
+		return this.session.canPlace(unitType, point);
+	}
+	/** The value of one of the game's layers of cells at a point (`Terrain.cells`, `CellLayerDef`): 0 where it is not painted */
+	cellAt(layer, x, z) {
+		return this.session.terrain.cellAt(layer, x, z);
+	}
+	/** One of the game's layers of cells whole, row by row (`Terrain.cells`), to read and not to change: none where nothing is painted */
+	cells(layer) {
+		return this.session.terrain.cells[layer];
+	}
+	/** The route a unit would take, over the ground the player knows */
+	findPath(from, to, flying) {
+		return this.session.findPath(from, to, flying);
+	}
+	/** What the view found of the roles, for the debug tools: each role and its types among the player's own */
+	inspect() {
+		const roles = {};
+		for (const [role, types] of Object.entries(this.roles.report())) {
+			const own = types.filter((type) => this.reachable.has(type));
+			if (own.length) roles[role] = own;
+		}
+		return { roles };
+	}
+};
+/** The player's own state out of the snapshot: empty where the snapshot has none (a seat out of the game) */
+function meOf(self, id) {
+	const own = self?.own;
+	return {
+		id,
+		name: self?.name ?? "",
+		team: self?.team ?? 0,
+		...self?.race !== void 0 && { race: self.race },
+		defeated: self?.defeated ?? true,
+		resources: own?.resources ?? {},
+		supplyUsed: own?.supplyUsed ?? 0,
+		supplyCap: own?.supplyCap ?? 0,
+		...own?.supplies && { supplies: own.supplies },
+		upkeep: own?.upkeep ?? {
+			tier: 0,
+			name: "",
+			income: 1
+		},
+		upgrades: own?.upgrades ?? {},
+		researching: own?.researching ?? [],
+		tech: own?.tech ?? [],
+		heroes: own?.heroes ?? [],
+		objectives: own?.objectives ?? [],
+		...own?.unlocks && { unlocks: own.unlocks },
+		...own?.availability && { availability: own.availability }
+	};
+}
+/** Whether two of what the game's `available` hook decided are the same: by type, either left out as none */
+function sameAvailability(a, b) {
+	if (a === b) return true;
+	const keys = Object.keys(a ?? {});
+	if (keys.length !== Object.keys(b ?? {}).length) return false;
+	return keys.every((key) => a[key] === b?.[key]);
+}
+//#endregion
+export { AiView, UnitSet, ViewEvents };
+
+//# sourceMappingURL=view.js.map