@v12-engine/engine 0.0.0-stage → 0.1.0

package/dist/testing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"testing.js","names":[],"sources":["../src/fixture.ts","../src/aiTesting.ts","../src/testing.ts"],"sourcesContent":["/**\n * The fixture game: the smallest game the engine's kit has a part for each of its roles in (a hall and its workers,\n * supply, a barracks of a fighter and an archer, a tower, an altar and a hero, a gold mine and trees, a creep, an\n * upgrade, abilities and items), for the engine's own tests and a game's. Its numbers are round (health 100 or 200,\n * damage 10, speed 4) so that what a test expects reads as what it means: a soldier hits an archer ten times\n */\nimport type { AbilityDef, BuffDef, ItemDef, UnitTypeDef, UpgradeDef } from './defs'\nimport type { GameModule } from './game'\nimport { createMap, type GameMap } from './map'\nimport { dist, type Vec2 } from './math'\nimport { withHeroes } from './packs/heroes'\nimport type { PlayerId } from './entity'\nimport type { World } from './world'\n\nconst worker: UnitTypeDef = {\n\tid: 'worker',\n\tname: 'Worker',\n\tkind: 'unit',\n\tradius: 0.4,\n\tstats: { health: 100, attackDamage: 5, attackSpeed: 1, attackRange: 0.5, moveSpeed: 4 },\n\tsight: 8,\n\tattacks: [{ damagePoint: 0.3, acquisitionRange: 0, targets: ['unit', 'building'] }],\n\tcost: { gold: 50 },\n\tsupply: 1,\n\tbuildTime: 10,\n\tharvester: { capacity: 10, gatherTime: 1 },\n\tbuilds: ['hall', 'supply', 'barracks', 'tower', 'altar']\n}\n\nconst soldier: UnitTypeDef = {\n\tid: 'soldier',\n\tname: 'Soldier',\n\tkind: 'unit',\n\tradius: 0.45,\n\tstats: { health: 200, attackDamage: 10, attackSpeed: 1, attackRange: 0.5, armor: 10, moveSpeed: 4 },\n\tsight: 10,\n\tattacks: [{ damagePoint: 0.3, acquisitionRange: 8 }],\n\tcost: { gold: 100 },\n\tsupply: 2,\n\tbuildTime: 10,\n\tabilities: ['guard']\n}\n\nconst archer: UnitTypeDef = {\n\tid: 'archer',\n\tname: 'Archer',\n\tkind: 'unit',\n\tradius: 0.45,\n\tstats: { health: 100, attackDamage: 10, attackSpeed: 1, attackRange: 6, moveSpeed: 4 },\n\tsight: 10,\n\tattacks: [{ damagePoint: 0.3, acquisitionRange: 8, projectileSpeed: 20, targets: ['ground', 'air'] }],\n\tcost: { gold: 100, lumber: 20 },\n\tsupply: 2,\n\tbuildTime: 10\n}\n\nconst hero: UnitTypeDef = {\n\tid: 'hero',\n\tname: 'Hero',\n\tkind: 'unit',\n\tradius: 0.5,\n\tstats: { health: 300, mana: 100, manaRegen: 1, attackDamage: 20, attackSpeed: 1, attackRange: 0.5, armor: 10, moveSpeed: 4 },\n\tsight: 12,\n\tattacks: [{ damagePoint: 0.3, acquisitionRange: 8 }],\n\thero: { growth: { stats: { health: 20, mana: 10, attackDamage: 2 } }, learns: ['heal', 'guard'] },\n\tinventory: 6,\n\tcost: { gold: 400, lumber: 100 },\n\tsupply: 5,\n\tbuildTime: 40\n}\n\nconst creep: UnitTypeDef = {\n\tid: 'creep',\n\tname: 'Creep',\n\tkind: 'unit',\n\tradius: 0.45,\n\tstats: { health: 200, attackDamage: 10, attackSpeed: 1, attackRange: 0.5, moveSpeed: 3 },\n\tsight: 8,\n\tattacks: [{ damagePoint: 0.3, acquisitionRange: 5 }],\n\tlevel: 1,\n\tbounty: [10, 10],\n\txp: 20\n}\n\nconst hall: UnitTypeDef = {\n\tid: 'hall',\n\tname: 'Hall',\n\tkind: 'building',\n\tradius: 2,\n\tfootprint: { w: 4, d: 4 },\n\tstats: { health: 1500, armor: 10 },\n\tsight: 12,\n\tcost: { gold: 400, lumber: 200 },\n\tbuildTime: 40,\n\tsupplyProvided: 10,\n\ttrains: ['worker'],\n\tdropOff: true,\n\tupgradesTo: 'keep'\n}\n\nconst keep: UnitTypeDef = {\n\t...hall,\n\tid: 'keep',\n\tname: 'Keep',\n\tstats: { health: 2000, armor: 10 },\n\tcost: { gold: 300, lumber: 200 },\n\tprovides: ['hall'],\n\tupgradesTo: undefined\n}\n\nconst supply: UnitTypeDef = {\n\tid: 'supply',\n\tname: 'Supply',\n\tkind: 'building',\n\tradius: 1,\n\tfootprint: { w: 2, d: 2 },\n\tstats: { health: 500, armor: 10 },\n\tsight: 6,\n\tcost: { gold: 50 },\n\tbuildTime: 10,\n\tsupplyProvided: 10\n}\n\nconst barracks: UnitTypeDef = {\n\tid: 'barracks',\n\tname: 'Barracks',\n\tkind: 'building',\n\tradius: 1.5,\n\tfootprint: { w: 3, d: 3 },\n\tstats: { health: 1000, armor: 10 },\n\tsight: 9,\n\tcost: { gold: 150, lumber: 50 },\n\tbuildTime: 20,\n\ttrains: ['soldier', 'archer'],\n\tresearches: ['armour']\n}\n\nconst tower: UnitTypeDef = {\n\tid: 'tower',\n\tname: 'Tower',\n\tkind: 'building',\n\tradius: 1,\n\tfootprint: { w: 2, d: 2 },\n\tstats: { health: 500, attackDamage: 20, attackSpeed: 1, attackRange: 8, armor: 10 },\n\tsight: 12,\n\tattacks: [{ damagePoint: 0.3, acquisitionRange: 8, projectileSpeed: 20, targets: ['ground', 'air'] }],\n\tcost: { gold: 100, lumber: 50 },\n\tbuildTime: 20,\n\trequires: ['barracks']\n}\n\nconst altar: UnitTypeDef = {\n\tid: 'altar',\n\tname: 'Altar',\n\tkind: 'building',\n\tradius: 1.5,\n\tfootprint: { w: 3, d: 3 },\n\tstats: { health: 1000, armor: 10 },\n\tsight: 9,\n\tcost: { gold: 200, lumber: 50 },\n\tbuildTime: 30,\n\ttrains: ['hero'],\n\trevives: true\n}\n\nconst mine: UnitTypeDef = {\n\tid: 'mine',\n\tname: 'Mine',\n\tkind: 'resource',\n\tradius: 2,\n\tfootprint: { w: 4, d: 4 },\n\tstats: { health: 1 },\n\tsight: 0,\n\tinvulnerable: true,\n\tresource: { kind: 'gold', amount: 10000, slots: 1, entered: true }\n}\n\nconst tree: UnitTypeDef = {\n\tid: 'tree',\n\tname: 'Tree',\n\tkind: 'resource',\n\tradius: 0.5,\n\tfootprint: { w: 1, d: 1 },\n\tstats: { health: 1 },\n\tsight: 0,\n\tinvulnerable: true,\n\tfellable: true,\n\tresource: { kind: 'lumber', amount: 50, slots: 1, gatherTime: 5 }\n}\n\nconst armour: UpgradeDef = {\n\tid: 'armour',\n\tname: 'Armour',\n\tdescription: '+10 armor for soldiers and archers',\n\tcost: { gold: 100, lumber: 50 },\n\tresearchTime: 20,\n\tmaxLevel: 2,\n\teffects: [{ units: ['soldier', 'archer'], stats: { armor: 10 } }]\n}\n\nconst guarded: BuffDef = { id: 'guarded', name: 'Guarded', description: '+20 armor', duration: 10, stats: { armor: 20 } }\n\nconst abilities: AbilityDef[] = [\n\t{\n\t\tid: 'heal',\n\t\tname: 'Heal',\n\t\tdescription: 'Heals a friendly unit for 100 or 200',\n\t\ttarget: 'unit',\n\t\ttargets: { allies: true, self: false },\n\t\tmanaCost: 10,\n\t\tcooldown: 5,\n\t\trange: 6,\n\t\teffects: [{ type: 'heal', amount: [100, 200] }]\n\t},\n\t{\n\t\tid: 'guard',\n\t\tname: 'Guard',\n\t\tdescription: '+20 armor for 10 seconds',\n\t\ttarget: 'none',\n\t\tcooldown: 10,\n\t\teffects: [{ type: 'buff', buff: 'guarded', on: 'caster' }]\n\t},\n\t{ id: 'drink', name: 'Drink', description: 'Heals 100', target: 'none', cooldown: 10, effects: [{ type: 'heal', amount: 100, on: 'caster' }] }\n]\n\nconst items: ItemDef[] = [\n\t{ id: 'sword', name: 'Sword', description: '+10 attack damage', tier: 'basic', cost: { gold: 100 }, bonus: { stats: { attackDamage: 10 } } },\n\t{ id: 'potion', name: 'Potion', description: 'Heals 100 when drunk', tier: 'consumable', cost: { gold: 50 }, charges: 1, ability: 'drink' }\n]\n\n/** A hall where a player starts, and five workers on the side of the closest mine */\nfunction startingBase(world: World, player: PlayerId, at: Vec2): void {\n\tconst base = world.spawn('hall', player, at)\n\tlet closest: Vec2 | undefined\n\tfor (const entity of world.entities.values()) {\n\t\tif (entity.def.resource?.kind !== 'gold' || dist(entity.pos, base.pos) > 20) continue\n\t\tif (!closest || dist(entity.pos, base.pos) < dist(closest, base.pos)) closest = entity.pos\n\t}\n\tconst towards = closest ? { x: Math.sign(closest.x - at.x), z: Math.sign(closest.z - at.z) } : { x: 1, z: 0 }\n\tfor (let i = 0; i < 5; i++)\n\t\tworld.spawn('worker', player, { x: at.x + towards.x * 4 + (i - 2) * towards.z, z: at.z + towards.z * 4 + (i - 2) * towards.x })\n}\n\n/**\n * The fixture game (see the top of this file): every role of the kit, with round numbers. Gold and lumber, 1000 of each\n * to start with; a hall and five workers at each start; heroes on (`withHeroes`); no fog explored at the start. A new\n * one each time, for a test to change\n *\n * @beta\n */\nexport function fixtureGame(): GameModule {\n\treturn {\n\t\tid: 'fixture',\n\t\tname: 'Fixture',\n\t\tversion: '1.0.0',\n\t\tunits: [worker, soldier, archer, hero, creep, hall, keep, supply, barracks, tower, altar, mine, tree].map((def) => structuredClone(def)),\n\t\tupgrades: [structuredClone(armour)],\n\t\tabilities: structuredClone(abilities),\n\t\tbuffs: [structuredClone(guarded)],\n\t\titems: structuredClone(items),\n\t\tresources: [\n\t\t\t{ id: 'gold', name: 'Gold', start: 1000 },\n\t\t\t{ id: 'lumber', name: 'Lumber', start: 1000 }\n\t\t],\n\t\tcurrency: 'gold',\n\t\tpacks: [withHeroes()],\n\t\tstart: { spawn: startingBase }\n\t}\n}\n\n/**\n * A map of the fixture game, 64 cells a side: two players, starting at opposite corners (12, 12 and 52, 52), a gold\n * mine and a row of trees by each start, and a camp of three creeps in the middle\n *\n * @beta\n */\nexport function fixtureMap(): GameMap {\n\tconst map = createMap({ name: 'Fixture', width: 64, depth: 64, game: 'fixture' })\n\tmap.players[0].start = { x: 12, z: 12 }\n\tmap.players[1].start = { x: 52, z: 52 }\n\tlet id = 1\n\tconst object = (type: string, x: number, z: number) => map.objects.push({ id: id++, type, owner: 0, x, z, facing: 0, scale: 1 })\n\tobject('mine', 12, 22)\n\tobject('mine', 52, 42)\n\tfor (let i = 0; i < 6; i++) {\n\t\tobject('tree', 22.5 + i, 4.5)\n\t\tobject('tree', 36.5 + i, 59.5)\n\t}\n\tmap.camps.push({ id: id++, x: 32, z: 32, units: ['creep', 'creep', 'creep'] })\n\treturn map\n}\n","/**\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 GameModule, 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\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\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\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, game: melee })).toBeNull()\n *\n * @beta\n */\nexport async function checkComputerSave(\n\tmake: () => World | Promise<World>,\n\toptions: { from: number; ticks: number; game: GameModule }\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))), { game: options.game })\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","/**\n * `@v12-engine/engine/testing`: what a game's tests are written with. A world runs in a test as it does in a page, with no\n * screen: these make one, step it and give its units orders, so that a test says what happens in the game and little\n * else.\n *\n *     const world = await testWorld(myGame.rules)\n *     const knight = world.spawn('knight', 1, { x: 10, z: 10 })\n *     order(world, [knight], { type: 'move', point: { x: 30, z: 10 } })\n *     run(world, 5, () => knight.pos.x > 29)\n */\nimport type { Entity } from './entity'\nimport { createWorld, type GameModule } from './game'\nimport type { PlayerInit } from './player'\nimport type { Logger } from './log'\nimport type { OrderInit } from './registry'\nimport { Terrain } from './terrain'\nimport type { World } from './world'\n\n/**\n * Flat ground, `size` cells a side: 48 when left out\n *\n * @beta\n */\nexport const flatTerrain = (size = 48): Terrain => new Terrain(size, size, new Float32Array((size + 1) * (size + 1)))\n\n/**\n * The players of a test world, when a test says none: a neutral one, and two who are enemies\n *\n * @beta\n */\nexport const TEST_PLAYERS: PlayerInit[] = [\n\t{ id: 0, name: 'Neutral', team: 0, color: [1, 1, 0], neutral: true },\n\t{ id: 1, name: 'Player', team: 1, color: [0, 0, 1] },\n\t{ id: 2, name: 'Enemy', team: 2, color: [1, 0, 0] }\n]\n\n/**\n * A small world of a game for a test: flat ground, a neutral player and two enemies (`TEST_PLAYERS`), the same every\n * time (seed 7). Each of them is the test's to say otherwise\n *\n * @beta\n */\nexport function testWorld(\n\tgame: GameModule,\n\toptions: { terrain?: Terrain; size?: number; players?: PlayerInit[]; seed?: number; log?: Logger } = {}\n): Promise<World> {\n\treturn createWorld({\n\t\tterrain: options.terrain ?? flatTerrain(options.size),\n\t\tgame,\n\t\tseed: options.seed ?? 7,\n\t\tplayers: options.players ?? TEST_PLAYERS.map((player) => ({ ...player })),\n\t\tlog: options.log\n\t})\n}\n\n/**\n * Steps the world for up to `seconds`, stopping early once `until` holds. Returns the time that went by in it\n *\n * @beta\n */\nexport function run(world: World, seconds: number, until?: () => boolean): number {\n\tconst ticks = Math.ceil(seconds * world.tickRate)\n\tfor (let i = 0; i < ticks; i++) {\n\t\tworld.step()\n\t\tif (until?.()) return (i + 1) / world.tickRate\n\t}\n\treturn seconds\n}\n\n/**\n * Gives units an order, as their owner would: taken up at the next tick. `queue` adds it after what they are doing\n *\n * @beta\n */\nexport const order = (world: World, entities: Entity[], init: OrderInit, queue = false): void =>\n\tworld.issue({ type: 'order', player: entities[0].owner, entities: entities.map((entity) => entity.id), order: init, queue })\n\n// the fixture game, every role of the kit with round numbers: see `fixture.ts`\nexport { fixtureGame, fixtureMap } from './fixture'\n// many games at once, for balance: see `simulate.ts`\nexport {\n\ttype BrainResults,\n\ttype ComputerMeasures,\n\tdefineSimulation,\n\tplayGame,\n\ttype Counted,\n\ttype SimulatedGame,\n\ttype SimulateOptions,\n\tsimulate,\n\ttype Simulation,\n\twinRates\n} from './simulate'\n// a computer player under test: see `aiTesting.ts`\nexport {\n\tbrainOf,\n\tcheckComputerSave,\n\ttype ComputerWatch,\n\ttype DecisionRecorder,\n\ttype DecisionsApart,\n\texpectDecision,\n\ttype FairPlay,\n\tfairPlay,\n\ttype RecordedDecision,\n\trecordDecisions,\n\tthinkOnce,\n\twatchComputer,\n\ttype WatchOptions\n} from './aiTesting'\n\nexport {\n\ttype Apart,\n\tcheckDeterminism,\n\ttype DeterminismOptions,\n\ttype DeterminismReport,\n\ttype Difference,\n\tfirstDifference,\n\tworldFingerprint,\n\tworldHash,\n\tworldState\n} from './determinism'\n"],"mappings":"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"}

