@v12-engine/engine 0.0.0-stage → 0.1.0

package/dist/sides.d.ts

@@ -0,0 +1,75 @@
+import type { Entity, PlayerId } from './entity';
+import type { PlayerRelation, World } from './world';
+export declare const relations: import("./components").Component<{
+    pairs: Record<number, PlayerRelation>;
+}, {
+    pairs: Record<number, PlayerRelation>;
+}>;
+/** Teams that see what others see: by the team that sees, those it shares with */
+export declare const vision: import("./components").Component<{
+    teams: Record<number, number[]>;
+}, {
+    teams: Record<number, number[]>;
+}>;
+/** Who may command whose units besides their owner (`shareControl`): by the owner, the players given control. Kept in the world */
+export declare const control: import("./components").Component<{
+    players: Record<number, number[]>;
+}, {
+    players: Record<number, number[]>;
+}>;
+/**
+ * Who is on whose side: kept in the world's state, so a save has it
+ *
+ * @beta
+ */
+export declare class Sides {
+    private readonly world;
+    constructor(world: World);
+    /** Whether everyone on a team is out */
+    teamDefeated(team: number): boolean;
+    /** Whether two players fight each other: their teams, or what they were set to be (`setRelation`) */
+    enemies(a: PlayerId, b: PlayerId): boolean;
+    /**
+     * What two players are to each other from now on, whatever their teams: `ally`, `enemy`, or `neutral` (neither).
+     * Null goes back to what their teams say. Creeps that turn friendly to one player; a ceasefire. Kept in the world:
+     * a save has it. Sight stays the teams' (see `shareVision`)
+     */
+    setRelation(a: PlayerId, b: PlayerId, relation: PlayerRelation | null): void;
+    /** What two players were set to be to each other (`setRelation`), if anything */
+    relationOf(a: PlayerId, b: PlayerId): PlayerRelation | undefined;
+    /**
+     * Moves a player to another team, one there is or a new one: whom they fight and see with follows. What their units
+     * were doing goes on; what they fought that is now a friend, they stop fighting on their own
+     */
+    setTeam(player: PlayerId, team: number): void;
+    /**
+     * Lets one team see what another sees, from now on, or no longer: shared vision without an alliance. Kept in the
+     * world. A team sees what its own units see as ever
+     */
+    shareVision(from: number, to: number, shared?: boolean): void;
+    /** The teams that see what this one sees, besides itself */
+    visionOf(team: number): readonly number[];
+    /**
+     * Lets a player command another's units, from now on, or no longer: shared control, as allies in a melee game give
+     * each other (a map's force with `sharedControl` gives it to every player of the force). Kept in the world. Who may
+     * command what is `mayCommand`, which the rules may widen or narrow (`GameRules.mayCommand`)
+     */
+    shareControl(owner: PlayerId, withPlayer: PlayerId, shared?: boolean): void;
+    /** The players who may command this one's units, besides the owner (`shareControl`) */
+    controlOf(owner: PlayerId): readonly PlayerId[];
+    /**
+     * Shares what a player has with another, from now on, or no longer: their units' control (`shareControl`) and
+     * what their team sees (`shareVision`, team to team)
+     */
+    share(player: PlayerId, withPlayer: PlayerId, what: {
+        control?: boolean;
+        vision?: boolean;
+    }): void;
+    /**
+     * Whether a player may command an entity: its owner, whoever the owner shares control with, and whatever else the
+     * rules say (`GameRules.mayCommand`). What every command of the player's is checked against
+     */
+    mayCommand(player: PlayerId, entity: Entity): boolean;
+    /** Whether two players are on one side: one player, a team, or what they were set to be (`setRelation`) */
+    allies(a: PlayerId, b: PlayerId): boolean;
+}

package/dist/sight.d.ts

@@ -0,0 +1,27 @@
+import type { Entity } from './entity';
+import type { World } from './world';
+/**
+ * What each team sees of a world's entities
+ *
+ * @beta
+ */
+export declare class Sight {
+    private readonly world;
+    /**
+     * What is handed to the `visible` handlers, again and again, so that asking allocates nothing: the world's own, a
+     * handler that asks again getting an object of its own
+     */
+    private readonly asking;
+    constructor(world: World);
+    /** Whether a team currently sees the entity */
+    sees(entity: Entity, team: number): boolean;
+    /** Whether an entity is invisible right now: by its type (`invisible`), or a buff that says so */
+    isInvisible(entity: Entity): boolean;
+    /** Whether a team sees an entity of someone else's, by the fog and what is invisible */
+    private inSight;
+    /**
+     * Whether a team has ever laid eyes on the entity. Kept up to date for structures only, see the fog system.
+     * A team that sees the whole map (out of the game, or a debug switch) has seen everything there is
+     */
+    hasSeen(entity: Entity, team: number): boolean;
+}

package/dist/simulate-oXBiw1Ff.js

