@v12-engine/engine 0.1.1 → 0.4.0

package/dist/ai/threat.js

@@ -0,0 +1,206 @@
+import { distSq } from "../math.js";
+import { attackStat } from "../attacks.js";
+import "./reach.js";
+//#region src/ai/threat.ts
+/** Seconds of movement that count towards a unit's reach: what it could be hitting within a moment */
+var SPREAD = 1.5;
+/**
+* How much of a unit's strength a cell `d` away gets, for an attack reaching `range` (its size in): all of it within, fading
+* to nothing over `spread` past it
+*/
+function reachWeight(d, range, spread) {
+	const half = 4;
+	const reach = range + spread;
+	const fade = reach - range;
+	if (d <= range + half) return 1;
+	return fade > 0 && d < reach + half ? (reach + half - d) / fade : 0;
+}
+var ZERO = Object.freeze({
+	friendly: 0,
+	enemy: 0,
+	net: 0
+});
+/**
+* Where the strength is, on a coarse grid over the map (`AiView.threat`, `Brain.threat`): `at(point)` reads a place,
+* `around(point, radius)` the worst cell near it, `hot()` the cells where the enemy is strongest near what is one's
+* own, `cells()` every cell with something in it (for a drawing of it). Made from the view's picture when first asked,
+* once a think; all zeros for no point, or one off the map, so that a question about "the first base known" needs no
+* guard
+*
+* @beta
+*/
+var ThreatMap = class {
+	view;
+	/** Cells across and down, and the side of one */
+	cols;
+	/** How many cells down the grid has */
+	rows;
+	/** The side of a cell in cells of the map */
+	cell = 8;
+	seen;
+	withRemembered;
+	constructor(view) {
+		this.view = view;
+		const { terrain } = view.session;
+		this.cols = Math.max(1, Math.ceil(terrain.width / 8));
+		this.rows = Math.max(1, Math.ceil(terrain.depth / 8));
+	}
+	/** The grids of a reading, made when first asked */
+	grids(remembered) {
+		if (remembered) return this.withRemembered ??= this.build(true);
+		return this.seen ??= this.build(false);
+	}
+	/** One pass over the picture: each fighter painted onto the cells it reaches, on the layers it can hit */
+	build(remembered) {
+		const size = this.cols * this.rows;
+		const grids = {
+			friendly: {
+				ground: new Float64Array(size),
+				air: new Float64Array(size)
+			},
+			enemy: {
+				ground: new Float64Array(size),
+				air: new Float64Array(size)
+			}
+		};
+		const { view } = this;
+		for (const entity of view.mine) this.paint(grids.friendly, entity);
+		for (const entity of view.allies) this.paint(grids.friendly, entity);
+		const hostile = remembered ? view.hostile.known() : view.hostile;
+		for (const entity of hostile) this.paint(grids.enemy, entity);
+		return grids;
+	}
+	/** A unit's strength onto the cells within its reach: in full within its range, fading to nothing at the edge */
+	paint(side, entity) {
+		if (entity.health <= 0) return;
+		const { view } = this;
+		const def = view.def(entity);
+		const attacks = def.attacks;
+		if (!attacks?.length) return;
+		const strength = view.strength.of(entity);
+		if (!(strength > 0)) return;
+		const stats = view.strength.statsOf(entity, def);
+		let ground = -1;
+		let air = -1;
+		for (const attack of attacks) {
+			const { targets } = attack;
+			const range = attackStat(stats, attack, "range");
+			if (!targets || targets.some((entry) => entry !== "air")) ground = Math.max(ground, range);
+			if (targets?.includes("air")) air = Math.max(air, range);
+		}
+		if (ground < 0 && air < 0) return;
+		const spread = stats.moveSpeed * SPREAD;
+		const far = Math.max(ground, air) + def.radius + spread;
+		const c0 = this.col(entity.x - far);
+		const c1 = this.col(entity.x + far);
+		const r0 = this.row(entity.z - far);
+		const r1 = this.row(entity.z + far);
+		for (let r = r0; r <= r1; r++) for (let c = c0; c <= c1; c++) {
+			const nx = Math.max(c * 8, Math.min(entity.x, (c + 1) * 8));
+			const nz = Math.max(r * 8, Math.min(entity.z, (r + 1) * 8));
+			const d = Math.sqrt(distSq({
+				x: nx,
+				z: nz
+			}, entity));
+			const index = r * this.cols + c;
+			if (ground >= 0) side.ground[index] += strength * reachWeight(d, ground + def.radius, spread);
+			if (air >= 0) side.air[index] += strength * reachWeight(d, air + def.radius, spread);
+		}
+	}
+	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)));
+	}
+	/** Whether a point is on the map */
+	onMap(point) {
+		const { terrain } = this.view.session;
+		return point.x >= 0 && point.z >= 0 && point.x < terrain.width && point.z < terrain.depth;
+	}
+	read(grids, layer, index) {
+		const friendly = grids.friendly[layer][index];
+		const enemy = grids.enemy[layer][index];
+		return {
+			friendly,
+			enemy,
+			net: friendly - enemy
+		};
+	}
+	/**
+	* What reaches a place: the friendly and the enemy strength at its cell, on a layer (`ground` when left out). All
+	* zeros for no point or one off the map
+	*/
+	at(point, query = {}) {
+		if (!point || !this.onMap(point)) return ZERO;
+		const grids = this.grids(!!query.remembered);
+		return this.read(grids, query.layer ?? "ground", this.row(point.z) * this.cols + this.col(point.x));
+	}
+	/** The worst cell within a distance of a point: the one the most enemy strength reaches. Zeros off the map */
+	around(point, radius, query = {}) {
+		if (!point || !this.onMap(point)) return ZERO;
+		const grids = this.grids(!!query.remembered);
+		const layer = query.layer ?? "ground";
+		let worst = ZERO;
+		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 found = this.read(grids, layer, r * this.cols + c);
+			if (found.enemy > worst.enemy || worst === ZERO && found.friendly > 0) worst = found;
+		}
+		return worst;
+	}
+	/**
+	* Where the enemy is strongest near what is one's own: the cells that enemy strength reaches and that hold a unit or
+	* building of the player's (an ally's with `owner`), the hottest first. A raid at an expansion reads here while the
+	* main is quiet
+	*/
+	hot(query = {}) {
+		const grids = this.grids(!!query.remembered);
+		const layer = query.layer ?? "ground";
+		const own = query.owner === void 0 ? this.view.mine : this.view.all.ofOwner(query.owner);
+		const held = /* @__PURE__ */ new Set();
+		for (const entity of own) held.add(this.row(entity.z) * this.cols + this.col(entity.x));
+		const cells = [];
+		for (let index = 0; index < this.cols * this.rows; index++) {
+			if (!held.has(index)) continue;
+			const found = this.read(grids, layer, index);
+			if (found.enemy > 0) cells.push(this.cellOf(index, found));
+		}
+		return cells.sort((a, b) => b.enemy - a.enemy);
+	}
+	/** Every cell that any strength reaches on a layer, in the grid's order: for a drawing of the map */
+	cells(query = {}) {
+		const grids = this.grids(!!query.remembered);
+		const layer = query.layer ?? "ground";
+		const cells = [];
+		for (let index = 0; index < this.cols * this.rows; index++) {
+			const found = this.read(grids, layer, index);
+			if (found.friendly > 0 || found.enemy > 0) cells.push(this.cellOf(index, found));
+		}
+		return cells;
+	}
+	cellOf(index, found) {
+		const col = index % this.cols;
+		const row = Math.floor(index / this.cols);
+		return {
+			...found,
+			at: {
+				x: (col + .5) * 8,
+				z: (row + .5) * 8
+			},
+			col,
+			row
+		};
+	}
+	/** Whether a reading has been made this think: for the timing and the debug tools */
+	get built() {
+		return this.seen !== void 0 || this.withRemembered !== void 0;
+	}
+};
+//#endregion
+export { ThreatMap };
+
+//# sourceMappingURL=threat.js.map