package/dist/tiles.d.ts

@@ -0,0 +1,34 @@
+/**
+ * What the ground of a map can be painted with, named by the game: grass, road, sand. A cell holds the index of its
+ * paint: 0 for none, left to the slope and the height, and 1 and up for the game's tiles in the order it gives them
+ * (`GameModule.tiles`). The rules read and paint by name (`registry.tile('road')`); what each looks like is the
+ * view's (`GameView.ground.tiles`).
+ *
+ * A map file says the name of each index it was painted with (`GameMap.tileset`), so that a map keeps its paint when
+ * the game adds tiles or puts them in another order: it is brought in line with the game's list by name
+ *
+ * @beta
+ */
+export interface TileDef {
+    /** Shared by every game, like other ids */
+    id: string;
+    /** What the editor's palette calls it */
+    name: string;
+    /**
+     * How fast one on foot goes over it, as a multiplier of its speed: mud at 0.5, a road at 1.2. 1 when left out. What
+     * flies or sails is not slowed; the game's own `moveSpeed` rule keeps the last word (`groundSpeedAt`)
+     */
+    speed?: number;
+}
+/**
+ * Typed help for writing a tile
+ *
+ * @beta
+ */
+export declare const defineTile: (def: TileDef) => TileDef;
+/**
+ * The most tiles a game can have: a cell holds its tile in a byte, and 0 is none
+ *
+ * @beta
+ */
+export declare const MAX_TILES = 255;