@@ -0,0 +1,167 @@
+import "./debugCommands-CzjrSm66.js";
+import { a as createWorldFromMap } from "./game-DiJEN-Ks.js";
+//#region src/simulate.ts
+/** A simulation, as a module that a worker imports gives it: as it is written, for its type *
+* @beta
+*/
+var defineSimulation = (simulation) => simulation;
+/** Plays one game of a simulation from a seed, in this thread *
+* @beta
+*/
+async function playGame(simulation, seed) {
+	const began = performance.now();
+	const { game, map } = simulation;
+	const world = await createWorldFromMap({
+		map: structuredClone(map),
+		game,
+		seed,
+		onError: "end"
+	});
+	try {
+		const starts = map.players.filter((player) => player.start && player.id !== 90);
+		const computers = simulation.computers ?? starts.map((player) => player.id);
+		simulation.start?.(world);
+		for (const player of computers) {
+			const enemyBases = starts.filter((other) => other.id !== player && world.areEnemies(player, other.id)).map((other) => other.start);
+			const named = simulation.brains?.[player];
+			const brain = typeof named === "string" ? world.computers.brain(named) : named;
+			if (typeof named === "string" && !brain) throw new Error(`No brain is called "${named}": list it in GameModule.brains, or give the brain itself`);
+			const difficulty = simulation.difficulties?.[player];
+			const options = {
+				enemyBases,
+				...difficulty !== void 0 && { difficulty },
+				...simulation.ai?.(player, world)
+			};
+			world.computers.seat(player, {
+				...options,
+				brain
+			});
+		}
+		const until = simulation.until ?? ((done) => done.winner !== null);
+		const ticks = Math.ceil((simulation.seconds ?? 1200) * world.tickRate);
+		let tick = 0;
+		while (tick < ticks && !world.failure && !until(world)) {
+			world.step();
+			tick++;
+		}
+		const seconds = tick / world.tickRate;
+		const measures = {};
+		for (const player of computers) {
+			const computer = world.computers.get(player)?.computer;
+			const stats = computer?.stats;
+			if (!stats) continue;
+			const team = world.players.get(player)?.team ?? player;
+			measures[player] = {
+				...computer?.def?.id !== void 0 && { brain: computer.def.id },
+				team,
+				won: world.winner !== null && world.winner === team,
+				commandsAMinute: seconds > 0 ? stats.commands / seconds * 60 : 0,
+				idleArmySeconds: stats.idleArmySeconds,
+				churn: stats.churn,
+				blockedOnMoney: stats.blockedOnMoney,
+				refused: stats.refused,
+				held: stats.held
+			};
+		}
+		return {
+			seed,
+			winner: world.winner,
+			seconds,
+			ticks: tick,
+			...world.failure && { failed: world.failure.message },
+			measured: simulation.measure?.(world) ?? {},
+			computers: measures,
+			took: performance.now() - began
+		};
+	} finally {
+		world.dispose();
+	}
+}
+/**
+* The win rate of each brain over games of `simulate`, by brain id (`ComputerMeasures.brain`): what a balance run of two
+* brains reads. A seat that named no brain is left out
+*
+*     const games = await simulate({ ...duel, brains: { 1: meleeBrain, 2: myBrain } }, { seeds })
+*     winRates(games) // { 'core.melee': { rate: 0.4, … }, 'mygame.brain': { rate: 0.55, … } }
+*
+* @beta
+*/
+function winRates(games) {
+	const results = {};
+	for (const game of games) for (const measures of Object.values(game.computers)) {
+		if (measures.brain === void 0) continue;
+		const result = results[measures.brain] ??= {
+			games: 0,
+			wins: 0,
+			losses: 0,
+			draws: 0,
+			rate: 0,
+			decided: 0
+		};
+		result.games++;
+		if (measures.won) result.wins++;
+		else if (game.winner === null) result.draws++;
+		else result.losses++;
+	}
+	for (const result of Object.values(results)) {
+		result.rate = result.games ? result.wins / result.games : 0;
+		result.decided = result.wins + result.losses ? result.wins / (result.wins + result.losses) : 0;
+	}
+	return results;
+}
+/**
+* Plays games of a simulation, one from each seed, and gives what each ended in, in the order of the seeds. Given as
+* it is, they are played in this thread. Given as the address of a file (a module whose `default`, or `simulation`, is
+* one: `defineSimulation`), each worker thread imports it and plays its share: in Node, from the built packages (a
+* worker loads JavaScript, not the TypeScript of this repository)
+*
+* @beta
+*/
+async function simulate(simulation, options) {
+	if (typeof simulation !== "string" && !(simulation instanceof URL)) {
+		const games = [];
+		for (const seed of options.seeds) {
+			const game = await playGame(simulation, seed);
+			options.onGame?.(game);
+			games.push(game);
+		}
+		return games;
+	}
+	const { Worker } = await import("node:worker_threads");
+	const { availableParallelism } = await import("node:os");
+	const module = String(simulation);
+	const count = Math.max(1, Math.min(options.workers ?? availableParallelism() - 1, options.seeds.length));
+	const script = new URL("simulate-worker.js", import.meta.url);
+	const results = /* @__PURE__ */ new Map();
+	const queue = [...options.seeds];
+	await Promise.all(Array.from({ length: count }, () => new Promise((resolve, reject) => {
+		const worker = new Worker(script);
+		const next = () => {
+			const seed = queue.shift();
+			if (seed === void 0) {
+				worker.terminate();
+				return resolve();
+			}
+			worker.postMessage({
+				module,
+				seed
+			});
+		};
+		worker.on("message", (message) => {
+			if (message.error !== void 0) {
+				worker.terminate();
+				return reject(new Error(message.error));
+			}
+			results.set(message.game.seed, message.game);
+			options.onGame?.(message.game);
+			next();
+		});
+		worker.on("error", reject);
+		next();
+	})));
+	return options.seeds.map((seed) => results.get(seed));
+}
+//#endregion
+export { winRates as i, playGame as n, simulate as r, defineSimulation as t };
+
+//# sourceMappingURL=simulate-oXBiw1Ff.js.map