package/dist/ai/threat.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"threat.js","names":[],"sources":["../../src/ai/threat.ts"],"sourcesContent":["import type { Layer } from '#engine/defs'\nimport { attackStat } from '#engine/attacks'\nimport { distSq, type Vec2 } from '#engine/math'\nimport type { EntityState } from '#engine/session/protocol'\nimport type { AiView } from './view'\nimport { CELL } from './reach'\n\n/*\n * The threat map: where the strength is (AI plan, A4). An **influence map**, the standard idea written plainly: a\n * coarse grid over the map where each cell holds the strength of the friendly units and of the enemy units that can\n * reach it. A brain's questions about places become reads of a few cells: \"is my expansion in danger\" is the enemy\n * strength at its cell, \"where is it safe\" is where the net is friendly, \"where are they raiding\" is the hot cells\n * near what is mine. It is cheap to make (one pass over what is in sight, each unit painted onto the cells it reaches)\n * and made only when something asks, once a think (`AiView.threat`): the view is of one think, and so is this.\n *\n * Reach is the unit's range, and a little more for its speed: what it could be hitting within a moment. Strength is\n * painted in full within range and fades to nothing at the edge of reach. Two layers are kept, for what a unit can\n * hit: `ground` holds the strength of what reaches things on the ground, `air` of what reaches things in the air, so\n * that gryphons over footmen read as safe in the air and a tower reads on both. Built from what is in sight only;\n * `remembered: true` adds the enemy structures seen before and out of sight (their towers), which may be gone\n */\n\n/** Seconds of movement that count towards a unit's reach: what it could be hitting within a moment */\nconst SPREAD = 1.5\n\n/**\n * How much of a unit's strength a cell `d` away gets, for an attack reaching `range` (its size in): all of it within, fading\n * to nothing over `spread` past it\n */\nfunction reachWeight(d: number, range: number, spread: number): number {\n\tconst half = CELL / 2\n\tconst reach = range + spread\n\tconst fade = reach - range\n\tif (d <= range + half) return 1\n\treturn fade > 0 && d < reach + half ? (reach + half - d) / fade : 0\n}\n\n/**\n * What the threat map reads at a place: the strength of the friendly units (one's own and allies') and of the enemy\n * units (rivals' and creeps') that can reach it, and the difference\n *\n * @beta\n */\nexport interface Threat {\n\t/** The strength of one's own and allies' units that reach the place */\n\tfriendly: number\n\t/** The strength of rivals' and creeps' units that reach it */\n\tenemy: number\n\t/** `friendly - enemy`: above 0 where one's own side is stronger */\n\tnet: number\n}\n\n/**\n * A cell of the threat map with what it reads (`ThreatMap.hot`, `cells`)\n *\n * @beta\n */\nexport interface ThreatCell extends Threat {\n\t/** The middle of the cell */\n\tat: Vec2\n\t/** The cell's column on the grid, counted from 0 */\n\tcol: number\n\t/** The cell's row on the grid, counted from 0 */\n\trow: number\n}\n\n/**\n * What a read of the map is for: the layer the thing asked about is on (`ground` when left out: what can reach things\n * on the ground), and whether the enemy structures remembered and out of sight count too (a tower seen before)\n *\n * @beta\n */\nexport interface ThreatQuery {\n\t/** The layer the thing asked about is on; `ground` when left out */\n\tlayer?: Layer\n\t/** Whether enemy structures remembered but out of sight count too */\n\tremembered?: boolean\n}\n\nconst ZERO: Threat = Object.freeze({ friendly: 0, enemy: 0, net: 0 })\n\n/** The two grids of one reading: what can reach the ground, what can reach the air */\ninterface Grids {\n\tfriendly: Record<Layer, Float64Array>\n\tenemy: Record<Layer, Float64Array>\n}\n\n/**\n * Where the strength is, on a coarse grid over the map (`AiView.threat`, `Brain.threat`): `at(point)` reads a place,\n * `around(point, radius)` the worst cell near it, `hot()` the cells where the enemy is strongest near what is one's\n * own, `cells()` every cell with something in it (for a drawing of it). Made from the view's picture when first asked,\n * once a think; all zeros for no point, or one off the map, so that a question about \"the first base known\" needs no\n * guard\n *\n * @beta\n */\nexport class ThreatMap {\n\t/** Cells across and down, and the side of one */\n\treadonly cols: number\n\t/** How many cells down the grid has */\n\treadonly rows: number\n\t/** The side of a cell in cells of the map */\n\treadonly cell = CELL\n\tprivate seen: Grids | undefined\n\tprivate withRemembered: Grids | undefined\n\n\tconstructor(\n\t\t/** The picture it is made from */\n\t\treadonly view: AiView\n\t) {\n\t\tconst { terrain } = view.session\n\t\tthis.cols = Math.max(1, Math.ceil(terrain.width / CELL))\n\t\tthis.rows = Math.max(1, Math.ceil(terrain.depth / CELL))\n\t}\n\n\t/** The grids of a reading, made when first asked */\n\tprivate grids(remembered: boolean): Grids {\n\t\tif (remembered) return (this.withRemembered ??= this.build(true))\n\t\treturn (this.seen ??= this.build(false))\n\t}\n\n\t/** One pass over the picture: each fighter painted onto the cells it reaches, on the layers it can hit */\n\tprivate build(remembered: boolean): Grids {\n\t\tconst size = this.cols * this.rows\n\t\tconst grids: Grids = {\n\t\t\tfriendly: { ground: new Float64Array(size), air: new Float64Array(size) },\n\t\t\tenemy: { ground: new Float64Array(size), air: new Float64Array(size) }\n\t\t}\n\t\tconst { view } = this\n\t\tfor (const entity of view.mine) this.paint(grids.friendly, entity)\n\t\tfor (const entity of view.allies) this.paint(grids.friendly, entity)\n\t\tconst hostile = remembered ? view.hostile.known() : view.hostile\n\t\tfor (const entity of hostile) this.paint(grids.enemy, entity)\n\t\treturn grids\n\t}\n\n\t/** A unit's strength onto the cells within its reach: in full within its range, fading to nothing at the edge */\n\tprivate paint(side: Record<Layer, Float64Array>, entity: EntityState): void {\n\t\tif (entity.health <= 0) return\n\t\tconst { view } = this\n\t\tconst def = view.def(entity)\n\t\tconst attacks = def.attacks\n\t\tif (!attacks?.length) return\n\t\tconst strength = view.strength.of(entity)\n\t\tif (!(strength > 0)) return\n\t\tconst stats = view.strength.statsOf(entity, def)\n\t\t// how far it reaches each layer: the farthest of its attacks that hit there, -1 for none\n\t\tlet ground = -1\n\t\tlet air = -1\n\t\tfor (const attack of attacks) {\n\t\t\tconst { targets } = attack\n\t\t\tconst range = attackStat(stats, attack, 'range')\n\t\t\tif (!targets || targets.some((entry) => entry !== 'air')) ground = Math.max(ground, range)\n\t\t\tif (targets?.includes('air')) air = Math.max(air, range)\n\t\t}\n\t\tif (ground < 0 && air < 0) return\n\t\tconst spread = stats.moveSpeed * SPREAD\n\t\tconst far = Math.max(ground, air) + def.radius + spread\n\t\tconst c0 = this.col(entity.x - far)\n\t\tconst c1 = this.col(entity.x + far)\n\t\tconst r0 = this.row(entity.z - far)\n\t\tconst r1 = this.row(entity.z + far)\n\t\tfor (let r = r0; r <= r1; r++) {\n\t\t\tfor (let c = c0; c <= c1; c++) {\n\t\t\t\t// the nearest point of the cell to the unit: a cell it stands in or touches with its range is within it in full\n\t\t\t\tconst nx = Math.max(c * CELL, Math.min(entity.x, (c + 1) * CELL))\n\t\t\t\tconst nz = Math.max(r * CELL, Math.min(entity.z, (r + 1) * CELL))\n\t\t\t\tconst d = Math.sqrt(distSq({ x: nx, z: nz }, entity))\n\t\t\t\tconst index = r * this.cols + c\n\t\t\t\tif (ground >= 0) side.ground[index] += strength * reachWeight(d, ground + def.radius, spread)\n\t\t\t\tif (air >= 0) side.air[index] += strength * reachWeight(d, air + def.radius, spread)\n\t\t\t}\n\t\t}\n\t}\n\n\tprivate col(x: number): number {\n\t\treturn Math.min(this.cols - 1, Math.max(0, Math.floor(x / CELL)))\n\t}\n\n\tprivate row(z: number): number {\n\t\treturn Math.min(this.rows - 1, Math.max(0, Math.floor(z / CELL)))\n\t}\n\n\t/** Whether a point is on the map */\n\tprivate onMap(point: Vec2): boolean {\n\t\tconst { terrain } = this.view.session\n\t\treturn point.x >= 0 && point.z >= 0 && point.x < terrain.width && point.z < terrain.depth\n\t}\n\n\tprivate read(grids: Grids, layer: Layer, index: number): Threat {\n\t\tconst friendly = grids.friendly[layer][index]\n\t\tconst enemy = grids.enemy[layer][index]\n\t\treturn { friendly, enemy, net: friendly - enemy }\n\t}\n\n\t/**\n\t * What reaches a place: the friendly and the enemy strength at its cell, on a layer (`ground` when left out). All\n\t * zeros for no point or one off the map\n\t */\n\tat(point: Vec2 | undefined, query: ThreatQuery = {}): Threat {\n\t\tif (!point || !this.onMap(point)) return ZERO\n\t\tconst grids = this.grids(!!query.remembered)\n\t\treturn this.read(grids, query.layer ?? 'ground', this.row(point.z) * this.cols + this.col(point.x))\n\t}\n\n\t/** The worst cell within a distance of a point: the one the most enemy strength reaches. Zeros off the map */\n\taround(point: Vec2 | undefined, radius: number, query: ThreatQuery = {}): Threat {\n\t\tif (!point || !this.onMap(point)) return ZERO\n\t\tconst grids = this.grids(!!query.remembered)\n\t\tconst layer = query.layer ?? 'ground'\n\t\tlet worst = ZERO\n\t\tconst c0 = this.col(point.x - radius)\n\t\tconst c1 = this.col(point.x + radius)\n\t\tconst r0 = this.row(point.z - radius)\n\t\tconst r1 = this.row(point.z + radius)\n\t\tfor (let r = r0; r <= r1; r++) {\n\t\t\tfor (let c = c0; c <= c1; c++) {\n\t\t\t\tconst found = this.read(grids, layer, r * this.cols + c)\n\t\t\t\tif (found.enemy > worst.enemy || (worst === ZERO && found.friendly > 0)) worst = found\n\t\t\t}\n\t\t}\n\t\treturn worst\n\t}\n\n\t/**\n\t * Where the enemy is strongest near what is one's own: the cells that enemy strength reaches and that hold a unit or\n\t * building of the player's (an ally's with `owner`), the hottest first. A raid at an expansion reads here while the\n\t * main is quiet\n\t */\n\thot(query: ThreatQuery & { owner?: number } = {}): ThreatCell[] {\n\t\tconst grids = this.grids(!!query.remembered)\n\t\tconst layer = query.layer ?? 'ground'\n\t\tconst own = query.owner === undefined ? this.view.mine : this.view.all.ofOwner(query.owner)\n\t\tconst held = new Set<number>()\n\t\tfor (const entity of own) held.add(this.row(entity.z) * this.cols + this.col(entity.x))\n\t\tconst cells: ThreatCell[] = []\n\t\t// in the grid's order, so that equals come out the same every time\n\t\tfor (let index = 0; index < this.cols * this.rows; index++) {\n\t\t\tif (!held.has(index)) continue\n\t\t\tconst found = this.read(grids, layer, index)\n\t\t\tif (found.enemy > 0) cells.push(this.cellOf(index, found))\n\t\t}\n\t\treturn cells.sort((a, b) => b.enemy - a.enemy)\n\t}\n\n\t/** Every cell that any strength reaches on a layer, in the grid's order: for a drawing of the map */\n\tcells(query: ThreatQuery = {}): ThreatCell[] {\n\t\tconst grids = this.grids(!!query.remembered)\n\t\tconst layer = query.layer ?? 'ground'\n\t\tconst cells: ThreatCell[] = []\n\t\tfor (let index = 0; index < this.cols * this.rows; index++) {\n\t\t\tconst found = this.read(grids, layer, index)\n\t\t\tif (found.friendly > 0 || found.enemy > 0) cells.push(this.cellOf(index, found))\n\t\t}\n\t\treturn cells\n\t}\n\n\tprivate cellOf(index: number, found: Threat): ThreatCell {\n\t\tconst col = index % this.cols\n\t\tconst row = Math.floor(index / this.cols)\n\t\treturn { ...found, at: { x: (col + 0.5) * CELL, z: (row + 0.5) * CELL }, col, row }\n\t}\n\n\t/** Whether a reading has been made this think: for the timing and the debug tools */\n\tget built(): boolean {\n\t\treturn this.seen !== undefined || this.withRemembered !== undefined\n\t}\n}\n"],"mappings":"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"}