package/dist/timers.d.ts

@@ -0,0 +1,146 @@
+import type { PlayerId } from './entity';
+import { type Message, type MessageRef } from './messages';
+import type { System } from './registry';
+import type { World } from './world';
+/**
+ * Something a game does after a while, or every so often: a wave coming, a spell wearing off, a line of dialog.
+ * Made with `defineTimer` and given in `GameModule.timers`, the way listeners are, so that a loaded save finds the
+ * code by id: what is waiting in the world is data, which timer and with what, never a function
+ *
+ * @beta
+ */
+export interface TimerDef<T = any> {
+    /** Shared by every game, like other ids: give it a prefix of the game's (`'td.waveComes'`) */
+    readonly id: string;
+    run(world: World, data: T, timer: TimerInfo): void;
+}
+/**
+ * Typed help: `defineTimer<{ wave: number }>('td.waveComes', (world, { wave }) => ...)`
+ *
+ * @beta
+ */
+export declare function defineTimer<T = undefined>(id: string, run: (world: World, data: T, timer: TimerInfo) => void): TimerDef<T>;
+/** A timer as it waits in the world. Plain data: it goes into a save */
+interface Waiting {
+    /** Unique in the world, for `cancel` and `left` */
+    id: number;
+    timer: string;
+    data: unknown;
+    /** The tick it goes off at */
+    at: number;
+    /** Ticks between two times, for one that repeats */
+    every?: number;
+    /** How many times it still goes off, for one that repeats a number of times. Forever when left out */
+    times?: number;
+}
+/**
+ * A timer as the debug tools show it: seconds until it goes off, and between two times
+ *
+ * @beta
+ */
+export interface WaitingTimer {
+    id: number;
+    timer: string;
+    data: unknown;
+    left: number;
+    every?: number;
+    times?: number;
+}
+/**
+ * How a timer repeats, and what it is given, for one whose handler takes something
+ *
+ * @beta
+ */
+export type EveryOptions<T> = {
+    times?: number;
+    first?: number;
+} & (T extends undefined ? {
+    data?: undefined;
+} : {
+    data: T;
+});
+/**
+ * What a timer's handler is told about the time it went off
+ *
+ * @beta
+ */
+export interface TimerInfo {
+    id: number;
+    /** How many more times it goes off after this one: 0 for the last, undefined for one that repeats forever */
+    left?: number;
+}
+/**
+ * A timer the rules show a player (`world.timers.show`): its words, and the tick it goes off at, for the screen to count
+ * down to
+ *
+ * @beta
+ */
+export interface ShownTimer {
+    id: number;
+    label: Message;
+    at: number;
+}
+/** The timers each player is shown, by the id of each and its words: kept in the world, so that a save has them */
+export declare const shownTimers: import("./components").Component<Record<number, {
+    id: number;
+    label: Message;
+}[]>, Record<number, {
+    id: number;
+    label: Message;
+}[]>>;
+/** The timers waiting in a world, kept in it so that a save has them */
+export declare const waiting: import("./components").Component<{
+    next: number;
+    list: Waiting[];
+}, {
+    next: number;
+    list: Waiting[];
+}>;
+/** The timers waiting in the state of a save, by the id of their definition: what a game must still have to load it */
+export declare const waitingTimers: (state: Record<string, unknown>) => string[];
+/**
+ * The timers of a world. Time is counted in ticks, which every machine counts the same, never with the clock:
+ * a timer goes off at the start of the tick it is due, after the players' commands and before anything else, in the
+ * order they are due and then the order they were set
+ *
+ * @beta
+ */
+export declare class Timers {
+    private readonly world;
+    private readonly defs;
+    constructor(world: World, defs: readonly TimerDef[]);
+    /** Goes off once, `seconds` from now. Returns its id, for `cancel` and `left` */
+    after<T>(seconds: number, timer: TimerDef<T>, ...data: T extends undefined ? [] : [T]): number;
+    /**
+     * Goes off every `seconds`: the first time `seconds` from now, or after `first` seconds; `times` times, or until
+     * cancelled. Returns its id
+     */
+    every<T>(seconds: number, timer: TimerDef<T>, options: EveryOptions<T>): number;
+    /** Stops a timer from going off again. Whether it was still waiting */
+    cancel(id: number): boolean;
+    /**
+     * Shows a player a timer (campaign plan CP5): its words and when it goes off, counted down on their screen (the HUD's
+     * timers) for as long as it waits. A timer that repeats is shown to each time it next goes off
+     */
+    show(player: PlayerId, id: number, options: {
+        label: MessageRef;
+    }): void;
+    /** Shows a player a timer no more */
+    hide(player: PlayerId, id: number): void;
+    /** The timers a player is shown that still wait, with the tick each goes off at next */
+    shownTo(player: PlayerId): ShownTimer[];
+    /** Seconds until the timer next goes off, or undefined when it is not waiting any more */
+    left(id: number): number | undefined;
+    /** Whether the timer is still waiting */
+    has(id: number): boolean;
+    /** What is waiting, in the order it was set: a copy, for the debug tools */
+    list(): WaitingTimer[];
+    /** Sets off what is due. The `timers` system calls it at the start of every tick */
+    update(): void;
+    private add;
+    private ticks;
+    private state;
+}
+/** Sets off the timers that are due, at the start of the tick, after the players' commands */
+export declare const timerSystem: System;
+export {};