package/dist/simulate-oXBiw1Ff.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"simulate-oXBiw1Ff.js","names":[],"sources":["../src/simulate.ts"],"sourcesContent":["import type { AiOptions } from './ai/options'\nimport type { AiStats } from './ai/report'\nimport type { BrainDef } from './ai/brain'\nimport type { PlayerId } from './entity'\nimport { createWorldFromMap, type GameModule } from './game'\nimport { type GameMap, MAP_CREEPS } from './map'\nimport type { World } from './world'\n\n/*\n * Many games at once, for balance (S43): games of a game played at full speed by the computer, from seeds, each\n * ending in plain data (who won, how long it took, what the game asked to count). The same seed gives the same game.\n * In this thread (`simulate(simulation, …)`), or in worker threads, each of which imports the game itself from a file\n * (`simulate(url, { workers })`): a game's rules are functions, which cannot be sent to another thread.\n */\n\n/**\n * What a value counted at the end of a game may be: plain data, which comes back from a worker as it went\n *\n * @beta\n */\nexport type Counted = number | string | boolean | null\n\n/**\n * A game to play many times (`simulate`): the rules, the map, who the computer plays and how, and what to count\n *\n * @beta\n */\nexport interface Simulation {\n\tgame: GameModule\n\tmap: GameMap\n\t/**\n\t * The players the computer plays: every player of the map with a start, the creeps apart, when left out. One left\n\t * out is the game's own (`start`) to move, or stands\n\t */\n\tcomputers?: PlayerId[]\n\t/**\n\t * The brain each player is played by, or its id (one the game lists in `GameModule.brains`, or the engine's\n\t * `core.melee`): two brains against each other, for a balance run. A player not named here is played by the first\n\t * brain the game lists\n\t */\n\tbrains?: Record<number, BrainDef | string>\n\t/**\n\t * How hard each player's computer plays, by name (`'hard'`): under what `ai` gives. The seat's own when left out\n\t */\n\tdifficulties?: Record<number, string>\n\t/** How the computer plays a player, over what it is given (`enemyBases`: where the others start) */\n\tai?: (player: PlayerId, world: World) => Partial<AiOptions>\n\t/** What the game does once a world is made, before the first tick: units of its own, a rule turned on */\n\tstart?: (world: World) => void\n\t/** Seconds of the game at most: twenty minutes when left out */\n\tseconds?: number\n\t/** Whether the game is over before that: once there is a winner, when left out */\n\tuntil?: (world: World) => boolean\n\t/** What to count at the end of each game, by name: units alive, gold gathered, the hour */\n\tmeasure?: (world: World) => Record<string, Counted>\n}\n\n/**\n * How a computer player played one game, beside who won (`SimulatedGame.computers`): the numbers that say whether a\n * brain plays well, not only whether it won (`AiStats`, the brain's own counts, by the minute where it says so)\n *\n * @beta\n */\nexport interface ComputerMeasures {\n\t/** The brain that played the seat, by id: none for the first the game lists, seated by none named */\n\tbrain?: string\n\t/** The team the seat played for */\n\tteam: number\n\t/** Whether its team won: false for a draw too */\n\twon: boolean\n\t/** Commands sent a minute of the game */\n\tcommandsAMinute: number\n\t/** Seconds its fighters stood idle, summed over the fighters */\n\tidleArmySeconds: number\n\t/** Orders sent to a unit again for the same thing within a few seconds */\n\tchurn: number\n\t/** Seconds its building waited on money */\n\tblockedOnMoney: number\n\t/** Commands the game refused */\n\trefused: number\n\t/** Commands held back past what a think may send */\n\theld: number\n}\n\n/**\n * How one game ended\n *\n * @beta\n */\nexport interface SimulatedGame {\n\tseed: number\n\t/** The winning team, or null for none in the time given */\n\twinner: number | null\n\t/** Seconds of the game it lasted, and ticks */\n\tseconds: number\n\tticks: number\n\t/** Why it stopped on an error of its rules, where it did (`World.failure`) */\n\tfailed?: string\n\t/** What `measure` counted */\n\tmeasured: Record<string, Counted>\n\t/** How each computer player played, by player: commands a minute, idle army seconds, churn, seconds blocked on money, commands refused */\n\tcomputers: Record<string, ComputerMeasures>\n\t/** Milliseconds it took to play here */\n\ttook: number\n}\n\n/** A simulation, as a module that a worker imports gives it: as it is written, for its type *\n * @beta\n */\nexport const defineSimulation = (simulation: Simulation): Simulation => simulation\n\n/** Plays one game of a simulation from a seed, in this thread *\n * @beta\n */\nexport async function playGame(simulation: Simulation, seed: number): Promise<SimulatedGame> {\n\tconst began = performance.now()\n\tconst { game, map } = simulation\n\tconst world = await createWorldFromMap({ map: structuredClone(map), game, seed, onError: 'end' })\n\ttry {\n\t\tconst starts = map.players.filter((player) => player.start && player.id !== MAP_CREEPS)\n\t\tconst computers = simulation.computers ?? starts.map((player) => player.id)\n\t\tsimulation.start?.(world)\n\t\tfor (const player of computers) {\n\t\t\tconst enemyBases = starts.filter((other) => other.id !== player && world.areEnemies(player, other.id)).map((other) => other.start!)\n\t\t\tconst named = simulation.brains?.[player]\n\t\t\tconst brain = typeof named === 'string' ? world.computers.brain(named) : named\n\t\t\tif (typeof named === 'string' && !brain)\n\t\t\t\tthrow new Error(`No brain is called \"${named}\": list it in GameModule.brains, or give the brain itself`)\n\t\t\tconst difficulty = simulation.difficulties?.[player]\n\t\t\tconst options: AiOptions = { enemyBases, ...(difficulty !== undefined && { difficulty }), ...simulation.ai?.(player, world) }\n\t\t\tworld.computers.seat(player, { ...options, brain })\n\t\t}\n\t\tconst until = simulation.until ?? ((done: World) => done.winner !== null)\n\t\tconst ticks = Math.ceil((simulation.seconds ?? 1200) * world.tickRate)\n\t\tlet tick = 0\n\t\twhile (tick < ticks && !world.failure && !until(world)) {\n\t\t\tworld.step()\n\t\t\ttick++\n\t\t}\n\t\tconst seconds = tick / world.tickRate\n\t\tconst measures: Record<string, ComputerMeasures> = {}\n\t\tfor (const player of computers) {\n\t\t\tconst computer = world.computers.get(player)?.computer as { stats?: AiStats; def?: { id: string } } | undefined\n\t\t\tconst stats = computer?.stats\n\t\t\tif (!stats) continue\n\t\t\tconst team = world.players.get(player)?.team ?? player\n\t\t\tmeasures[player] = {\n\t\t\t\t...(computer?.def?.id !== undefined && { brain: computer.def.id }),\n\t\t\t\tteam,\n\t\t\t\twon: world.winner !== null && world.winner === team,\n\t\t\t\tcommandsAMinute: seconds > 0 ? (stats.commands / seconds) * 60 : 0,\n\t\t\t\tidleArmySeconds: stats.idleArmySeconds,\n\t\t\t\tchurn: stats.churn,\n\t\t\t\tblockedOnMoney: stats.blockedOnMoney,\n\t\t\t\trefused: stats.refused,\n\t\t\t\theld: stats.held\n\t\t\t}\n\t\t}\n\t\treturn {\n\t\t\tseed,\n\t\t\twinner: world.winner,\n\t\t\tseconds,\n\t\t\tticks: tick,\n\t\t\t...(world.failure && { failed: world.failure.message }),\n\t\t\tmeasured: simulation.measure?.(world) ?? {},\n\t\t\tcomputers: measures,\n\t\t\ttook: performance.now() - began\n\t\t}\n\t} finally {\n\t\tworld.dispose()\n\t}\n}\n\n/**\n * How a brain did over some games (`winRates`): by seat, so a brain that played both sides of a game counts twice\n *\n * @beta\n */\nexport interface BrainResults {\n\t/** Seats it played */\n\tgames: number\n\twins: number\n\t/** Seats whose team another team beat */\n\tlosses: number\n\t/** Seats of games with no winner in the time given */\n\tdraws: number\n\t/** Wins over seats played */\n\trate: number\n\t/** Wins over games decided either way: draws left out */\n\tdecided: number\n}\n\n/**\n * The win rate of each brain over games of `simulate`, by brain id (`ComputerMeasures.brain`): what a balance run of two\n * brains reads. A seat that named no brain is left out\n *\n *     const games = await simulate({ ...duel, brains: { 1: meleeBrain, 2: myBrain } }, { seeds })\n *     winRates(games) // { 'core.melee': { rate: 0.4, … }, 'mygame.brain': { rate: 0.55, … } }\n *\n * @beta\n */\nexport function winRates(games: readonly SimulatedGame[]): Record<string, BrainResults> {\n\tconst results: Record<string, BrainResults> = {}\n\tfor (const game of games)\n\t\tfor (const measures of Object.values(game.computers)) {\n\t\t\tif (measures.brain === undefined) continue\n\t\t\tconst result = (results[measures.brain] ??= { games: 0, wins: 0, losses: 0, draws: 0, rate: 0, decided: 0 })\n\t\t\tresult.games++\n\t\t\tif (measures.won) result.wins++\n\t\t\telse if (game.winner === null) result.draws++\n\t\t\telse result.losses++\n\t\t}\n\tfor (const result of Object.values(results)) {\n\t\tresult.rate = result.games ? result.wins / result.games : 0\n\t\tresult.decided = result.wins + result.losses ? result.wins / (result.wins + result.losses) : 0\n\t}\n\treturn results\n}\n\n/**\n * How `simulate` plays its games\n *\n * @beta\n */\nexport interface SimulateOptions {\n\t/** The seeds to play from, a game each */\n\tseeds: number[]\n\t/**\n\t * Worker threads to play them in at once, where the simulation is given as a file: as many as the machine has\n\t * cores less one, when left out. In this thread, one after the other, for a simulation given as it is\n\t */\n\tworkers?: number\n\t/** Told of each game as it ends, in the order they end */\n\tonGame?: (game: SimulatedGame) => void\n}\n\n/**\n * Plays games of a simulation, one from each seed, and gives what each ended in, in the order of the seeds. Given as\n * it is, they are played in this thread. Given as the address of a file (a module whose `default`, or `simulation`, is\n * one: `defineSimulation`), each worker thread imports it and plays its share: in Node, from the built packages (a\n * worker loads JavaScript, not the TypeScript of this repository)\n *\n * @beta\n */\nexport async function simulate(simulation: Simulation | string | URL, options: SimulateOptions): Promise<SimulatedGame[]> {\n\tif (typeof simulation !== 'string' && !(simulation instanceof URL)) {\n\t\tconst games: SimulatedGame[] = []\n\t\tfor (const seed of options.seeds) {\n\t\t\tconst game = await playGame(simulation, seed)\n\t\t\toptions.onGame?.(game)\n\t\t\tgames.push(game)\n\t\t}\n\t\treturn games\n\t}\n\tconst { Worker } = await import('node:worker_threads')\n\tconst { availableParallelism } = await import('node:os')\n\tconst module = String(simulation)\n\tconst count = Math.max(1, Math.min(options.workers ?? availableParallelism() - 1, options.seeds.length))\n\t// the worker's file sits next to this one in the build: named so, a bundler leaves the address alone\n\tconst file = 'simulate-worker.js'\n\tconst script = new URL(file, import.meta.url)\n\tconst results = new Map<number, SimulatedGame>()\n\tconst queue = [...options.seeds]\n\tawait Promise.all(\n\t\tArray.from(\n\t\t\t{ length: count },\n\t\t\t() =>\n\t\t\t\tnew Promise<void>((resolve, reject) => {\n\t\t\t\t\tconst worker = new Worker(script)\n\t\t\t\t\tconst next = () => {\n\t\t\t\t\t\tconst seed = queue.shift()\n\t\t\t\t\t\tif (seed === undefined) {\n\t\t\t\t\t\t\tvoid worker.terminate()\n\t\t\t\t\t\t\treturn resolve()\n\t\t\t\t\t\t}\n\t\t\t\t\t\tworker.postMessage({ module, seed })\n\t\t\t\t\t}\n\t\t\t\t\tworker.on('message', (message: { game?: SimulatedGame; error?: string }) => {\n\t\t\t\t\t\tif (message.error !== undefined) {\n\t\t\t\t\t\t\tvoid worker.terminate()\n\t\t\t\t\t\t\treturn reject(new Error(message.error))\n\t\t\t\t\t\t}\n\t\t\t\t\t\tresults.set(message.game!.seed, message.game!)\n\t\t\t\t\t\toptions.onGame?.(message.game!)\n\t\t\t\t\t\tnext()\n\t\t\t\t\t})\n\t\t\t\t\tworker.on('error', reject)\n\t\t\t\t\tnext()\n\t\t\t\t})\n\t\t)\n\t)\n\treturn options.seeds.map((seed) => results.get(seed)!)\n}\n"],"mappings":"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"}

