@v12-engine/engine 0.1.1 → 0.4.0

package/dist/aiTesting.d.ts

@@ -21,7 +21,7 @@ import { Brain } from './ai/brain';
 import type { GoalReport } from './ai/goals';
 import { type AiDecision, type AiReport } from './ai/report';
 import type { PlayerId } from './entity';
-import { type GameModule } from './game';
+import { type Rules } from './game';
 import type { PlayerCommand, Snapshot } from './session/protocol';
 import type { World } from './world';
 /**
@@ -110,6 +110,7 @@ export interface FairPlay {
     readonly refused: number;
     /** Throws where it sent any command about what it did not see */
     assert(): void;
+    /** Stops watching the brain; the violations found so far stay */
     stop(): void;
 }
 /**
@@ -126,6 +127,7 @@ export declare function fairPlay(world: World, player: PlayerId): FairPlay;
  * @beta
  */
 export interface RecordedDecision extends AiDecision {
+    /** The player whose computer made the decision */
     player: PlayerId;
     /** The brain's id */
     brain: string;
@@ -139,6 +141,7 @@ export interface RecordedDecision extends AiDecision {
 export interface DecisionRecorder {
     /** Every decision so far, in the order made */
     readonly decisions: readonly RecordedDecision[];
+    /** Stops recording; the decisions so far stay */
     stop(): void;
 }
 /**
@@ -168,12 +171,12 @@ export interface DecisionsApart {
  * game seats them), runs it to `from`, saves it as a file would keep it and loads that with `game`, then runs both to
  * `ticks` and compares what every computer decided. What lost rng, tasks or memory in a restore shows as
  *
- *     expect(await checkComputerSave(() => duel(), { from: 600, ticks: 2400, game: melee })).toBeNull()
+ *     expect(await checkComputerSave(() => duel(), { from: 600, ticks: 2400, rules: melee })).toBeNull()
  *
  * @beta
  */
 export declare function checkComputerSave(make: () => World | Promise<World>, options: {
     from: number;
     ticks: number;
-    game: GameModule;
+    rules: Rules;
 }): Promise<DecisionsApart | null>;

package/dist/aiTesting.js

@@ -0,0 +1,229 @@
+import { decodeSave, encodeSave, saveWorld } from "./save.js";
+import { loadWorld } from "./game.js";
+import { LocalSession } from "./session/local.js";
+import { explainGoal } from "./ai/report.js";
+import { checkBrain } from "./ai/checks.js";
+import { Brain } from "./ai/brain.js";
+//#region src/aiTesting.ts
+/**
+* Testing a computer player (AI plan, E3): what a game's tests of its brains are written with, in
+* `@v12-engine/engine/testing` beside `testWorld` and `run`. A brain is tested as it plays, through the world it sits in:
+*
+*     const world = await testWorld(myGame)
+*     world.computers.seat(ENEMY, { enemyBases: [home], brain: myBrain })
+*     const watch = watchComputer(world, ENEMY)        // its invariants, every think
+*     run(world, 120)
+*     expectDecision(thinkOnce(world, ENEMY), 'ai.attack')
+*     watch.assert()                                     // no rule broken
+*
+* `thinkOnce` has a seated brain think now and gives its report; `expectDecision` says a goal runs, or why not in
+* words; `watchComputer` checks the invariants of `ai/checks.ts` after every think (a unit in one squad, gold spent
+* once, finite numbers, commands about what it sees, no churn, nothing stuck) and keeps what it decided; `fairPlay` is
+* the one about seeing; `recordDecisions` keeps every computer's decisions for a replay's side file; `checkComputerSave`
+* is the seventh invariant: a game saved and loaded decides the same from then on. These take the world, which a test
+* may: the brains under test never do.
+*/
+/**
+* The brain that plays a player, where one is seated (`world.computers.seat`): none where nobody is, or where what is
+* seated is not a brain (`defineComputer`)
+*
+* @beta
+*/
+function brainOf(world, player) {
+	const computer = world.computers.get(player)?.computer;
+	return computer instanceof Brain ? computer : void 0;
+}
+/** The brain at a player, or an error that says what is seated there instead */
+function seated(world, player) {
+	const brain = brainOf(world, player);
+	if (brain) return brain;
+	const system = world.computers.get(player);
+	throw new Error(system ? `The computer player at ${player} is not a brain (defineBrain): it has no report` : `No computer player is seated at ${player}`);
+}
+/**
+* Has the brain at a player think now, all of it (a think its budget slices over ticks is run to its end), over a new
+* picture of the game, and gives its report: what a test reads after setting a scene. Its commands land at the next
+* tick, as a think's do. A think the seat would have had is not skipped: this one is beside them
+*
+* @beta
+*/
+function thinkOnce(world, player) {
+	const brain = seated(world, player);
+	do
+		brain.think();
+	while (brain.busy);
+	return brain.report();
+}
+/**
+* Says that a goal runs, as of a report (`thinkOnce`, `Brain.report`): it is picked and holds what it claimed. Throws
+* where it does not, with its row in words (`Brain.explain`): what each consideration answered and what kept it out.
+* Gives the goal's row. With `picked: false`, says it does not run
+*
+*     expectDecision(thinkOnce(world, ENEMY), 'ai.defend')
+*
+* @beta
+*/
+function expectDecision(report, goal, options = {}) {
+	const wanted = options.picked ?? true;
+	const row = report.goals.find((each) => each.id === goal);
+	if (!row) throw new Error(`The brain ${report.brain} has no goal "${goal}": its goals are ${report.goals.map((each) => each.id).join(", ") || "none"}`);
+	if (row.picked === wanted) return row;
+	const seconds = (tick) => tick / report.tickRate;
+	throw new Error(`Expected ${goal} ${wanted ? "to run" : "not to run"} at ${report.time.toFixed(1)} s, and it ${wanted ? "does not" : "does"}. ${explainGoal(row, seconds, report.time)}${report.goal && report.goal !== goal ? ` The best goal is ${report.goal}.` : ""}`);
+}
+/**
+* Follows the brain at a player from now on: after every think, the invariants of `ai/checks.ts` (a unit in one squad
+* and one hold, gold spent once, finite numbers, commands about what it sees, no order sent again to a unit still at
+* it, builders, tasks, holds and wants that end), with what it decided and sent. A broken rule is kept, not thrown,
+* unless `onViolation` throws: `assert` at the end says them all
+*
+* @beta
+*/
+function watchComputer(world, player, options = {}) {
+	const brain = seated(world, player);
+	const violations = [];
+	const decisions = [];
+	let thinks = 0;
+	let commands = 0;
+	const { stop: unchecked } = checkBrain(brain, {
+		...options,
+		onViolation: (violation) => {
+			violations.push(violation);
+			options.onViolation?.(violation);
+		}
+	});
+	const observer = options.observe ? new LocalSession(world, player, { observer: true }) : void 0;
+	const unwatched = brain.watch({
+		sent: (command) => {
+			commands++;
+			options.sent?.(command, brain);
+		},
+		decided: (decision) => void decisions.push(decision),
+		thought: () => {
+			thinks++;
+			if (observer) options.observe(observer.snapshot(), brain);
+		}
+	});
+	return {
+		brain,
+		violations,
+		decisions,
+		get thinks() {
+			return thinks;
+		},
+		get commands() {
+			return commands;
+		},
+		assert() {
+			if (!violations.length) return;
+			const lines = violations.slice(0, 20).map((each) => `  ${each.invariant} at tick ${each.tick}: ${each.message}`);
+			const more = violations.length > 20 ? `\n  and ${violations.length - 20} more` : "";
+			throw new Error(`The computer player at ${player} broke ${violations.length} rule${violations.length === 1 ? "" : "s"}:\n${lines.join("\n")}${more}`);
+		},
+		stop() {
+			unchecked();
+			unwatched();
+			observer?.dispose();
+		}
+	};
+}
+/**
+* Follows the brain at a player from now on for fair play: that it never sends a command about an entity its snapshot
+* did not have (a fog leak: its seat's session would drop the command, so a game shows nothing; this says it), and
+* counts what the game refused
+*
+* @beta
+*/
+function fairPlay(world, player) {
+	const watch = watchComputer(world, player, { invariants: ["commands"] });
+	const brain = watch.brain;
+	const refusedBefore = brain.stats.refused;
+	return {
+		get unfair() {
+			return watch.violations;
+		},
+		get refused() {
+			return brain.stats.refused - refusedBefore;
+		},
+		assert: () => watch.assert(),
+		stop: () => watch.stop()
+	};
+}
+/** How many recorders were made: each one's system a name of its own */
+var recorders = 0;
+/**
+* Keeps the decisions of every brain seated at a world, from now on, those seated later included (looked for at each
+* tick, by a system of its own that keeps nothing in a save)
+*
+* @beta
+*/
+function recordDecisions(world) {
+	const decisions = [];
+	const watched = /* @__PURE__ */ new Map();
+	const look = () => {
+		for (const player of world.computers.list()) {
+			const brain = brainOf(world, player);
+			if (!brain || watched.has(brain)) continue;
+			watched.set(brain, brain.watch({ decided: (decision) => void decisions.push({
+				...decision,
+				player: brain.playerId,
+				brain: brain.def.id
+			}) }));
+		}
+	};
+	look();
+	const name = `core.ai.recordDecisions.${++recorders}`;
+	world.addSystem({
+		name,
+		update: look
+	});
+	return {
+		decisions,
+		stop() {
+			world.removeSystem(name);
+			for (const unwatch of watched.values()) unwatch();
+			watched.clear();
+		}
+	};
+}
+/**
+* The seventh invariant of a computer player: a game saved at tick `from` and loaded makes the same decisions from then
+* on as the game it was saved from, under the same commands. Makes the world with `make` (its computers seated, as a
+* game seats them), runs it to `from`, saves it as a file would keep it and loads that with `game`, then runs both to
+* `ticks` and compares what every computer decided. What lost rng, tasks or memory in a restore shows as
+*
+*     expect(await checkComputerSave(() => duel(), { from: 600, ticks: 2400, rules: melee })).toBeNull()
+*
+* @beta
+*/
+async function checkComputerSave(make, options) {
+	const saved = await make();
+	let loaded;
+	try {
+		while (saved.tick < options.from) saved.step();
+		loaded = await loadWorld(decodeSave(encodeSave(saveWorld(saved))), { rules: options.rules });
+		const before = recordDecisions(saved);
+		const after = recordDecisions(loaded);
+		while (saved.tick < options.ticks) {
+			saved.step();
+			loaded.step();
+		}
+		before.stop();
+		after.stop();
+		const a = before.decisions;
+		const b = after.decisions;
+		for (let i = 0; i < Math.max(a.length, b.length); i++) if (JSON.stringify(a[i]) !== JSON.stringify(b[i])) return {
+			index: i,
+			...a[i] && { saved: a[i] },
+			...b[i] && { loaded: b[i] }
+		};
+		return null;
+	} finally {
+		saved.dispose();
+		loaded?.dispose();
+	}
+}
+//#endregion
+export { brainOf, checkComputerSave, expectDecision, fairPlay, recordDecisions, thinkOnce, watchComputer };
+
+//# sourceMappingURL=aiTesting.js.map

package/dist/aiTesting.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"aiTesting.js","names":[],"sources":["../src/aiTesting.ts"],"sourcesContent":["/**\n * Testing a computer player (AI plan, E3): what a game's tests of its brains are written with, in\n * `@v12-engine/engine/testing` beside `testWorld` and `run`. A brain is tested as it plays, through the world it sits in:\n *\n *     const world = await testWorld(myGame)\n *     world.computers.seat(ENEMY, { enemyBases: [home], brain: myBrain })\n *     const watch = watchComputer(world, ENEMY)        // its invariants, every think\n *     run(world, 120)\n *     expectDecision(thinkOnce(world, ENEMY), 'ai.attack')\n *     watch.assert()                                     // no rule broken\n *\n * `thinkOnce` has a seated brain think now and gives its report; `expectDecision` says a goal runs, or why not in\n * words; `watchComputer` checks the invariants of `ai/checks.ts` after every think (a unit in one squad, gold spent\n * once, finite numbers, commands about what it sees, no churn, nothing stuck) and keeps what it decided; `fairPlay` is\n * the one about seeing; `recordDecisions` keeps every computer's decisions for a replay's side file; `checkComputerSave`\n * is the seventh invariant: a game saved and loaded decides the same from then on. These take the world, which a test\n * may: the brains under test never do.\n */\nimport { type AiCheckOptions, type AiViolation, checkBrain } from './ai/checks'\nimport { Brain } from './ai/brain'\nimport type { GoalReport } from './ai/goals'\nimport { type AiDecision, type AiReport, explainGoal } from './ai/report'\nimport type { PlayerId } from './entity'\nimport { type Rules, loadWorld } from './game'\nimport { decodeSave, encodeSave, saveWorld } from './save'\nimport { LocalSession } from './session/local'\nimport type { PlayerCommand, Snapshot } from './session/protocol'\nimport type { World } from './world'\n\n/**\n * The brain that plays a player, where one is seated (`world.computers.seat`): none where nobody is, or where what is\n * seated is not a brain (`defineComputer`)\n *\n * @beta\n */\nexport function brainOf(world: World, player: PlayerId): Brain | undefined {\n\tconst computer = world.computers.get(player)?.computer\n\treturn computer instanceof Brain ? computer : undefined\n}\n\n/** The brain at a player, or an error that says what is seated there instead */\nfunction seated(world: World, player: PlayerId): Brain {\n\tconst brain = brainOf(world, player)\n\tif (brain) return brain\n\tconst system = world.computers.get(player)\n\tthrow new Error(\n\t\tsystem ? `The computer player at ${player} is not a brain (defineBrain): it has no report` : `No computer player is seated at ${player}`\n\t)\n}\n\n/**\n * Has the brain at a player think now, all of it (a think its budget slices over ticks is run to its end), over a new\n * picture of the game, and gives its report: what a test reads after setting a scene. Its commands land at the next\n * tick, as a think's do. A think the seat would have had is not skipped: this one is beside them\n *\n * @beta\n */\nexport function thinkOnce(world: World, player: PlayerId): AiReport {\n\tconst brain = seated(world, player)\n\tdo brain.think()\n\twhile (brain.busy)\n\treturn brain.report()\n}\n\n/**\n * Says that a goal runs, as of a report (`thinkOnce`, `Brain.report`): it is picked and holds what it claimed. Throws\n * where it does not, with its row in words (`Brain.explain`): what each consideration answered and what kept it out.\n * Gives the goal's row. With `picked: false`, says it does not run\n *\n *     expectDecision(thinkOnce(world, ENEMY), 'ai.defend')\n *\n * @beta\n */\nexport function expectDecision(report: AiReport, goal: string, options: { picked?: boolean } = {}): GoalReport {\n\tconst wanted = options.picked ?? true\n\tconst row = report.goals.find((each) => each.id === goal)\n\tif (!row)\n\t\tthrow new Error(`The brain ${report.brain} has no goal \"${goal}\": its goals are ${report.goals.map((each) => each.id).join(', ') || 'none'}`)\n\tif (row.picked === wanted) return row\n\tconst seconds = (tick: number) => tick / report.tickRate\n\tthrow new Error(\n\t\t`Expected ${goal} ${wanted ? 'to run' : 'not to run'} at ${report.time.toFixed(1)} s, and it ${wanted ? 'does not' : 'does'}. ${explainGoal(row, seconds, report.time)}${\n\t\t\treport.goal && report.goal !== goal ? ` The best goal is ${report.goal}.` : ''\n\t\t}`\n\t)\n}\n\n/**\n * A computer player followed over a run (`watchComputer`): the rules it broke, what it decided and sent, and, where\n * asked, what an observer saw at each of its thinks\n *\n * @beta\n */\nexport interface ComputerWatch {\n\t/** The brain watched */\n\treadonly brain: Brain\n\t/** Every invariant it broke, in the order found (`ai/checks.ts`) */\n\treadonly violations: readonly AiViolation[]\n\t/** What it decided while watched, oldest first: every line, not only the last fifty its log keeps */\n\treadonly decisions: readonly AiDecision[]\n\t/** Its thinks while watched */\n\treadonly thinks: number\n\t/** Commands it sent while watched */\n\treadonly commands: number\n\t/** Throws, listing them, where it broke any rule */\n\tassert(): void\n\t/** Stops watching */\n\tstop(): void\n}\n\n/**\n * How a computer player is watched (`watchComputer`): which invariants and how long things may go on (`AiCheckOptions`),\n * and what to be shown at each think\n *\n * @beta\n */\nexport interface WatchOptions extends AiCheckOptions {\n\t/**\n\t * Shown, at the end of each of its thinks, the game as an observer sees it (everything, no fog) and the brain: for a\n\t * look at what it does (a test that writes frames, a page that draws them). An observer's seat is made only when given\n\t */\n\tobserve?: (snapshot: Snapshot, brain: Brain) => void\n\t/** Each command as it sends it */\n\tsent?: (command: PlayerCommand, brain: Brain) => void\n}\n\n/**\n * Follows the brain at a player from now on: after every think, the invariants of `ai/checks.ts` (a unit in one squad\n * and one hold, gold spent once, finite numbers, commands about what it sees, no order sent again to a unit still at\n * it, builders, tasks, holds and wants that end), with what it decided and sent. A broken rule is kept, not thrown,\n * unless `onViolation` throws: `assert` at the end says them all\n *\n * @beta\n */\nexport function watchComputer(world: World, player: PlayerId, options: WatchOptions = {}): ComputerWatch {\n\tconst brain = seated(world, player)\n\tconst violations: AiViolation[] = []\n\tconst decisions: AiDecision[] = []\n\tlet thinks = 0\n\tlet commands = 0\n\tconst { stop: unchecked } = checkBrain(brain, {\n\t\t...options,\n\t\tonViolation: (violation) => {\n\t\t\tviolations.push(violation)\n\t\t\toptions.onViolation?.(violation)\n\t\t}\n\t})\n\tconst observer = options.observe ? new LocalSession(world, player, { observer: true }) : undefined\n\tconst unwatched = brain.watch({\n\t\tsent: (command) => {\n\t\t\tcommands++\n\t\t\toptions.sent?.(command, brain)\n\t\t},\n\t\tdecided: (decision) => void decisions.push(decision),\n\t\tthought: () => {\n\t\t\tthinks++\n\t\t\tif (observer) options.observe!(observer.snapshot(), brain)\n\t\t}\n\t})\n\treturn {\n\t\tbrain,\n\t\tviolations,\n\t\tdecisions,\n\t\tget thinks() {\n\t\t\treturn thinks\n\t\t},\n\t\tget commands() {\n\t\t\treturn commands\n\t\t},\n\t\tassert() {\n\t\t\tif (!violations.length) return\n\t\t\tconst lines = violations.slice(0, 20).map((each) => `  ${each.invariant} at tick ${each.tick}: ${each.message}`)\n\t\t\tconst more = violations.length > 20 ? `\\n  and ${violations.length - 20} more` : ''\n\t\t\tthrow new Error(\n\t\t\t\t`The computer player at ${player} broke ${violations.length} rule${violations.length === 1 ? '' : 's'}:\\n${lines.join('\\n')}${more}`\n\t\t\t)\n\t\t},\n\t\tstop() {\n\t\t\tunchecked()\n\t\t\tunwatched()\n\t\t\tobserver?.dispose()\n\t\t}\n\t}\n}\n\n/**\n * Whether a computer player played fair over a run (`fairPlay`): every command it sent named what its own snapshot\n * had, and how many the game refused\n *\n * @beta\n */\nexport interface FairPlay {\n\t/** Commands that named an entity it did not see, or a place off the map */\n\treadonly unfair: readonly AiViolation[]\n\t/** Commands the game refused while watched (a unit that could not do it, a place it could not build at) */\n\treadonly refused: number\n\t/** Throws where it sent any command about what it did not see */\n\tassert(): void\n\t/** Stops watching the brain; the violations found so far stay */\n\tstop(): void\n}\n\n/**\n * Follows the brain at a player from now on for fair play: that it never sends a command about an entity its snapshot\n * did not have (a fog leak: its seat's session would drop the command, so a game shows nothing; this says it), and\n * counts what the game refused\n *\n * @beta\n */\nexport function fairPlay(world: World, player: PlayerId): FairPlay {\n\tconst watch = watchComputer(world, player, { invariants: ['commands'] })\n\tconst brain = watch.brain\n\tconst refusedBefore = brain.stats.refused\n\treturn {\n\t\tget unfair() {\n\t\t\treturn watch.violations\n\t\t},\n\t\tget refused() {\n\t\t\treturn brain.stats.refused - refusedBefore\n\t\t},\n\t\tassert: () => watch.assert(),\n\t\tstop: () => watch.stop()\n\t}\n}\n\n/**\n * One thing a computer player decided, with whose: a line of a replay's side file (`recordDecisions`)\n *\n * @beta\n */\nexport interface RecordedDecision extends AiDecision {\n\t/** The player whose computer made the decision */\n\tplayer: PlayerId\n\t/** The brain's id */\n\tbrain: string\n}\n\n/**\n * The decisions of every computer of a world, as they are made (`recordDecisions`): plain data, for a side file beside a\n * replay of commands, read back by whoever wonders why the computer did what the replay shows\n *\n * @beta\n */\nexport interface DecisionRecorder {\n\t/** Every decision so far, in the order made */\n\treadonly decisions: readonly RecordedDecision[]\n\t/** Stops recording; the decisions so far stay */\n\tstop(): void\n}\n\n/** How many recorders were made: each one's system a name of its own */\nlet recorders = 0\n\n/**\n * Keeps the decisions of every brain seated at a world, from now on, those seated later included (looked for at each\n * tick, by a system of its own that keeps nothing in a save)\n *\n * @beta\n */\nexport function recordDecisions(world: World): DecisionRecorder {\n\tconst decisions: RecordedDecision[] = []\n\tconst watched = new Map<Brain, () => void>()\n\tconst look = () => {\n\t\tfor (const player of world.computers.list()) {\n\t\t\tconst brain = brainOf(world, player)\n\t\t\tif (!brain || watched.has(brain)) continue\n\t\t\twatched.set(brain, brain.watch({ decided: (decision) => void decisions.push({ ...decision, player: brain.playerId, brain: brain.def.id }) }))\n\t\t}\n\t}\n\tlook()\n\tconst name = `core.ai.recordDecisions.${++recorders}`\n\tworld.addSystem({ name, update: look })\n\treturn {\n\t\tdecisions,\n\t\tstop() {\n\t\t\tworld.removeSystem(name)\n\t\t\tfor (const unwatch of watched.values()) unwatch()\n\t\t\twatched.clear()\n\t\t}\n\t}\n}\n\n/**\n * Where a game saved and loaded first decided otherwise than the game it was saved from (`checkComputerSave`): the\n * decision each made at that place in their logs. `null` where they decided alike to the end\n *\n * @beta\n */\nexport interface DecisionsApart {\n\t/** How many decisions since the save they shared before this one */\n\tindex: number\n\t/** The game that went on from the save */\n\tsaved?: RecordedDecision\n\t/** The game loaded from it */\n\tloaded?: RecordedDecision\n}\n\n/**\n * The seventh invariant of a computer player: a game saved at tick `from` and loaded makes the same decisions from then\n * on as the game it was saved from, under the same commands. Makes the world with `make` (its computers seated, as a\n * game seats them), runs it to `from`, saves it as a file would keep it and loads that with `game`, then runs both to\n * `ticks` and compares what every computer decided. What lost rng, tasks or memory in a restore shows as\n *\n *     expect(await checkComputerSave(() => duel(), { from: 600, ticks: 2400, rules: melee })).toBeNull()\n *\n * @beta\n */\nexport async function checkComputerSave(\n\tmake: () => World | Promise<World>,\n\toptions: { from: number; ticks: number; rules: Rules }\n): Promise<DecisionsApart | null> {\n\tconst saved = await make()\n\tlet loaded: World | undefined\n\ttry {\n\t\twhile (saved.tick < options.from) saved.step()\n\t\tloaded = await loadWorld(decodeSave(encodeSave(saveWorld(saved))), { rules: options.rules })\n\t\tconst before = recordDecisions(saved)\n\t\tconst after = recordDecisions(loaded)\n\t\twhile (saved.tick < options.ticks) {\n\t\t\tsaved.step()\n\t\t\tloaded.step()\n\t\t}\n\t\tbefore.stop()\n\t\tafter.stop()\n\t\tconst a = before.decisions\n\t\tconst b = after.decisions\n\t\tfor (let i = 0; i < Math.max(a.length, b.length); i++)\n\t\t\tif (JSON.stringify(a[i]) !== JSON.stringify(b[i])) return { index: i, ...(a[i] && { saved: a[i] }), ...(b[i] && { loaded: b[i] }) }\n\t\treturn null\n\t} finally {\n\t\tsaved.dispose()\n\t\tloaded?.dispose()\n\t}\n}\n"],"mappings":"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"}

package/dist/areas.d.ts

@@ -77,13 +77,14 @@ export declare function areaShapeOf(ref: AreaRef, regions: readonly MapRegion[])
 /**
  * A named part of the map that the rules watch: who walks into it and out of it (`enteredArea`, `leftArea` events),
  * and who is in it now (`world.areas`). Units count, by where their middle is; buildings, scenery and units inside
- * something do not. Given in `GameModule.areas`
+ * something do not. Given in `Rules.areas`
  *
  * @beta
  */
 export interface AreaDef {
     /** Shared by every game, like other ids: give it a prefix of the game's (`'td.gate'`) */
     id: string;
+    /** The area's shape in cells, one of the `AreaShape`s */
     shape: AreaShape;
 }
 /**
@@ -122,7 +123,9 @@ export declare class Areas {
     constructor(world: World, defs: readonly AreaDef[]);
     /** The areas of the game, then those added while it runs */
     get all(): Iterable<AreaDef>;
+    /** How many areas there are: the game's and those added while it runs */
     get size(): number;
+    /** Gives the area with the id; throws when there is none */
     get(id: string): AreaDef;
     /** Whether there is an area of that id */
     has(id: string): boolean;

package/dist/areas.js

@@ -0,0 +1,295 @@
+import { hypot } from "./exactMath.js";
+import { defineComponent } from "./components.js";
+import { enteredArea, leftArea } from "./engineEvents.js";
+//#region src/areas.ts
+/**
+* The box round a shape: its least and greatest x and z on the map
+*
+* @beta
+*/
+function shapeBounds(shape) {
+	if (shape.kind === "circle") return {
+		x0: shape.x - shape.radius,
+		z0: shape.z - shape.radius,
+		x1: shape.x + shape.radius,
+		z1: shape.z + shape.radius
+	};
+	if (shape.kind === "rect") return {
+		x0: shape.x - shape.width / 2,
+		z0: shape.z - shape.depth / 2,
+		x1: shape.x + shape.width / 2,
+		z1: shape.z + shape.depth / 2
+	};
+	let x0 = Infinity;
+	let z0 = Infinity;
+	let x1 = -Infinity;
+	let z1 = -Infinity;
+	for (const point of shape.points) {
+		x0 = Math.min(x0, shape.x + point.x);
+		z0 = Math.min(z0, shape.z + point.z);
+		x1 = Math.max(x1, shape.x + point.x);
+		z1 = Math.max(z1, shape.z + point.z);
+	}
+	return shape.points.length ? {
+		x0,
+		z0,
+		x1,
+		z1
+	} : {
+		x0: shape.x,
+		z0: shape.z,
+		x1: shape.x,
+		z1: shape.z
+	};
+}
+/**
+* How much ground a shape covers, in cells
+*
+* @beta
+*/
+function shapeArea(shape) {
+	if (shape.kind === "circle") return Math.PI * shape.radius * shape.radius;
+	if (shape.kind === "rect") return shape.width * shape.depth;
+	let twice = 0;
+	const { points } = shape;
+	for (let i = 0, j = points.length - 1; i < points.length; j = i++) twice += points[j].x * points[i].z - points[i].x * points[j].z;
+	return Math.abs(twice) / 2;
+}
+/**
+* A shape as a circle or a rectangle: a polygon as the rectangle round it. For what draws only those (mist, clouds and
+* weather in a region of the map)
+*
+* @beta
+*/
+function shapeAsBox(shape) {
+	if (shape.kind !== "polygon") return shape;
+	const { x0, z0, x1, z1 } = shapeBounds(shape);
+	return {
+		kind: "rect",
+		x: (x0 + x1) / 2,
+		z: (z0 + z1) / 2,
+		width: x1 - x0,
+		depth: z1 - z0
+	};
+}
+/**
+* A shape moved to stand at a point and sized `scale` times: a prefab's area where the prefab is put
+*
+* @beta
+*/
+function shapeAt(shape, at, scale = 1) {
+	if (shape.kind === "circle") return {
+		kind: "circle",
+		x: at.x,
+		z: at.z,
+		radius: shape.radius * scale
+	};
+	if (shape.kind === "rect") return {
+		kind: "rect",
+		x: at.x,
+		z: at.z,
+		width: shape.width * scale,
+		depth: shape.depth * scale
+	};
+	return {
+		kind: "polygon",
+		x: at.x,
+		z: at.z,
+		points: shape.points.map((point) => ({
+			x: point.x * scale,
+			z: point.z * scale
+		}))
+	};
+}
+/**
+* The shape an `AreaRef` stands for: its own, or the named region's among the map's. Nothing for a region that is
+* not there
+*
+* @beta
+*/
+function areaShapeOf(ref, regions) {
+	if ("region" in ref) return regions.find((region) => region.name === ref.region)?.shape;
+	return ref;
+}
+/**
+* Typed help for writing an area
+*
+* @beta
+*/
+var defineArea = (def) => def;
+/**
+* Whether a point is in a shape
+*
+* @beta
+*/
+function inShape(shape, point) {
+	const dx = point.x - shape.x;
+	const dz = point.z - shape.z;
+	if (shape.kind === "circle") return dx * dx + dz * dz <= shape.radius * shape.radius;
+	if (shape.kind === "rect") return Math.abs(dx) <= shape.width / 2 && Math.abs(dz) <= shape.depth / 2;
+	const { points } = shape;
+	let odd = false;
+	for (let i = 0, j = points.length - 1; i < points.length; j = i++) {
+		const a = points[i];
+		const b = points[j];
+		if (a.z > dz !== b.z > dz && dx < (b.x - a.x) * (dz - a.z) / (b.z - a.z) + a.x) odd = !odd;
+	}
+	return odd;
+}
+/**
+* The radius of a circle round the whole shape from its middle (`x`, `z`): what the spatial index is asked for
+*
+* @beta
+*/
+function shapeReach(shape) {
+	if (shape.kind === "circle") return shape.radius;
+	if (shape.kind === "rect") return hypot(shape.width, shape.depth) / 2;
+	let most = 0;
+	for (const point of shape.points) most = Math.max(most, hypot(point.x, point.z));
+	return most;
+}
+var reach = shapeReach;
+/** Who is in each area, by id: kept in the world, so that a save knows, and nobody walks in twice after loading */
+var inside = defineComponent({
+	id: "core.areas",
+	default: () => ({})
+});
+/** Areas added while the game runs (`areas.add`): kept in the world, so that a save has them */
+var added = defineComponent({
+	id: "core.areasAdded",
+	default: () => []
+});
+/**
+* The areas of a world, and who is in them
+*
+* @beta
+*/
+var Areas = class {
+	world;
+	byId = /* @__PURE__ */ new Map();
+	/** Kept between ticks, not made anew */
+	found = [];
+	now = /* @__PURE__ */ new Set();
+	constructor(world, defs) {
+		this.world = world;
+		for (const def of defs) {
+			if (this.byId.has(def.id)) throw new Error(`Area "${def.id}" is there twice`);
+			this.byId.set(def.id, def);
+		}
+	}
+	/** The areas of the game, then those added while it runs */
+	get all() {
+		return [...this.byId.values(), ...this.added()];
+	}
+	/** How many areas there are: the game's and those added while it runs */
+	get size() {
+		return this.byId.size + this.added().length;
+	}
+	/** Gives the area with the id; throws when there is none */
+	get(id) {
+		const def = this.find(id);
+		if (!def) throw new Error(`There is no area "${id}"`);
+		return def;
+	}
+	/** Whether there is an area of that id */
+	has(id) {
+		return !!this.find(id);
+	}
+	find(id) {
+		return this.byId.get(id) ?? this.added().find((def) => def.id === id);
+	}
+	added() {
+		return this.world.state(added);
+	}
+	/**
+	* Adds an area while the game runs: a zone a spell leaves, a ring that closes in, a part of the map a quest opens.
+	* Who is in it is found at the end of the tick, and walks in then. One of the same id, added before, is replaced
+	*/
+	add(def) {
+		if (this.byId.has(def.id)) throw new Error(`Area "${def.id}" is one of the game's: it cannot be added again`);
+		const list = this.added();
+		const index = list.findIndex((other) => other.id === def.id);
+		const copy = {
+			id: def.id,
+			shape: { ...def.shape }
+		};
+		if (index >= 0) list[index] = copy;
+		else list.push(copy);
+	}
+	/** Takes away an area added while the game runs. Who was in it leaves it (`leftArea`). False when there was none */
+	remove(id) {
+		const list = this.added();
+		const index = list.findIndex((def) => def.id === id);
+		if (index < 0) return false;
+		list.splice(index, 1);
+		const state = this.world.state(inside);
+		for (const entityId of state[id] ?? []) {
+			const entity = this.world.get(entityId);
+			if (entity?.alive) this.world.events.emit(leftArea, {
+				area: id,
+				entity
+			});
+		}
+		delete state[id];
+		return true;
+	}
+	/** Whether the entity was in the area when the areas were last looked at: the end of the last tick's movement */
+	contains(id, entity) {
+		return this.idsIn(id).includes(entity.id);
+	}
+	/** Who is in the area, as of the last look */
+	inside(id) {
+		const result = [];
+		for (const entityId of this.idsIn(id)) {
+			const entity = this.world.get(entityId);
+			if (entity) result.push(entity);
+		}
+		return result;
+	}
+	idsIn(id) {
+		this.get(id);
+		return this.world.state(inside)[id] ?? [];
+	}
+	/** Looks who is in each area now, and tells who walked in and who walked out. What died in one is just gone */
+	update() {
+		const state = this.world.state(inside);
+		for (const area of this.byId.values()) this.look(area, state);
+		for (const area of this.added()) this.look(area, state);
+	}
+	/** Who is in one area now, against who was */
+	look(area, state) {
+		const { world, found, now } = this;
+		const { shape } = area;
+		now.clear();
+		for (const entity of world.spatial.query(shape.x, shape.z, reach(shape), found)) {
+			if (entity.def.kind !== "unit" || !entity.alive || entity.hidden || !inShape(shape, entity.pos)) continue;
+			now.add(entity.id);
+		}
+		const before = state[area.id] ?? [];
+		for (const id of before) {
+			if (now.has(id)) continue;
+			const entity = world.get(id);
+			if (entity?.alive) world.events.emit(leftArea, {
+				area: area.id,
+				entity
+			});
+		}
+		for (const id of now) if (!before.includes(id)) world.events.emit(enteredArea, {
+			area: area.id,
+			entity: world.get(id)
+		});
+		if (now.size || before.length) state[area.id] = [...now];
+	}
+};
+/** Watches the areas, after everyone has moved. Does nothing in a game without any */
+var areaSystem = {
+	name: "areas",
+	phase: "resolve",
+	update(world) {
+		if (world.areas.size) world.areas.update();
+	}
+};
+//#endregion
+export { Areas, added, areaShapeOf, areaSystem, defineArea, inShape, inside, shapeArea, shapeAsBox, shapeAt, shapeBounds, shapeReach };
+
+//# sourceMappingURL=areas.js.map

package/dist/areas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"areas.js","names":["leftAreaEvent","enteredAreaEvent"],"sources":["../src/areas.ts"],"sourcesContent":["import { enteredArea as enteredAreaEvent, leftArea as leftAreaEvent } from '#engine/engineEvents'\nimport { defineComponent } from './components'\nimport type { Entity } from './entity'\nimport type { Vec2 } from './math'\nimport type { System } from './registry'\nimport type { World } from './world'\nimport { hypot } from './exactMath'\nimport type { MapRegion } from './map'\n\n/**\n * Where an area is on the map: a circle, a rectangle by its middle and size, or a polygon by its corners round a middle\n * of its own (`points`, each from `x` and `z`, three or more, in order round it: moving the middle moves it whole)\n *\n * @beta\n */\nexport type AreaShape =\n\t| { kind: 'circle'; x: number; z: number; radius: number }\n\t| { kind: 'rect'; x: number; z: number; width: number; depth: number }\n\t| { kind: 'polygon'; x: number; z: number; points: Vec2[] }\n\n/**\n * The box round a shape: its least and greatest x and z on the map\n *\n * @beta\n */\nexport function shapeBounds(shape: AreaShape): { x0: number; z0: number; x1: number; z1: number } {\n\tif (shape.kind === 'circle')\n\t\treturn { x0: shape.x - shape.radius, z0: shape.z - shape.radius, x1: shape.x + shape.radius, z1: shape.z + shape.radius }\n\tif (shape.kind === 'rect')\n\t\treturn { x0: shape.x - shape.width / 2, z0: shape.z - shape.depth / 2, x1: shape.x + shape.width / 2, z1: shape.z + shape.depth / 2 }\n\tlet x0 = Infinity\n\tlet z0 = Infinity\n\tlet x1 = -Infinity\n\tlet z1 = -Infinity\n\tfor (const point of shape.points) {\n\t\tx0 = Math.min(x0, shape.x + point.x)\n\t\tz0 = Math.min(z0, shape.z + point.z)\n\t\tx1 = Math.max(x1, shape.x + point.x)\n\t\tz1 = Math.max(z1, shape.z + point.z)\n\t}\n\treturn shape.points.length ? { x0, z0, x1, z1 } : { x0: shape.x, z0: shape.z, x1: shape.x, z1: shape.z }\n}\n\n/**\n * How much ground a shape covers, in cells\n *\n * @beta\n */\nexport function shapeArea(shape: AreaShape): number {\n\tif (shape.kind === 'circle') return Math.PI * shape.radius * shape.radius\n\tif (shape.kind === 'rect') return shape.width * shape.depth\n\tlet twice = 0\n\tconst { points } = shape\n\tfor (let i = 0, j = points.length - 1; i < points.length; j = i++) twice += points[j].x * points[i].z - points[i].x * points[j].z\n\treturn Math.abs(twice) / 2\n}\n\n/**\n * A shape as a circle or a rectangle: a polygon as the rectangle round it. For what draws only those (mist, clouds and\n * weather in a region of the map)\n *\n * @beta\n */\nexport function shapeAsBox(shape: AreaShape): Exclude<AreaShape, { kind: 'polygon' }> {\n\tif (shape.kind !== 'polygon') return shape\n\tconst { x0, z0, x1, z1 } = shapeBounds(shape)\n\treturn { kind: 'rect', x: (x0 + x1) / 2, z: (z0 + z1) / 2, width: x1 - x0, depth: z1 - z0 }\n}\n\n/**\n * A shape moved to stand at a point and sized `scale` times: a prefab's area where the prefab is put\n *\n * @beta\n */\nexport function shapeAt(shape: AreaShape, at: Vec2, scale = 1): AreaShape {\n\tif (shape.kind === 'circle') return { kind: 'circle', x: at.x, z: at.z, radius: shape.radius * scale }\n\tif (shape.kind === 'rect') return { kind: 'rect', x: at.x, z: at.z, width: shape.width * scale, depth: shape.depth * scale }\n\treturn { kind: 'polygon', x: at.x, z: at.z, points: shape.points.map((point) => ({ x: point.x * scale, z: point.z * scale })) }\n}\n\n/**\n * Where something of the map is, by a shape of its own or by a region of the map, named: mist, clouds and weather in\n * places (`MapMistArea.shape`). By the region, it is where the region is, moved with it, and is the rules' too\n *\n * @beta\n */\nexport type AreaRef = AreaShape | { region: string }\n\n/**\n * The shape an `AreaRef` stands for: its own, or the named region's among the map's. Nothing for a region that is\n * not there\n *\n * @beta\n */\nexport function areaShapeOf(ref: AreaRef, regions: readonly MapRegion[]): AreaShape | undefined {\n\tif ('region' in ref) return regions.find((region) => region.name === ref.region)?.shape\n\treturn ref\n}\n\n/**\n * A named part of the map that the rules watch: who walks into it and out of it (`enteredArea`, `leftArea` events),\n * and who is in it now (`world.areas`). Units count, by where their middle is; buildings, scenery and units inside\n * something do not. Given in `Rules.areas`\n *\n * @beta\n */\nexport interface AreaDef {\n\t/** Shared by every game, like other ids: give it a prefix of the game's (`'td.gate'`) */\n\tid: string\n\t/** The area's shape in cells, one of the `AreaShape`s */\n\tshape: AreaShape\n}\n\n/**\n * Typed help for writing an area\n *\n * @beta\n */\nexport const defineArea = (def: AreaDef): AreaDef => def\n\n/**\n * Whether a point is in a shape\n *\n * @beta\n */\nexport function inShape(shape: AreaShape, point: Vec2): boolean {\n\tconst dx = point.x - shape.x\n\tconst dz = point.z - shape.z\n\tif (shape.kind === 'circle') return dx * dx + dz * dz <= shape.radius * shape.radius\n\tif (shape.kind === 'rect') return Math.abs(dx) <= shape.width / 2 && Math.abs(dz) <= shape.depth / 2\n\t// a polygon: in where a line from the point crosses its edges an odd number of times\n\tconst { points } = shape\n\tlet odd = false\n\tfor (let i = 0, j = points.length - 1; i < points.length; j = i++) {\n\t\tconst a = points[i]\n\t\tconst b = points[j]\n\t\tif (a.z > dz !== b.z > dz && dx < ((b.x - a.x) * (dz - a.z)) / (b.z - a.z) + a.x) odd = !odd\n\t}\n\treturn odd\n}\n\n/**\n * The radius of a circle round the whole shape from its middle (`x`, `z`): what the spatial index is asked for\n *\n * @beta\n */\nexport function shapeReach(shape: AreaShape): number {\n\tif (shape.kind === 'circle') return shape.radius\n\tif (shape.kind === 'rect') return hypot(shape.width, shape.depth) / 2\n\tlet most = 0\n\tfor (const point of shape.points) most = Math.max(most, hypot(point.x, point.z))\n\treturn most\n}\nconst reach = shapeReach\n\n/** Who is in each area, by id: kept in the world, so that a save knows, and nobody walks in twice after loading */\nexport const inside = defineComponent<Record<string, number[]>>({ id: 'core.areas', default: () => ({}) })\n/** Areas added while the game runs (`areas.add`): kept in the world, so that a save has them */\nexport const added = defineComponent<AreaDef[]>({ id: 'core.areasAdded', default: () => [] })\n\n/**\n * The areas of a world, and who is in them\n *\n * @beta\n */\nexport class Areas {\n\tprivate readonly byId = new Map<string, AreaDef>()\n\t/** Kept between ticks, not made anew */\n\tprivate readonly found: Entity[] = []\n\tprivate readonly now = new Set<number>()\n\n\tconstructor(\n\t\tprivate readonly world: World,\n\t\tdefs: readonly AreaDef[]\n\t) {\n\t\tfor (const def of defs) {\n\t\t\tif (this.byId.has(def.id)) throw new Error(`Area \"${def.id}\" is there twice`)\n\t\t\tthis.byId.set(def.id, def)\n\t\t}\n\t}\n\n\t/** The areas of the game, then those added while it runs */\n\tget all(): Iterable<AreaDef> {\n\t\treturn [...this.byId.values(), ...this.added()]\n\t}\n\n\t/** How many areas there are: the game's and those added while it runs */\n\tget size(): number {\n\t\treturn this.byId.size + this.added().length\n\t}\n\n\t/** Gives the area with the id; throws when there is none */\n\tget(id: string): AreaDef {\n\t\tconst def = this.find(id)\n\t\tif (!def) throw new Error(`There is no area \"${id}\"`)\n\t\treturn def\n\t}\n\n\t/** Whether there is an area of that id */\n\thas(id: string): boolean {\n\t\treturn !!this.find(id)\n\t}\n\n\tprivate find(id: string): AreaDef | undefined {\n\t\treturn this.byId.get(id) ?? this.added().find((def) => def.id === id)\n\t}\n\n\tprivate added(): AreaDef[] {\n\t\treturn this.world.state(added)\n\t}\n\n\t/**\n\t * Adds an area while the game runs: a zone a spell leaves, a ring that closes in, a part of the map a quest opens.\n\t * Who is in it is found at the end of the tick, and walks in then. One of the same id, added before, is replaced\n\t */\n\tadd(def: AreaDef): void {\n\t\tif (this.byId.has(def.id)) throw new Error(`Area \"${def.id}\" is one of the game's: it cannot be added again`)\n\t\tconst list = this.added()\n\t\tconst index = list.findIndex((other) => other.id === def.id)\n\t\t// a copy: the shape may be moved by adding it again, not by changing what was given\n\t\tconst copy = { id: def.id, shape: { ...def.shape } }\n\t\tif (index >= 0) list[index] = copy\n\t\telse list.push(copy)\n\t}\n\n\t/** Takes away an area added while the game runs. Who was in it leaves it (`leftArea`). False when there was none */\n\tremove(id: string): boolean {\n\t\tconst list = this.added()\n\t\tconst index = list.findIndex((def) => def.id === id)\n\t\tif (index < 0) return false\n\t\tlist.splice(index, 1)\n\t\tconst state = this.world.state(inside)\n\t\tfor (const entityId of state[id] ?? []) {\n\t\t\tconst entity = this.world.get(entityId)\n\t\t\tif (entity?.alive) this.world.events.emit(leftAreaEvent, { area: id, entity })\n\t\t}\n\t\tdelete state[id]\n\t\treturn true\n\t}\n\n\t/** Whether the entity was in the area when the areas were last looked at: the end of the last tick's movement */\n\tcontains(id: string, entity: Entity): boolean {\n\t\treturn this.idsIn(id).includes(entity.id)\n\t}\n\n\t/** Who is in the area, as of the last look */\n\tinside(id: string): Entity[] {\n\t\tconst result: Entity[] = []\n\t\tfor (const entityId of this.idsIn(id)) {\n\t\t\tconst entity = this.world.get(entityId)\n\t\t\tif (entity) result.push(entity)\n\t\t}\n\t\treturn result\n\t}\n\n\tprivate idsIn(id: string): number[] {\n\t\tthis.get(id)\n\t\treturn this.world.state(inside)[id] ?? []\n\t}\n\n\t/** Looks who is in each area now, and tells who walked in and who walked out. What died in one is just gone */\n\tupdate(): void {\n\t\tconst state = this.world.state(inside)\n\t\t// the game's, then those added: no list made of both every tick\n\t\tfor (const area of this.byId.values()) this.look(area, state)\n\t\tfor (const area of this.added()) this.look(area, state)\n\t}\n\n\t/** Who is in one area now, against who was */\n\tprivate look(area: AreaDef, state: Record<string, number[]>): void {\n\t\tconst { world, found, now } = this\n\t\tconst { shape } = area\n\t\tnow.clear()\n\t\tfor (const entity of world.spatial.query(shape.x, shape.z, reach(shape), found)) {\n\t\t\tif (entity.def.kind !== 'unit' || !entity.alive || entity.hidden || !inShape(shape, entity.pos)) continue\n\t\t\tnow.add(entity.id)\n\t\t}\n\t\tconst before = state[area.id] ?? []\n\t\tfor (const id of before) {\n\t\t\tif (now.has(id)) continue\n\t\t\tconst entity = world.get(id)\n\t\t\tif (entity?.alive) world.events.emit(leftAreaEvent, { area: area.id, entity })\n\t\t}\n\t\tfor (const id of now) {\n\t\t\tif (!before.includes(id)) world.events.emit(enteredAreaEvent, { area: area.id, entity: world.get(id)! })\n\t\t}\n\t\tif (now.size || before.length) state[area.id] = [...now]\n\t}\n}\n\n/** Watches the areas, after everyone has moved. Does nothing in a game without any */\nexport const areaSystem: System = {\n\tname: 'areas',\n\tphase: 'resolve',\n\tupdate(world) {\n\t\tif (world.areas.size) world.areas.update()\n\t}\n}\n"],"mappings":"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"}