package/dist/tomes.d.ts

@@ -0,0 +1,48 @@
+import type { StatChange } from './defs';
+import type { Entity } from './entity';
+import type { GamePack } from './packs/pack';
+import type { World } from './world';
+/**
+ * The tomes pack's id
+ *
+ * @beta
+ */
+export declare const TOMES = "core.tomes";
+/**
+ * What a unit gained for good (`gainStats`): the stats added and the parts, everything it gained added up, and how many
+ * times it gained
+ *
+ * @beta
+ */
+export interface GainedStats {
+    /** What was added to each stat */
+    stats: Record<string, number>;
+    /** The parts each stat was made bigger or smaller by */
+    percent: Record<string, number>;
+    /** How many times it gained: what tells the stats to be added up again */
+    times: number;
+}
+/**
+ * What a unit gained for good from tomes or the game's own rules (`gainStats`): saved with it
+ *
+ * @beta
+ */
+export declare const gainedStats: import("./components").Component<GainedStats, GainedStats>;
+/**
+ * Gives a unit stats for good, as a tome does: added to what it gained before, kept with it in a save, its health and
+ * mana raised with them. For the tomes pack's `tome` effect and a game's own rules (a shrine that makes a unit
+ * stronger); it works in a game with the tomes pack (`withTomes`), which adds what was gained to the stats
+ *
+ * @beta
+ */
+export declare function gainStats(world: World, entity: Entity, change: StatChange): void;
+/**
+ * Tomes, as in classic RTS games: the `tome` effect (`EffectTypes.tome`) gives what it reaches stats for good (`gain`: a
+ * point of strength with the attributes pack), a hero experience (`xp`) and levels (`levels`). A tome is an item whose
+ * ability has the effect, with a charge, used from the inventory, or as it is picked up with the runes pack
+ * (`withRunes`). What a unit gained is kept with it and in a save (`gainedStats`), and a game gives it from its own
+ * rules with `gainStats`
+ *
+ * @beta
+ */
+export declare function withTomes(): GamePack;