package/dist/simulate-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/simulate-worker.js

@@ -0,0 +1,28 @@
+import { n as playGame } from "./simulate-oXBiw1Ff.js";
+import { parentPort } from "node:worker_threads";
+//#region src/simulate-worker.ts
+/**
+* A worker thread of `simulate`: told a file and a seed, it imports the simulation the file gives (its `default`, or
+* `simulation`) and plays a game of it, and says how it ended. Built next to `testing.js`, and not one of the names
+* of the engine: `simulate` starts it
+*/
+var loaded = /* @__PURE__ */ new Map();
+parentPort?.on("message", async ({ module, seed }) => {
+	try {
+		let simulation = loaded.get(module);
+		if (!simulation) {
+			simulation = import(module).then((imported) => {
+				const found = imported.default ?? imported.simulation;
+				if (!found) throw new Error(`${module} gives no simulation: its default, or one named simulation`);
+				return found;
+			});
+			loaded.set(module, simulation);
+		}
+		parentPort.postMessage({ game: await playGame(await simulation, seed) });
+	} catch (error) {
+		parentPort.postMessage({ error: error instanceof Error ? error.stack ?? error.message : String(error) });
+	}
+});
+//#endregion
+
+//# sourceMappingURL=simulate-worker.js.map

package/dist/simulate-worker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"simulate-worker.js","names":[],"sources":["../src/simulate-worker.ts"],"sourcesContent":["/**\n * A worker thread of `simulate`: told a file and a seed, it imports the simulation the file gives (its `default`, or\n * `simulation`) and plays a game of it, and says how it ended. Built next to `testing.js`, and not one of the names\n * of the engine: `simulate` starts it\n */\nimport { parentPort } from 'node:worker_threads'\nimport { playGame, type Simulation } from './simulate'\n\nconst loaded = new Map<string, Promise<Simulation>>()\n\nparentPort?.on('message', async ({ module, seed }: { module: string; seed: number }) => {\n\ttry {\n\t\tlet simulation = loaded.get(module)\n\t\tif (!simulation) {\n\t\t\tsimulation = import(module).then((imported: { default?: Simulation; simulation?: Simulation }) => {\n\t\t\t\tconst found = imported.default ?? imported.simulation\n\t\t\t\tif (!found) throw new Error(`${module} gives no simulation: its default, or one named simulation`)\n\t\t\t\treturn found\n\t\t\t})\n\t\t\tloaded.set(module, simulation)\n\t\t}\n\t\tparentPort!.postMessage({ game: await playGame(await simulation, seed) })\n\t} catch (error) {\n\t\tparentPort!.postMessage({ error: error instanceof Error ? (error.stack ?? error.message) : String(error) })\n\t}\n})\n"],"mappings":";;;;;;;;AAQA,IAAM,yBAAS,IAAI,IAAiC;AAEpD,YAAY,GAAG,WAAW,OAAO,EAAE,QAAQ,WAA6C;CACvF,IAAI;EACH,IAAI,aAAa,OAAO,IAAI,MAAM;EAClC,IAAI,CAAC,YAAY;GAChB,aAAa,OAAO,OAAO,CAAC,MAAM,aAAgE;IACjG,MAAM,QAAQ,SAAS,WAAW,SAAS;IAC3C,IAAI,CAAC,OAAO,MAAM,IAAI,MAAM,GAAG,OAAO,2DAA2D;IACjG,OAAO;GACR,CAAC;GACD,OAAO,IAAI,QAAQ,UAAU;EAC9B;EACA,WAAY,YAAY,EAAE,MAAM,MAAM,SAAS,MAAM,YAAY,IAAI,EAAE,CAAC;CACzE,SAAS,OAAO;EACf,WAAY,YAAY,EAAE,OAAO,iBAAiB,QAAS,MAAM,SAAS,MAAM,UAAW,OAAO,KAAK,EAAE,CAAC;CAC3G;AACD,CAAC"}