package/dist/ai/view.d.ts

@@ -1,5 +1,5 @@
 import type { Component } from '#engine/components';
-import type { ResourceKind, UnitTypeDef } from '#engine/defs';
+import type { ResourceId, UnitTypeDef } from '#engine/defs';
 import type { PlayerId } from '#engine/entity';
 import type { EventKey } from '#engine/events';
 import type { Lane } from '#engine/lanes';
@@ -40,6 +40,7 @@ export declare class UnitSet implements Iterable<EntityState> {
     items?: readonly EntityState[], remembered?: EntityState[]);
     /** How many */
     get length(): number;
+    /** Iterates the set's entities in order */
     [Symbol.iterator](): Iterator<EntityState>;
     /** The first of them: none in an empty set */
     first(): EntityState | undefined;
@@ -51,9 +52,13 @@ export declare class UnitSet implements Iterable<EntityState> {
     map<T>(fn: (entity: EntityState, index: number) => T): T[];
     /** As an array does: a plain array. `where` gives a set */
     filter(fn: (entity: EntityState, index: number) => unknown): EntityState[];
+    /** The first entity `fn` is true for, or nothing; `fn` is given the entity and its index */
     find(fn: (entity: EntityState, index: number) => unknown): EntityState | undefined;
+    /** Whether `fn` is true for any entity of the set */
     some(fn: (entity: EntityState, index: number) => unknown): boolean;
+    /** Whether `fn` is true for every entity of the set */
     every(fn: (entity: EntityState, index: number) => unknown): boolean;
+    /** Calls `fn` with each entity and its index, in order */
     forEach(fn: (entity: EntityState, index: number) => void): void;
     /** A set of these, of the same view */
     private make;
@@ -86,7 +91,7 @@ export declare class UnitSet implements Iterable<EntityState> {
     /** Those with health left */
     alive(): UnitSet;
     /** Deposits of a resource with something left in them (a gold mine, a tree): for the view's `resources` */
-    ofResource(kind: ResourceKind): UnitSet;
+    ofResource(kind: ResourceId): UnitSet;
     /** Those of a player */
     ofOwner(player: PlayerId): UnitSet;
     /**
@@ -124,17 +129,23 @@ export declare class UnitSet implements Iterable<EntityState> {
  * @beta
  */
 export interface Me {
+    /** The player's id */
     id: PlayerId;
+    /** The player's name */
     name: string;
+    /** The player's team number */
     team: number;
     /** The race they play (`raceOf`): left out in a game without races */
     race?: string;
+    /** Whether the player is out of the game */
     defeated: boolean;
     /** What they have of each resource, by resource id */
-    resources: Record<ResourceKind, number>;
+    resources: Record<ResourceId, number>;
+    /** How much supply the player's units and queues use */
     supplyUsed: number;
+    /** How much supply the player may use at most */
     supplyCap: number;
-    /** The game's other pools of supply, by name (`GameRules.supply.pools`) */
+    /** The game's other pools of supply, by name (`RuleSettings.supply.pools`) */
     supplies?: Record<string, {
         used: number;
         cap: number;
@@ -145,10 +156,13 @@ export interface Me {
         name: string;
         income: number;
     };
+    /** The levels of the upgrades the player has, by upgrade id */
     upgrades: Record<string, number>;
+    /** The ids of the upgrades being researched */
     researching: string[];
     /** Types of the finished buildings the player has, with what those count as */
     tech: string[];
+    /** The player's heroes, each in short */
     heroes: HeroSummary[];
     /** What the player is set to do, in a mission. Empty in a game without objectives */
     objectives: ObjectiveState[];
@@ -160,12 +174,12 @@ export interface Me {
      * What the player gathers of each resource a minute, of late, as the brain's knowledge works it out
      * (`Knowledge.own.income`): set by the brain after the view is made; left out for a view of no brain's
      */
-    income?: Record<ResourceKind, number>;
+    income?: Record<ResourceId, number>;
     /**
      * What is free to spend this think, by resource: the resources less what is promised and held, less what the think
      * spent so far (the brain's purse, `ai.purse`). Set by the brain after the view is made; left out for a view of no brain's
      */
-    purse?: Readonly<Record<ResourceKind, number>>;
+    purse?: Readonly<Record<ResourceId, number>>;
 }
 /**
  * One of a player's bases, as the view clusters its buildings: around each building that takes deposits (a hall, what
@@ -294,7 +308,7 @@ export declare class AiView {
     get time(): number;
     /** Items lying on the ground where the player sees it */
     get items(): readonly GroundItemState[];
-    /** What the game tells the player about itself (`GameModule.report`): a wave number, a score */
+    /** What the game tells the player about itself (`Rules.report`): a wave number, a score */
     get report(): Record<string, unknown> | undefined;
     /** An entity the player knows of, by id: none for one gone, or never seen */
     byId(id: number | undefined): EntityState | undefined;