package/dist/trade.d.ts

@@ -0,0 +1,28 @@
+import type { PlayerId } from './entity';
+import type { World } from './world';
+/**
+ * Gives `amount` of a resource from one player to an ally (`traded`), both told. Nothing to who is not an ally, more
+ * than the giver has, or a resource the game does not have; and as the `beforeTrade` hook says: how much arrives, or not
+ *
+ * @beta
+ */
+export declare function give(world: World, from: PlayerId, to: PlayerId, resource: string, amount: number): void;
+/**
+ * Shares with an ally, or no longer: control of the player's units (`shareControl`), and what the player's team sees
+ * (`shareVision`, when the ally is of another team: a team sees as one already). Nothing for who is not an ally
+ *
+ * @beta
+ */
+export declare function shareWith(world: World, player: PlayerId, ally: PlayerId, what: {
+    vision?: boolean;
+    control?: boolean;
+}): void;
+/**
+ * Trades `amount` of one resource of a player's (`sold`) for another (`bought`) at a rate: `rate` of it for each one
+ * sold, rounded down (`exchanged`), the player told. What the `exchange` effect does (a marketplace's ability,
+ * `presetMarket`), for a game's own rules. Nothing of a resource the game does not have, of one for itself, or more
+ * than the player has. Gives back how much came
+ *
+ * @beta
+ */
+export declare function exchange(world: World, player: PlayerId, sold: string, bought: string, amount: number, rate: number): number;