package/dist/simulate.d.ts

@@ -0,0 +1,154 @@
+import type { AiOptions } from './ai/options';
+import type { BrainDef } from './ai/brain';
+import type { PlayerId } from './entity';
+import { type GameModule } from './game';
+import { type GameMap } from './map';
+import type { World } from './world';
+/**
+ * What a value counted at the end of a game may be: plain data, which comes back from a worker as it went
+ *
+ * @beta
+ */
+export type Counted = number | string | boolean | null;
+/**
+ * A game to play many times (`simulate`): the rules, the map, who the computer plays and how, and what to count
+ *
+ * @beta
+ */
+export interface Simulation {
+    game: GameModule;
+    map: GameMap;
+    /**
+     * The players the computer plays: every player of the map with a start, the creeps apart, when left out. One left
+     * out is the game's own (`start`) to move, or stands
+     */
+    computers?: PlayerId[];
+    /**
+     * The brain each player is played by, or its id (one the game lists in `GameModule.brains`, or the engine's
+     * `core.melee`): two brains against each other, for a balance run. A player not named here is played by the first
+     * brain the game lists
+     */
+    brains?: Record<number, BrainDef | string>;
+    /**
+     * How hard each player's computer plays, by name (`'hard'`): under what `ai` gives. The seat's own when left out
+     */
+    difficulties?: Record<number, string>;
+    /** How the computer plays a player, over what it is given (`enemyBases`: where the others start) */
+    ai?: (player: PlayerId, world: World) => Partial<AiOptions>;
+    /** What the game does once a world is made, before the first tick: units of its own, a rule turned on */
+    start?: (world: World) => void;
+    /** Seconds of the game at most: twenty minutes when left out */
+    seconds?: number;
+    /** Whether the game is over before that: once there is a winner, when left out */
+    until?: (world: World) => boolean;
+    /** What to count at the end of each game, by name: units alive, gold gathered, the hour */
+    measure?: (world: World) => Record<string, Counted>;
+}
+/**
+ * How a computer player played one game, beside who won (`SimulatedGame.computers`): the numbers that say whether a
+ * brain plays well, not only whether it won (`AiStats`, the brain's own counts, by the minute where it says so)
+ *
+ * @beta
+ */
+export interface ComputerMeasures {
+    /** The brain that played the seat, by id: none for the first the game lists, seated by none named */
+    brain?: string;
+    /** The team the seat played for */
+    team: number;
+    /** Whether its team won: false for a draw too */
+    won: boolean;
+    /** Commands sent a minute of the game */
+    commandsAMinute: number;
+    /** Seconds its fighters stood idle, summed over the fighters */
+    idleArmySeconds: number;
+    /** Orders sent to a unit again for the same thing within a few seconds */
+    churn: number;
+    /** Seconds its building waited on money */
+    blockedOnMoney: number;
+    /** Commands the game refused */
+    refused: number;
+    /** Commands held back past what a think may send */
+    held: number;
+}
+/**
+ * How one game ended
+ *
+ * @beta
+ */
+export interface SimulatedGame {
+    seed: number;
+    /** The winning team, or null for none in the time given */
+    winner: number | null;
+    /** Seconds of the game it lasted, and ticks */
+    seconds: number;
+    ticks: number;
+    /** Why it stopped on an error of its rules, where it did (`World.failure`) */
+    failed?: string;
+    /** What `measure` counted */
+    measured: Record<string, Counted>;
+    /** How each computer player played, by player: commands a minute, idle army seconds, churn, seconds blocked on money, commands refused */
+    computers: Record<string, ComputerMeasures>;
+    /** Milliseconds it took to play here */
+    took: number;
+}
+/** A simulation, as a module that a worker imports gives it: as it is written, for its type *
+ * @beta
+ */
+export declare const defineSimulation: (simulation: Simulation) => Simulation;
+/** Plays one game of a simulation from a seed, in this thread *
+ * @beta
+ */
+export declare function playGame(simulation: Simulation, seed: number): Promise<SimulatedGame>;
+/**
+ * How a brain did over some games (`winRates`): by seat, so a brain that played both sides of a game counts twice
+ *
+ * @beta
+ */
+export interface BrainResults {
+    /** Seats it played */
+    games: number;
+    wins: number;
+    /** Seats whose team another team beat */
+    losses: number;
+    /** Seats of games with no winner in the time given */
+    draws: number;
+    /** Wins over seats played */
+    rate: number;
+    /** Wins over games decided either way: draws left out */
+    decided: number;
+}
+/**
+ * The win rate of each brain over games of `simulate`, by brain id (`ComputerMeasures.brain`): what a balance run of two
+ * brains reads. A seat that named no brain is left out
+ *
+ *     const games = await simulate({ ...duel, brains: { 1: meleeBrain, 2: myBrain } }, { seeds })
+ *     winRates(games) // { 'core.melee': { rate: 0.4, … }, 'mygame.brain': { rate: 0.55, … } }
+ *
+ * @beta
+ */
+export declare function winRates(games: readonly SimulatedGame[]): Record<string, BrainResults>;
+/**
+ * How `simulate` plays its games
+ *
+ * @beta
+ */
+export interface SimulateOptions {
+    /** The seeds to play from, a game each */
+    seeds: number[];
+    /**
+     * Worker threads to play them in at once, where the simulation is given as a file: as many as the machine has
+     * cores less one, when left out. In this thread, one after the other, for a simulation given as it is
+     */
+    workers?: number;
+    /** Told of each game as it ends, in the order they end */
+    onGame?: (game: SimulatedGame) => void;
+}
+/**
+ * Plays games of a simulation, one from each seed, and gives what each ended in, in the order of the seeds. Given as
+ * it is, they are played in this thread. Given as the address of a file (a module whose `default`, or `simulation`, is
+ * one: `defineSimulation`), each worker thread imports it and plays its share: in Node, from the built packages (a
+ * worker loads JavaScript, not the TypeScript of this repository)
+ *
+ * @beta
+ */
+export declare function simulate(simulation: Simulation | string | URL, options: SimulateOptions): Promise<SimulatedGame[]>;

package/dist/smart.d.ts

@@ -0,0 +1,9 @@
+import type { Entity } from './entity';
+import type { Vec2 } from './math';
+import type { OrderInit } from './registry';
+import type { World } from './world';
+/**
+ * The right-click: picks the order a unit should get for whatever was clicked.
+ * Returns undefined when there is nothing sensible for this unit to do.
+ */
+export declare function smartOrder(world: World, entity: Entity, point: Vec2, target?: Entity): OrderInit | undefined;

package/dist/spatial.d.ts

@@ -0,0 +1,62 @@
+import type { Entity, PlayerId } from './entity';
+/**
+ * Uniform grid for "what is near this point" queries. The map is cut into square cells and every entity is
+ * filed under the cells it is in, so a query only looks at the few cells around the point instead of at every
+ * entity in the world.
+ *
+ * There are two layers:
+ * - Units move, so they are filed again from scratch every tick (`rebuild`), which is simpler and cheaper than
+ *   following every unit from cell to cell. A unit is filed by its center only, so queries look a little
+ *   further than asked, by the radius of the biggest unit, not to miss one whose edge is in range.
+ * - Structures (buildings, trees, mines) never move, so they are filed once when they appear and taken out when
+ *   they go (`insertStatic`, `removeStatic`). They are filed under every cell their footprint covers, so a query
+ *   finds them by any part of them without looking further than asked. That matters: padding queries by the
+ *   size of the biggest building would make every query near a forest go through far more trees.
+ */
+export declare class SpatialIndex {
+    private readonly cellSize;
+    private readonly cols;
+    private readonly rows;
+    private readonly cells;
+    private readonly staticCells;
+    /**
+     * By cell, the one owner of every unit filed in it this tick, or -1 for none or more than one: what a search that
+     * passes over a side's own leaves out cell by cell (`query`'s `skip`). Not to be gone by once an owner changed
+     * since (`ownerChanged`), until the next filing
+     */
+    private readonly soleOwner;
+    private ownersMoved;
+    /** Radius of the biggest unit filed this tick */
+    private maxRadius;
+    /** Counts queries. A structure that covers several cells is marked with it when found, so it is only found once */
+    private stamp;
+    constructor(width: number, depth: number, cellSize?: number);
+    private col;
+    private row;
+    /** Files every unit again. Called once per tick, before the systems run. Structures in `entities` are passed over */
+    rebuild(entities: Iterable<Entity>): void;
+    /** A unit filed this tick has another owner now: no cell's one owner is gone by until the next filing */
+    ownerChanged(): void;
+    /** Files a structure under every cell it covers, for as long as it stands */
+    insertStatic(entity: Entity): void;
+    removeStatic(entity: Entity): void;
+    private forCellsOf;
+    /**
+     * Entities that could be within `radius` of the point: every structure that has a part in the square around it,
+     * and every unit whose center is close enough for its edge to be. Callers do the exact distance check.
+     *
+     * The answer is written into `out`, which callers keep around and pass again so that nothing is allocated. While going
+     * through the answer, a caller that does something which can lead to another query with the same `out` (dealing damage
+     * can set off effects that look around) has to go through a copy instead: the other query would overwrite it.
+     *
+     * `skip`: owners whose units the caller passes over anyway (a side's own, as it picks a target): a cell of units of
+     * one such owner alone is left out. What is left is what the full answer had, in the same order, less some of theirs
+     */
+    query(x: number, z: number, radius: number, out?: Entity[], skip?: (owner: PlayerId) => boolean): Entity[];
+    /**
+     * Only the structures that have a part in the square around the point: buildings, trees, mines, every kind but a
+     * unit. For who looks for those alone, among crowds of units that would otherwise all be gone through. Into `out`,
+     * as `query`
+     */
+    queryStatic(x: number, z: number, radius: number, out?: Entity[]): Entity[];
+}