package/dist/transport.d.ts

@@ -0,0 +1,76 @@
+import { type Entity } from './entity';
+import type { Vec2 } from './math';
+import type { System } from './registry';
+import type { World } from './world';
+/**
+ * What a transport carries, and whether it is near enough the land to let them out: kept for its side to see, the
+ * card's unload button reads it (see `UnitTypeDef.transport`)
+ *
+ * @beta
+ */
+export interface Cargo {
+    passengers: number[];
+    /** There is land within reach to let them out on */
+    ashore: boolean;
+}
+/** @beta */
+export declare const cargo: import("./components").Component<Cargo, Cargo>;
+/**
+ * How many more a transport has room for
+ *
+ * @beta
+ */
+export declare function roomIn(transport: Entity): number;
+/**
+ * Whether a unit can get into a transport: one of its side's that has room, and a unit that walks. What flies, what
+ * sails and what carries others do not get in
+ *
+ * @beta
+ */
+export declare function canBoard(world: World, passenger: Entity, transport: Entity): boolean;
+/**
+ * Puts a unit into a transport at once, wherever the two are. False when it cannot get in
+ *
+ * @beta
+ */
+export declare function board(world: World, passenger: Entity, transport: Entity): boolean;
+/**
+ * Lets out what a transport carries, on the land nearest it (or nearest `near`, within reach of the transport), spread
+ * around it. How many got out: none when there is no land in reach
+ *
+ * @beta
+ */
+export declare function unload(world: World, transport: Entity, near?: Vec2): number;
+/**
+ * What `board` keeps: the tick it last set out for its transport
+ *
+ * @beta
+ */
+export interface BoardState {
+    /** The tick it last set out for its transport */
+    tried?: number;
+}
+/**
+ * What `unload` keeps: whether it set its passengers down already
+ *
+ * @beta
+ */
+export interface UnloadState {
+    /** It set them down already */
+    sent?: boolean;
+}
+/**
+ * What `load` keeps: the tick it last set out for its passenger, and where it was then
+ *
+ * @beta
+ */
+export interface LoadState {
+    /** The tick it last set out for its passenger */
+    tried?: number;
+    /** Where it was when it last set out */
+    from?: Vec2;
+}
+/** Keeps each transport's word of whether it is near the land, for its card. A few times a second */
+export declare const transportSystem: System;
+/** A transport that dies takes down what it carries with it: a boat. A building that falls lets them out */
+export declare const transportSank: import("./events").ListenerDef;