package/dist/spawning.d.ts

@@ -0,0 +1,33 @@
+import { Entity, type PlayerId } from './entity';
+import type { Vec2 } from './math';
+import type { SpawnOptions, World } from './world';
+/**
+ * How entities come into the world and are moved about in it, as the world's own part (`World.spawn`, `place`,
+ * `setOwner`, `setHidden`, `setLifetime`): what a type is given as it is made, its place on the ground, the grid and the
+ * ways, whose it is, whether it is inside something, how long it lasts. The world's methods are this.world part's
+ */
+export declare class Spawning {
+    private readonly world;
+    constructor(world: World);
+    spawn(typeId: string, owner: PlayerId, position: Vec2, options?: SpawnOptions): Entity;
+    /**
+     * Turns scenery into an actor, for good: something gave it a reason to be looked at every tick, like a buff
+     * that has to run out. Whatever does that to an entity calls this.world; the debug checks catch what forgets to.
+     */
+    wake(entity: Entity): void;
+    /** Puts a unit somewhere else, where it stands: the way through is not its concern. Structures stay where they were built */
+    place(entity: Entity, point: Vec2): void;
+    /**
+     * Gives an entity to another player, from now on in everything: whose it is, whom it fights, what it counts for.
+     * What it was doing is called off, and what it was making is given back to the one it belonged to
+     */
+    setOwner(entity: Entity, owner: PlayerId): void;
+    /**
+     * Takes a unit out of the world for a while, or puts it back: a worker inside a gold mine, a unit carried in
+     * something. While hidden it is not found, not seen and in nobody's way, and its orders wait. It comes back at
+     * `at`, or where it went in, on the nearest ground it can stand on. Structures cannot hide
+     */
+    setHidden(entity: Entity, hidden: boolean, at?: Vec2): void;
+    /** Gives an entity a time after which it is gone by itself, like a ward, or takes it away with `null` */
+    setLifetime(entity: Entity, seconds: number | null): void;
+}