package/dist/tunables.d.ts

@@ -0,0 +1,45 @@
+/**
+ * A number of a game's rules to be tuned while it plays: the seconds between waves, how much a kill pays. Read in the
+ * rules with `world.tunable(id)`, and changed while the game runs from the editor's play mode (`debug.tune`), in the
+ * world itself, so that a save and a screen over a wire have the same. Given in `GameModule.tunables`
+ *
+ * @beta
+ */
+export interface TunableDef {
+    /** Shared by every game: give it a prefix of the game's */
+    id: string;
+    /** What the tuning panel calls it */
+    name?: string;
+    default: number;
+    min: number;
+    max: number;
+    /** What the slider steps by. A hundredth of the way from min to max when left out */
+    step?: number;
+}
+/** @beta */
+export declare const defineTunable: (def: TunableDef) => TunableDef;
+/**
+ * The tunables of a game with what a file says over their defaults: the values kept from the tuning panel, in the
+ * game's `tuning.json` (`{ "td.betweenWaves": 12 }`). Code can still set any of them as it likes
+ *
+ * @beta
+ */
+export declare function withTuning(defs: readonly TunableDef[], file?: Readonly<Record<string, unknown>>): TunableDef[];
+/**
+ * A tunable changed while the game runs: for what has to be worked out again from it
+ *
+ * @beta
+ */
+export declare const tunableChanged: import("./events").EventKey<{
+    id: string;
+    value: number;
+}>;
+/**
+ * Sets a tunable while the game runs: for players allowed the debug tools
+ *
+ * @beta
+ */
+export declare const tuneCommand: import("#engine/commands").DefinedCommand<"debug.tune", {
+    id: import("./fields").Check<string>;
+    value: import("./fields").Check<number>;
+}>;

package/dist/upkeep.d.ts

@@ -0,0 +1,16 @@
+import type { PlayerId } from './entity';
+import type { World } from './world';
+/** @beta */
+export interface Upkeep {
+    /** 0 without upkeep, then counting up with the tiers of the game */
+    tier: number;
+    name: string;
+    /** Part of the gold a worker brings in that reaches the player */
+    income: number;
+}
+/**
+ * What a player's army costs them, by how much supply they use
+ *
+ * @beta
+ */
+export declare function upkeepOf(world: World, player: PlayerId): Upkeep;

package/dist/veterancy.d.ts

@@ -0,0 +1,80 @@
+import type { GamePack } from './packs/pack';
+import type { StatChange } from './defs';
+import type { Entity } from './entity';
+import type { World } from './world';
+/**
+ * A rank of veterancy: the experience it starts at, its name, and what it adds to a unit's stats (in place of the rank
+ * before's: each says all a unit of that rank has)
+ *
+ * @beta
+ */
+export interface VeterancyRank {
+    name: string;
+    xp: number;
+    stats?: StatChange;
+}
+/**
+ * What a unit has of veterancy: its experience and the rank it reached (0 for none yet)
+ *
+ * @beta
+ */
+export interface VeterancyState {
+    xp: number;
+    rank: number;
+}
+/**
+ * Ranks as many games have them: three, at 50, 150 and 300 experience, 10%, 20% and 30% more damage and health
+ *
+ * @beta
+ */
+export declare const VETERANCY_RANKS: readonly VeterancyRank[];
+/**
+ * What veterancy is made of (`withVeterancy`)
+ *
+ * @beta
+ */
+export interface VeterancyOptions {
+    /** The ranks, from the lowest: `VETERANCY_RANKS` when left out */
+    ranks?: readonly VeterancyRank[];
+    /** Who earns it: units of a player's that are not heroes and not structures, when left out */
+    earns?: (world: World, entity: Entity) => boolean;
+    /** What a kill is worth to the killer: what it is worth to heroes (`xpWorth`), when left out. 0 for nothing */
+    worth?: (world: World, dead: Entity, killer: Entity) => number;
+}
+/**
+ * What a unit has of veterancy, told to everyone (a rank shows on its plate): none for one that has earned nothing
+ *
+ * @beta
+ */
+export declare const veterancy: import("./components").Component<VeterancyState, VeterancyState>;
+/**
+ * A unit reached a rank: told to everyone, for a sound or a word on the screen
+ *
+ * @beta
+ */
+export declare const rankedUp: import("./events").EventKey<{
+    entity: number;
+    rank: number;
+    name: string;
+}>;
+/**
+ * The rank a unit has reached, as a definition, or none: of the game's ranks (`VeterancyOptions.ranks`)
+ *
+ * @beta
+ */
+export declare function rankOf(entity: Entity, ranks?: readonly VeterancyRank[]): VeterancyRank | undefined;
+/**
+ * Gives a unit experience, as a kill does: its rank goes up where it reaches the next ones' thresholds, its stats
+ * with it, and `rankedUp` is told for each. Gives back the rank it is at. For a game's own rules (a unit that trains
+ * at a camp), and what `withVeterancy` does on a kill
+ *
+ * @beta
+ */
+export declare function grantVeterancy(world: World, entity: Entity, xp: number, ranks?: readonly VeterancyRank[]): number;
+/**
+ * Veterancy for a game's units (`VeterancyOptions`): the killer of an enemy earns what it was worth, ranks come at
+ * their thresholds, each rank's stats are added (the `stats` hook). The game is the same otherwise
+ *
+ * @beta
+ */
+export declare function withVeterancy(options?: VeterancyOptions): GamePack;

package/dist/walls.d.ts

@@ -0,0 +1,86 @@
+import type { Vec2 } from './math';
+import type { GamePack } from './packs/pack';
+import type { Entity } from './entity';
+import type { World } from './world';
+/**
+ * What a piece of wall is, among its family's: its shape, by the pieces of its family beside it
+ *
+ * @beta
+ */
+export type WallShape = 'single' | 'end' | 'straight' | 'corner' | 'tee' | 'cross';
+/**
+ * A piece of wall took another shape, or turned: a piece came or went beside it
+ *
+ * @beta
+ */
+export declare const wallJoined: import("./events").EventKey<{
+    entity: number;
+    shape: WallShape;
+    facing: number;
+}>;
+/**
+ * The cells of a wall along a drag, as the genre lays one: along the longer of its two directions first, then the
+ * other, a cell's middle each (`x + 0.5`), from where it started to where it ended, each once
+ *
+ * @beta
+ */
+export declare function wallLine(from: Vec2, to: Vec2): Vec2[];
+/**
+ * Lays a wall along a drag with the player's builders: a build order for each cell of the line (`wallLine`), queued
+ * after one another (after what they were doing, with `queue`), for the first builder of theirs among the ids that can
+ * build the type. What cannot be built where it is (a unit, a tree in the way) is refused there as one built by hand is
+ *
+ * @beta
+ */
+export declare const buildLineCommand: import("#engine/commands").DefinedCommand<"buildLine", {
+    entities: import("./fields").Check<number[]>;
+    unitType: import("./fields").Check<string>;
+    from: import("./fields").Check<Vec2>;
+    to: import("./fields").Check<Vec2>;
+    queue: import("./fields").Check<boolean | undefined>;
+}>;
+/**
+ * A gate of a wall (`UnitTypeDef.wall.gate`): whether it stands open, every screen told. Open, it is in nobody's way,
+ * whoever walks; shut, it is a piece of the wall. Its owner opens and shuts it (`wallGateCommand`, `setWallGate`)
+ *
+ * @beta
+ */
+export declare const wallGate: import("./components").Component<{
+    open: boolean;
+}, {
+    open: boolean;
+}>;
+/**
+ * A gate of a wall opened or shut (`setWallGate`)
+ *
+ * @beta
+ */
+export declare const wallGateChanged: import("./events").EventKey<{
+    entity: number;
+    open: boolean;
+}>;
+/**
+ * Opens or shuts a gate of a wall, for everyone: open, what walks goes through its cell, whoever's; shut, around it.
+ * Its look is `open` or `shut`. False for what is no gate, or one still going up
+ *
+ * @beta
+ */
+export declare function setWallGate(world: World, gate: Entity, open: boolean): boolean;
+/**
+ * Its owner opens or shuts a gate of a wall (`setWallGate`), for everyone
+ *
+ * @beta
+ */
+export declare const wallGateCommand: import("#engine/commands").DefinedCommand<"wallGate", {
+    entity: import("./fields").Check<number>;
+    open: import("./fields").Check<boolean>;
+}>;
+/**
+ * Walls for a game: its pieces (types with `wall: { family }`) join with their neighbours as they are put down and
+ * taken away, and a builder lays a line of them (`buildLineCommand`). A game's pieces draw by their shape with
+ * `UnitLook.looks` (`single`, `end`, `straight`, `corner`, `tee`, `cross`); its gates (`wall.gate`) by `open` and `shut`,
+ * opened and shut by their owner (`wallGateCommand`)
+ *
+ * @beta
+ */
+export declare function withWalls(): GamePack;