@v12-engine/engine 0.0.0-stage → 0.1.1

package/dist/determinism-BCymQwiE.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"determinism-BCymQwiE.js","names":[],"sources":["../src/packs/heroes/hire.ts","../src/packs/heroes/commands.ts","../src/packs/heroes/making.ts","../src/packs/heroes/index.ts","../src/determinism.ts"],"sourcesContent":["import { unitHired } from '#engine/engineEvents'\nimport type { Entity, PlayerId } from '#engine/entity'\nimport { heroesOf } from '#engine/hero'\nimport { atShop } from '#engine/items'\nimport { engineMessage } from '#engine/messages'\nimport { shortOf, spend } from '#engine/player'\nimport type { World } from '#engine/world'\n\n/**\n * Whether someone of a player's stands at a place that hires (`UnitTypeDef.hires`) to hire there: any unit of theirs\n * close enough, as at a shop. The first one found\n *\n * @internal\n */\nexport function hirerAt(world: World, shop: Entity, player: PlayerId): Entity | undefined {\n\tfor (const entity of world.index.ownedBy(player))\n\t\tif (entity.alive && !entity.hidden && entity.def.kind === 'unit' && atShop(entity, shop)) return entity\n\treturn undefined\n}\n\n/**\n * Why a player cannot hire a unit at a place now, as the message the player is told: none of theirs there, a hero\n * they have already (a hero is hired once), what it costs. Nothing when they can\n *\n * @internal\n */\nexport function hireRefusal(world: World, shop: Entity, unit: string, player: PlayerId) {\n\tif (!shop.def.hires?.includes(unit) || !world.registry.units.has(unit)) return engineMessage('cannotDoThat')\n\tif (!shop.alive || !shop.operational || world.areEnemies(shop.owner, player)) return engineMessage('cannotDoThat')\n\tconst def = world.registry.unit(unit)\n\tif (def.hero && heroesOf(world, player).some((hero) => hero.def.id === unit)) return engineMessage('alreadyHired', { unit })\n\tif (!hirerAt(world, shop, player)) return engineMessage('unitAtShop')\n\tconst short = shortOf(world.player(player).resources, def.cost)\n\tif (short) return engineMessage('notEnough', { resource: short })\n\treturn undefined\n}\n\n/**\n * Hires a unit at a place that hires for a player: a tavern's hero, a dock's boat. Paid for, and made next to the\n * place, a boat on the water nearest it. The unit, or nothing with the player told why\n *\n * @beta\n */\nexport function hire(world: World, shop: Entity, unit: string, player: PlayerId): Entity | undefined {\n\tconst refusal = hireRefusal(world, shop, unit, player)\n\tif (refusal) {\n\t\tworld.message(player, refusal)\n\t\treturn undefined\n\t}\n\tconst def = world.registry.unit(unit)\n\tspend(world, player, def.cost, 'hire', unit)\n\tconst hired = world.spawn(unit, player, { x: shop.pos.x, z: shop.pos.z + shop.def.radius + def.radius + 0.5 })\n\tworld.events.emit(unitHired, { shop, unit: hired, player })\n\treturn hired\n}\n","/**\n * The heroes pack's commands: buying and selling at a shop, hiring, putting a point into an ability, bringing a hero\n * back at an altar. Taken by a world whose game has the pack on (`withHeroes`); a game without it refuses them as it\n * does any command it does not know. Their type is among `Command`s, as the pack adds it (`Commands`)\n */\nimport { defineCommand, known, leastBusy, owned, producers } from '#engine/commands'\nimport { id, index, optional, string } from '#engine/fields'\nimport { learn } from '#engine/hero'\nimport { buy, sell } from '#engine/items'\nimport { enqueueRevive } from '#engine/systems/production'\nimport { hire } from './hire'\n\n/**\n * Buys from a shop, for the hero that is named, or else the one of the player that stands closest to it\n *\n * @internal\n */\nexport const buyCommand = defineCommand('buy', { shop: id, item: string, hero: optional(id) }, (world, player, command) => {\n\t// shops sell to whoever comes by, not only to their owner\n\tconst shop = known(world, player, command.shop)\n\tconst [buyer] = command.hero === undefined ? [] : owned(world, player, [command.hero])\n\tif (shop && !world.areEnemies(shop.owner, player)) buy(world, shop, command.item, player, buyer)\n})\n\n/**\n * Hires a unit at a place that hires, a tavern or a dock: someone of the player's has to be there\n *\n * @internal\n */\nexport const hireCommand = defineCommand('hire', { shop: id, unit: string }, (world, player, command) => {\n\tconst shop = known(world, player, command.shop)\n\tif (shop) hire(world, shop, command.unit, player)\n})\n\n/**\n * Gives something a hero carries back at a shop nearby, for a part of its price\n *\n * @internal\n */\nexport const sellCommand = defineCommand('sell', { entity: id, item: index }, (world, player, command) => {\n\tconst [seller] = owned(world, player, [command.entity])\n\tif (seller) sell(world, seller, command.item)\n})\n\n/**\n * Puts a point a hero has to spend into an ability\n *\n * @internal\n */\nexport const learnCommand = defineCommand('learn', { entity: id, ability: string }, (world, player, command) => {\n\tconst [hero] = owned(world, player, [command.entity])\n\tif (hero) learn(world, hero, command.ability)\n})\n\n/** @internal */\nexport const reviveCommand = defineCommand('revive', { ...producers, hero: id }, (world, player, command) => {\n\tconst building = leastBusy(world, player, command, (entity) => !!entity.def.revives)\n\tif (building) enqueueRevive(world, building, command.hero)\n})\n\n/**\n * The commands of the heroes pack (`withHeroes`): buying, hiring, selling, learning, bringing a hero back. A game\n * without the pack refuses them as it does any command it does not know\n *\n * @internal\n */\nexport const heroCommands = [buyCommand, hireCommand, sellCommand, learnCommand, reviveCommand] as const\n\ndeclare module '#engine/commands' {\n\tinterface Commands {\n\t\theroes: (typeof heroCommands)[number]\n\t}\n}\n","/**\n * What the heroes pack does as heroes are made and as things die: a hero of a hero's type made one, and the\n * experience of a kill shared out (the pack's `made` and `death` handlers)\n */\nimport type { Entity } from '#engine/entity'\nimport { grantXp, heroOf, heroState, maxLevelOf, xpWorth } from '#engine/hero'\nimport { distSq } from '#engine/math'\nimport type { World } from '#engine/world'\n\n/**\n * Makes a unit just made a hero, as its type says (`UnitTypeDef.hero`): level 1, a point to spend, the abilities it can\n * learn (none learned) and the spells it starts with, those it has not got already. What `World.spawn` does for a\n * hero's type, and `morph` for what becomes one\n *\n * @beta\n */\nexport function makeHero(world: World, entity: Entity): void {\n\tconst def = entity.def.hero\n\tif (!def) return\n\tentity.set(heroState, { level: 1, xp: 0, points: 1 })\n\t// what it has already (a unit turned into a hero, `morph`) as it was\n\tconst add = (id: string, level: number) => {\n\t\tif (!entity.abilities.some((state) => state.id === id))\n\t\t\tentity.addAbility({ id: world.registry.ability(id).id, level, cooldown: 0, autocast: false })\n\t}\n\tfor (const id of def.learns) add(id, 0)\n\tfor (const id of def.spells ?? []) add(id, 1)\n}\n\n/** Shares the experience for a kill between the heroes of the killer's side that were around */\nexport function awardKill(world: World, dead: Entity, killer: Entity | undefined): void {\n\tif (!killer || !world.areEnemies(killer.owner, dead.owner)) return\n\tconst worth = xpWorth(world, dead)\n\tif (worth <= 0) return\n\tconst heroes: Entity[] = []\n\tconst { xpRange } = world.rules.heroes\n\tfor (const player of world.players.values()) {\n\t\tif (!world.areAllies(player.id, killer.owner)) continue\n\t\tfor (const entity of world.index.with(heroState, player.id)) {\n\t\t\tif (!entity.alive || heroOf(entity)!.level >= maxLevelOf(world, entity)) continue\n\t\t\tif (distSq(entity.pos, dead.pos) <= xpRange * xpRange) heroes.push(entity)\n\t\t}\n\t}\n\tfor (const hero of heroes) grantXp(world, hero, worth / heroes.length, dead)\n}\n","import type { CommandDef } from '#engine/commands'\nimport { heroCommands } from './commands'\nimport { campHooks, campRespawnSystem } from '#engine/camps'\nimport { defineHook, type HookDef } from '#engine/hooks'\nimport { defaultHeroRules, HEROES, type HeroesPack, type HeroRules, heroOf, heroState } from '#engine/hero'\nimport { awardKill, makeHero } from './making'\nimport { shopStock } from '#engine/items'\nimport { corpseSystem, worthless } from '#engine/summons'\nimport type { System } from '#engine/registry'\nimport type { StatPart } from '#engine/stats'\nimport type { Entity } from '#engine/entity'\nimport type { World } from '#engine/world'\n\n/** A shop's wares, each as many as it stocks; what it stocked already as it was, where it sells it still */\nfunction stockShop(world: World, entity: Entity): void {\n\tconst sells = entity.def.sells ?? []\n\tconst had = entity.get(shopStock)\n\tif (!sells.length) {\n\t\tif (had) entity.remove(shopStock)\n\t\treturn\n\t}\n\tentity.set(\n\t\tshopStock,\n\t\tsells.map((item) => {\n\t\t\tconst kept = had?.find((stock) => stock.item === item)\n\t\t\tif (kept) return kept\n\t\t\tconst stock = world.registry.item(item).stock\n\t\t\treturn { item, count: stock?.max ?? 1, restock: stock?.restock ?? 60 }\n\t\t})\n\t)\n}\n\n/** What the pack does as things are made, change type, die and fall: heroes, their experience, shops' wares */\nconst heroHooks: HookDef[] = [\n\tdefineHook({\n\t\thook: 'made',\n\t\tid: 'hero',\n\t\trun(world, entity) {\n\t\t\t// a hero of a hero's type: level 1, a point to spend, what it learns\n\t\t\tif (entity.def.hero) makeHero(world, entity)\n\t\t\tstockShop(world, entity)\n\t\t}\n\t}),\n\tdefineHook({\n\t\thook: 'morphed',\n\t\tid: 'hero',\n\t\trun(world, { entity }) {\n\t\t\t// what became a hero's type is a hero from level 1; a hero that stays one keeps its level and what it learned\n\t\t\tif (entity.def.hero && !entity.has(heroState)) makeHero(world, entity)\n\t\t\t// what became a shop stocks its wares; one that sells no more has none\n\t\t\tif (entity.def.sells?.length || entity.has(shopStock)) stockShop(world, entity)\n\t\t}\n\t}),\n\tdefineHook({\n\t\thook: 'death',\n\t\tid: 'experience',\n\t\trun(world, { entity, killer }) {\n\t\t\t// an illusion gains its killer nothing\n\t\t\tif (worthless(entity)) return\n\t\t\tawardKill(world, entity, killer)\n\t\t}\n\t}),\n\tdefineHook({\n\t\thook: 'fallenHero',\n\t\tid: 'heroesStay',\n\t\trun(_world, event) {\n\t\t\t// a fallen hero waits out of the world to be brought back: at an altar, by its own time (`withRespawn`)\n\t\t\tif (event.entity.has(heroState)) event.stays = true\n\t\t}\n\t}),\n\t...campHooks\n]\n\n/**\n * A hero's stats grow with its level, as its type says (`UnitTypeDef.hero.growth`): stamped with the level past the\n * first, so that a level set however it is set is added up again\n */\nconst heroGrowth: StatPart = {\n\tid: 'heroGrowth',\n\tstamp(entity) {\n\t\tif (!entity.def.hero) return 0\n\t\tconst level = heroOf(entity)?.level ?? 1\n\t\treturn level > 1 ? level : 0\n\t},\n\tadd(_world, entity, sum) {\n\t\tconst growth = entity.def.hero?.growth\n\t\tconst hero = growth && heroOf(entity)\n\t\tif (hero && hero.level > 1) sum.add(growth, hero.level - 1)\n\t}\n}\n\n/** Camps come back as the engine's own did: in the clean-up, before the corpses go */\nconst campsComeBack: System = { ...campRespawnSystem, before: [corpseSystem.name] }\n\n/**\n * The heroes pack: what makes a game a classic hero RTS, opted into (`GameModule.packs: [withHeroes()]`). Heroes, with\n * their experience, levels, points and abilities to learn, brought back at an altar (`revive`); creeps' camps that guard\n * their ground, sleep at night and come back (`Camp.respawn`); shops that sell (`buy`, `sell`) and places that hire\n * (`hire`). `rules` change its numbers (`HeroRules`: how many heroes, the experience a level takes), the classic RTS numbers for\n * those left out. A game without it pays nothing for any of it: no hero is made of a hero's type, no command of these\n * is taken, no camp is looked at\n *\n * @beta\n */\nexport function withHeroes(rules: Partial<HeroRules> = {}): HeroesPack {\n\tfor (const key of Object.keys(rules)) if (!(key in defaultHeroRules)) throw new Error(`\"${key}\" is not a rule of the heroes pack`)\n\treturn {\n\t\tid: HEROES,\n\t\toptions: rules,\n\t\trules: () => ({ heroes: rules }),\n\t\tcommands: [...heroCommands] as unknown as CommandDef[],\n\t\tsystems: [campsComeBack],\n\t\thooks: heroHooks,\n\t\tstatParts: [heroGrowth]\n\t}\n}\n","/**\n * Whether a game comes out the same (determinism plan D1): the simulation's state as data and as a hash, and a check\n * that runs a world twice, and on from a save, and says the first tick and the first thing they differ at. What a\n * replay of commands, a save that goes on exactly and a game the same in every browser stand on\n */\nimport { type GameModule, loadWorld } from './game'\nimport { decodeSave, encodeSave, saveWorld, type WorldSave } from './save'\nimport type { Registry } from './registry'\nimport { teamMemory } from './session/memory'\nimport type { World } from './world'\nimport { fighting } from './entity'\nimport { hashText } from './math'\n\n/**\n * The simulation's state as plain data: its save, which holds all of it, but what each team's screens remember of the\n * map, which is the watchers' (`teamMemory`)\n *\n * @beta\n */\nexport function worldState(world: World): WorldSave {\n\treturn decided(saveWorld(world, { reseat: false }), world.registry)\n}\n\n/**\n * A save as what decides the game: without what each team's screens remember of the map (`teamMemory`: kept in the\n * world for who comes back, written by whoever watches it, and read by nothing that decides), and, with the rules, the\n * components nobody would have made had nobody asked for them (`unasked`)\n */\nfunction decided(save: WorldSave, registry?: Registry): WorldSave {\n\tconst { [teamMemory.id]: _memory, ...state } = save.state\n\tconst kept = (components: Record<string, unknown>) => (registry ? unasked(registry, components) : components)\n\treturn {\n\t\t...save,\n\t\tstate: kept(state),\n\t\tplayers: save.players.map((player) => ({ ...player, state: kept(player.state) })),\n\t\tentities: save.entities.map((entity) =>\n\t\t\tentity.components ? { ...entity, components: kept(entity.components as Record<string, unknown>) } : entity\n\t\t)\n\t}\n}\n\n/**\n * Where two saves of a game first differ, as `checkDeterminism` looks (what decides first: the tick, the random state,\n * the players, the entities): the path to it (`entities[id 11].pos.x`) and what each holds there, or nothing when they\n * are the same. What the screens remember of the map, and the hash of the rules they were made with, are left out;\n * with the game's `registry`, so are components that hold what they are made with (a screen asking for one makes it).\n * What a replay that came apart says at its checkpoints (`runReplay`), and `v12 save diff`\n *\n * @beta\n */\nexport function saveDifference(a: WorldSave, b: WorldSave, registry?: Registry): Difference | undefined {\n\tconst ordered = (save: WorldSave) => {\n\t\tconst { hash: _rules, ...state } = decided(save, registry)\n\t\treturn { ...Object.fromEntries(FIRST.map((key) => [key, (state as Partial<Compared>)[key]])), ...state }\n\t}\n\treturn firstDifference(ordered(a), ordered(b))\n}\n\n/**\n * Components as they would be had nobody asked for one that was not there: one that holds what its component makes\n * when asked for (its `default`) is left out. Asking makes one, and a watcher's screen asks for what it shows (a\n * player's objectives), so a world watched and the same world unwatched differ in that alone\n */\nfunction unasked(registry: Registry, components: Record<string, unknown>): Record<string, unknown> {\n\tconst kept: Record<string, unknown> = {}\n\tfor (const [id, value] of Object.entries(components)) {\n\t\tconst made = registry.component(id)?.default?.()\n\t\tif (made !== undefined && JSON.stringify(made) === JSON.stringify(value)) continue\n\t\tkept[id] = value\n\t}\n\treturn kept\n}\n\n/**\n * The simulation's state as a hash: two worlds with the same hash are, to all that is saved of them, the same. Fourteen\n * hex digits (cyrb53, of the save as JSON, but the hash of the rules, which another build of the same code writes\n * otherwise): enough to tell drift, not to stand against someone forging a state\n *\n * @beta\n */\nexport const worldHash = (world: World): string => {\n\t// the rules' own hash names the code they were built from, which another build of the same game writes otherwise\n\tconst { hash: _rules, ...state } = worldState(world)\n\treturn hashText(canonical(state))\n}\n\n/**\n * JSON with the keys of every object in order: the same state as text however it was put together (a component a\n * watcher made early comes first in its object, and later where nobody watched)\n */\nfunction canonical(value: unknown): string {\n\treturn JSON.stringify(value, (_key, each: unknown) => {\n\t\tif (!each || typeof each !== 'object' || Array.isArray(each)) return each\n\t\tconst sorted: Record<string, unknown> = {}\n\t\tfor (const key of Object.keys(each).sort()) sorted[key] = (each as Record<string, unknown>)[key]\n\t\treturn sorted\n\t})\n}\n\n/**\n * A quick hash of what a game that came apart differs in first: the tick, the random state, each player's resources,\n * upgrades and supply, and each entity's id, type, owner, place, facing, health, mana, whether it lives, its orders (how\n * many, and the first's kind and target), its buffs (which, and the time left) and its attack's cooldown and swing. Read\n * off the world as it is, with no save: 0.4 ms at 1000 units a side, where `worldHash` takes 66. What a\n * replay of commands keeps every few seconds and checks as it plays (`recordCommands`), and what `checkDeterminism`\n * compares every tick, for the tick a game came apart at; what it leaves out (components, areas, the fog) the whole\n * state, compared every so often, has\n *\n * @beta\n */\nexport function worldFingerprint(world: World): string {\n\tconst values: number[] = [world.tick, world.rng.save()]\n\tfor (const player of world.players.values()) {\n\t\tvalues.push(player.id, player.supplyUsed, player.supplyCap)\n\t\tfor (const key of Object.keys(player.resources).sort()) values.push(player.resources[key] ?? 0)\n\t\tfor (const [upgrade, level] of player.upgrades) values.push(wordOf(upgrade), level)\n\t}\n\tfor (const entity of world.entities.values()) {\n\t\tvalues.push(\n\t\t\tentity.id,\n\t\t\twordOf(entity.def.id),\n\t\t\tentity.owner,\n\t\t\tentity.pos.x,\n\t\t\tentity.pos.z,\n\t\t\tentity.facing,\n\t\t\tentity.hp,\n\t\t\tentity.mana,\n\t\t\tentity.alive ? 1 : 0\n\t\t)\n\t\tconst order = entity.orders[0]\n\t\tvalues.push(entity.orders.length, order ? wordOf(order.type) : 0, order?.init.target ?? 0)\n\t\tvalues.push(entity.buffs.length)\n\t\tfor (const buff of entity.buffs) values.push(wordOf(buff.id), buff.remaining)\n\t\tif (entity.get(fighting)) values.push(entity.get(fighting)!.cooldown, entity.get(fighting)!.swing)\n\t}\n\treturn hashWords(new Uint32Array(Float64Array.from(values).buffer))\n}\n\n/** A short text as a number, for the fingerprint: FNV-1a of its characters */\nfunction wordOf(text: string): number {\n\tlet h = 0x811c9dc5\n\tfor (let i = 0; i < text.length; i++) h = Math.imul(h ^ text.charCodeAt(i), 16777619)\n\treturn h >>> 0\n}\n\n/** cyrb53 of 32-bit words: the bits of numbers, hashed as they are */\nfunction hashWords(words: Uint32Array): string {\n\tlet h1 = 0xdeadbeef\n\tlet h2 = 0x41c6ce57\n\tfor (const word of words) {\n\t\th1 = Math.imul(h1 ^ word, 2654435761)\n\t\th2 = Math.imul(h2 ^ word, 1597334677)\n\t}\n\th1 = Math.imul(h1 ^ (h1 >>> 16), 2246822507) ^ Math.imul(h2 ^ (h2 >>> 13), 3266489909)\n\th2 = Math.imul(h2 ^ (h2 >>> 16), 2246822507) ^ Math.imul(h1 ^ (h1 >>> 13), 3266489909)\n\treturn (4294967296 * (2097151 & h2) + (h1 >>> 0)).toString(16).padStart(14, '0')\n}\n\n/**\n * Where two states first differ: the path to it (`entities[id 11].pos.x`) and what each holds there. Nothing when they\n * are the same. Lists of things with an `id` are named by it, the rest by their place\n *\n * @beta\n */\nexport function firstDifference(a: unknown, b: unknown, path = ''): Difference | undefined {\n\tif (Object.is(a, b)) return undefined\n\tif (typeof a !== 'object' || typeof b !== 'object' || a === null || b === null || Array.isArray(a) !== Array.isArray(b)) return { path, a, b }\n\tif (Array.isArray(a) && Array.isArray(b)) {\n\t\tfor (let i = 0; i < Math.max(a.length, b.length); i++) {\n\t\t\tconst each = a[i] ?? b[i]\n\t\t\tconst named = each && typeof each === 'object' && 'id' in each ? `[id ${String((each as { id: unknown }).id)}]` : `[${i}]`\n\t\t\tconst found = firstDifference(a[i], b[i], `${path}${named}`)\n\t\t\tif (found) return found\n\t\t}\n\t\treturn undefined\n\t}\n\tconst keys = new Set([...Object.keys(a), ...Object.keys(b)])\n\tfor (const key of keys) {\n\t\tconst found = firstDifference((a as Record<string, unknown>)[key], (b as Record<string, unknown>)[key], path ? `${path}.${key}` : key)\n\t\tif (found) return found\n\t}\n\treturn undefined\n}\n\n/**\n * Where two states differ (`firstDifference`)\n *\n * @beta\n */\nexport interface Difference {\n\t/** The path to it in the state: `entities[id 11].pos.x` */\n\tpath: string\n\t/** What the first holds there */\n\ta: unknown\n\t/** What the second holds there */\n\tb: unknown\n}\n\n/**\n * Where two runs of a game came apart: the first tick they were looked at and differed, and what differed first\n *\n * @beta\n */\nexport interface Apart extends Difference {\n\t/** The tick they were looked at and differed */\n\ttick: number\n}\n\n/**\n * How a game is checked for coming out the same (`checkDeterminism`)\n *\n * @beta\n */\nexport interface DeterminismOptions {\n\t/** How many ticks each world runs */\n\tticks: number\n\t/**\n\t * How often their whole state is compared, in ticks: every 30 when left out. Their fingerprints\n\t * (`worldFingerprint`) are compared every tick, and the whole state at once where those differ, so that the tick\n\t * said is the one they came apart at\n\t */\n\tevery?: number\n\t/**\n\t * A tick to save a third world at, and load a fourth from that save (`loadWorld`, with `game`): the game saved and\n\t * the game loaded are run on side by side and compared. Not done when left out\n\t */\n\tfrom?: number\n\t/** The game the save is loaded with, for `from` */\n\tgame?: GameModule\n}\n\n/**\n * What the check found: for each run, where it came apart from the first, or `null` for the same to the last tick\n *\n * @beta\n */\nexport interface DeterminismReport {\n\t/** A second world made the same way and run the same */\n\ttwice: Apart | null\n\t/** A world loaded from a save taken at `from`, beside the world the save was taken of: none when `from` was not said */\n\tfromSave?: Apart | null\n}\n\n/**\n * Makes a world twice with `make` (the same seed, the same commands given in it, as a replay would) and runs them side\n * by side, comparing their fingerprints every tick and their states (and the order each player's entities are filed\n * in) every `every` ticks; with `from`, a third is saved at that tick and a fourth loaded\n * from the save, and the two run on side by side. Says, for each, the first tick and thing it differs at, or that it does not. A test of a game's\n * own systems: one that reads `Math.random`, the clock, or the order of something unordered is found here\n *\n *     const report = await checkDeterminism(() => makeMyGame(1), { ticks: 1800, from: 300, game: rules })\n *     expect(report).toEqual({ twice: null, fromSave: null })\n *\n * @beta\n */\nexport async function checkDeterminism(make: () => World | Promise<World>, options: DeterminismOptions): Promise<DeterminismReport> {\n\tconst { ticks, every = 30, from } = options\n\tif (from !== undefined && !options.game) throw new Error('checkDeterminism: a check from a save needs the game to load it with (game)')\n\tconst first = await make()\n\tconst second = await make()\n\t// the game that is saved at `from` and goes on, and the game loaded from that save beside it\n\tconst saved = from === undefined ? undefined : await make()\n\tlet loaded: World | undefined\n\tconst report: DeterminismReport = { twice: null, ...(from !== undefined && { fromSave: null }) }\n\ttry {\n\t\tfor (let tick = 1; tick <= ticks; tick++) {\n\t\t\tfirst.step()\n\t\t\tif (!report.twice) second.step()\n\t\t\tif (saved && !report.fromSave) {\n\t\t\t\tsaved.step()\n\t\t\t\tloaded?.step()\n\t\t\t\tif (saved.tick === from) {\n\t\t\t\t\t// as a file keeps it (`encodeSave`): what a save cannot hold is lost here as it would be there\n\t\t\t\t\tloaded = await loadWorld(decodeSave(encodeSave(saveWorld(saved))), { game: options.game! })\n\t\t\t\t}\n\t\t\t}\n\t\t\t// the fingerprint every tick, for the tick they came apart at; the whole state every `every`, and at once where\n\t\t\t// the fingerprints differ, for what it is\n\t\t\tconst whole = tick % every === 0\n\t\t\tif (!report.twice && (whole || worldFingerprint(first) !== worldFingerprint(second)))\n\t\t\t\treport.twice = apartAt(first.tick, compared(first), compared(second))\n\t\t\tconst going = loaded && !report.fromSave && saved!.tick > from!\n\t\t\tif (going && (whole || worldFingerprint(saved!) !== worldFingerprint(loaded!)))\n\t\t\t\treport.fromSave = apartAt(saved!.tick, compared(saved!), compared(loaded!))\n\t\t\tif (report.twice && (from === undefined || report.fromSave)) break\n\t\t}\n\t} finally {\n\t\tfirst.dispose()\n\t\tsecond.dispose()\n\t\tsaved?.dispose()\n\t\tloaded?.dispose()\n\t}\n\treturn report\n}\n\n/**\n * What is compared of a world: its state (`worldState`), and the order its index gives each player's entities in\n * (`world.index.ownedBy`), which a save does not hold and which decides what is picked first among equals (the closest\n * drop-off, a shopper, who shares the experience): a world loaded from a save has to give them in the same order\n */\ntype Compared = WorldSave & { owned: Record<number, number[]> }\n\nconst compared = (world: World): Compared => ({\n\t...worldState(world),\n\towned: Object.fromEntries([...world.players.keys()].map((player) => [player, [...world.index.ownedBy(player)].map((entity) => entity.id)]))\n})\n\n/**\n * What is looked at first: what is decided (the random state, the players, the entities, the order they are filed in)\n * before what follows from it (the fog, which units see), so that what is said is where it began\n */\nconst FIRST: (keyof Compared)[] = ['tick', 'rng', 'players', 'entities', 'owned', 'actors']\n\nconst apartAt = (tick: number, a: Compared, b: Compared): Apart | null => {\n\tconst ordered = (state: Compared) => ({ ...Object.fromEntries(FIRST.map((key) => [key, state[key]])), ...state })\n\tconst found = firstDifference(ordered(a), ordered(b))\n\treturn found ? { tick, ...found } : null\n}\n"],"mappings":"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"}

package/dist/determinism.d.ts

@@ -0,0 +1,121 @@
+/**
+ * Whether a game comes out the same (determinism plan D1): the simulation's state as data and as a hash, and a check
+ * that runs a world twice, and on from a save, and says the first tick and the first thing they differ at. What a
+ * replay of commands, a save that goes on exactly and a game the same in every browser stand on
+ */
+import { type GameModule } from './game';
+import { type WorldSave } from './save';
+import type { Registry } from './registry';
+import type { World } from './world';
+/**
+ * The simulation's state as plain data: its save, which holds all of it, but what each team's screens remember of the
+ * map, which is the watchers' (`teamMemory`)
+ *
+ * @beta
+ */
+export declare function worldState(world: World): WorldSave;
+/**
+ * Where two saves of a game first differ, as `checkDeterminism` looks (what decides first: the tick, the random state,
+ * the players, the entities): the path to it (`entities[id 11].pos.x`) and what each holds there, or nothing when they
+ * are the same. What the screens remember of the map, and the hash of the rules they were made with, are left out;
+ * with the game's `registry`, so are components that hold what they are made with (a screen asking for one makes it).
+ * What a replay that came apart says at its checkpoints (`runReplay`), and `v12 save diff`
+ *
+ * @beta
+ */
+export declare function saveDifference(a: WorldSave, b: WorldSave, registry?: Registry): Difference | undefined;
+/**
+ * The simulation's state as a hash: two worlds with the same hash are, to all that is saved of them, the same. Fourteen
+ * hex digits (cyrb53, of the save as JSON, but the hash of the rules, which another build of the same code writes
+ * otherwise): enough to tell drift, not to stand against someone forging a state
+ *
+ * @beta
+ */
+export declare const worldHash: (world: World) => string;
+/**
+ * A quick hash of what a game that came apart differs in first: the tick, the random state, each player's resources,
+ * upgrades and supply, and each entity's id, type, owner, place, facing, health, mana, whether it lives, its orders (how
+ * many, and the first's kind and target), its buffs (which, and the time left) and its attack's cooldown and swing. Read
+ * off the world as it is, with no save: 0.4 ms at 1000 units a side, where `worldHash` takes 66. What a
+ * replay of commands keeps every few seconds and checks as it plays (`recordCommands`), and what `checkDeterminism`
+ * compares every tick, for the tick a game came apart at; what it leaves out (components, areas, the fog) the whole
+ * state, compared every so often, has
+ *
+ * @beta
+ */
+export declare function worldFingerprint(world: World): string;
+/**
+ * Where two states first differ: the path to it (`entities[id 11].pos.x`) and what each holds there. Nothing when they
+ * are the same. Lists of things with an `id` are named by it, the rest by their place
+ *
+ * @beta
+ */
+export declare function firstDifference(a: unknown, b: unknown, path?: string): Difference | undefined;
+/**
+ * Where two states differ (`firstDifference`)
+ *
+ * @beta
+ */
+export interface Difference {
+    /** The path to it in the state: `entities[id 11].pos.x` */
+    path: string;
+    /** What the first holds there */
+    a: unknown;
+    /** What the second holds there */
+    b: unknown;
+}
+/**
+ * Where two runs of a game came apart: the first tick they were looked at and differed, and what differed first
+ *
+ * @beta
+ */
+export interface Apart extends Difference {
+    /** The tick they were looked at and differed */
+    tick: number;
+}
+/**
+ * How a game is checked for coming out the same (`checkDeterminism`)
+ *
+ * @beta
+ */
+export interface DeterminismOptions {
+    /** How many ticks each world runs */
+    ticks: number;
+    /**
+     * How often their whole state is compared, in ticks: every 30 when left out. Their fingerprints
+     * (`worldFingerprint`) are compared every tick, and the whole state at once where those differ, so that the tick
+     * said is the one they came apart at
+     */
+    every?: number;
+    /**
+     * A tick to save a third world at, and load a fourth from that save (`loadWorld`, with `game`): the game saved and
+     * the game loaded are run on side by side and compared. Not done when left out
+     */
+    from?: number;
+    /** The game the save is loaded with, for `from` */
+    game?: GameModule;
+}
+/**
+ * What the check found: for each run, where it came apart from the first, or `null` for the same to the last tick
+ *
+ * @beta
+ */
+export interface DeterminismReport {
+    /** A second world made the same way and run the same */
+    twice: Apart | null;
+    /** A world loaded from a save taken at `from`, beside the world the save was taken of: none when `from` was not said */
+    fromSave?: Apart | null;
+}
+/**
+ * Makes a world twice with `make` (the same seed, the same commands given in it, as a replay would) and runs them side
+ * by side, comparing their fingerprints every tick and their states (and the order each player's entities are filed
+ * in) every `every` ticks; with `from`, a third is saved at that tick and a fourth loaded
+ * from the save, and the two run on side by side. Says, for each, the first tick and thing it differs at, or that it does not. A test of a game's
+ * own systems: one that reads `Math.random`, the clock, or the order of something unordered is found here
+ *
+ *     const report = await checkDeterminism(() => makeMyGame(1), { ticks: 1800, from: 300, game: rules })
+ *     expect(report).toEqual({ twice: null, fromSave: null })
+ *
+ * @beta
+ */
+export declare function checkDeterminism(make: () => World | Promise<World>, options: DeterminismOptions): Promise<DeterminismReport>;

package/dist/dialog.d.ts

@@ -0,0 +1,94 @@
+import type { PlayerId } from './entity';
+import { type Message, type MessageRef } from './messages';
+import { type Step } from './sequences';
+import type { World } from './world';
+/**
+ * Something someone says: a commander between waves, a hero in a cutscene. The rules say a line is said, so that
+ * every player hears it at the same moment and a save knows where a conversation was; the view shows it (a box with
+ * a portrait, subtitles) and plays its voice. Who the speaker is on the screen, their name and portrait, is the
+ * view's (`GameView.cinematics.speakers`)
+ *
+ * @beta
+ */
+export interface LineDef {
+    /** Who says it, by an id of the game's (`'td.commander'`) */
+    speaker: string;
+    /** What is said, in the words of the game: a message key, with params */
+    text: MessageRef;
+    /** How long it stays, in seconds. `LINE_SECONDS` when left out: the rules know the key of the words, not how long they are */
+    seconds?: number;
+}
+/**
+ * Whom a line is said to: a player, some, or everyone
+ *
+ * @beta
+ */
+export type Audience = PlayerId | PlayerId[] | 'everyone';
+/**
+ * A line as it is said: what the engine's `lineSaid` event carries, and what goes to the screen
+ *
+ * @beta
+ */
+export interface SaidLine {
+    id: number;
+    speaker: string;
+    text: Message;
+    seconds: number;
+    /** Who hears it. Everyone when left out */
+    to?: PlayerId[];
+}
+/**
+ * The line each player hears now, the sequence waiting on it, and the tick it is over at, for skipping. Kept in the
+ * world: a save has it
+ */
+export declare const current: import("./components").Component<{
+    next: number;
+    lines: Record<number, {
+        line: number;
+        run?: number;
+        to?: PlayerId[];
+        until?: number;
+    }>;
+}, {
+    next: number;
+    lines: Record<number, {
+        line: number;
+        run?: number;
+        to?: PlayerId[];
+        until?: number;
+    }>;
+}>;
+/**
+ * What is said in a world
+ *
+ * @beta
+ */
+export declare class Dialog {
+    private readonly world;
+    constructor(world: World);
+    /**
+     * Says a line, now. On its own it waits for nothing: in a sequence, `talk` says lines one after the other, each
+     * for as long as it lasts. `run` is the sequence that waits on it, which skipping the line hurries along
+     */
+    say(to: Audience, line: LineDef, run?: number): SaidLine;
+    /**
+     * A player asks to skip the line they hear: it ends, and a conversation goes on to its next line. Only a line
+     * said to them alone can be: what others hear too goes on for them
+     */
+    skip(player: PlayerId): void;
+    /** The players a line said to everyone is heard by: everyone who plays */
+    private listeners;
+}
+/**
+ * The steps of a conversation, for a sequence: each line is said and stays for as long as it lasts, then the next.
+ * Skipping a line (the `skipLine` command) goes on to the next at once:
+ *
+ *     defineSequence('td.beforeTheBoss', [...talk(DEFENDER, [{ speaker: 'td.commander', text: 'bossComing' }, ...])])
+ *
+ * @beta
+ */
+export declare function talk<D = undefined>(to: Audience, lines: LineDef[]): Step<D>[];
+/** A line said, to whom it is for: everyone when it names nobody */
+export declare const toldLine: import("./replication").ReplicatedEvent;
+/** A line over, to whom it was for */
+export declare const toldLineEnded: import("./replication").ReplicatedEvent;

package/dist/effectRefs.d.ts

@@ -0,0 +1,16 @@
+/**
+ * An effect of an ability as a save keeps it (`EffectRef`): where it is in the definition of the ability, found again
+ * as a save is loaded, or a copy of one made up on the spot. What saves of missiles, zones and dashes are made with
+ */
+import type { EffectDef } from './defs';
+import type { Registry } from './registry';
+/** An effect of an ability: where it is in the definition of the ability, or a copy for one made up on the spot */
+export type EffectRef = {
+    path: (string | number)[];
+} | {
+    value: unknown;
+};
+/** Where an effect is in the definition of an ability, found by identity; a copy of it when it is not in there */
+export declare function effectRef(registry: Registry, ability: string, effect: EffectDef | EffectDef[]): EffectRef;
+/** The effect a save kept (`effectRef`): found in the ability again, or the copy */
+export declare function resolveEffect(registry: Registry, ability: string, ref: EffectRef): never;

package/dist/effects.d.ts

@@ -0,0 +1,80 @@
+import type { Audience } from './dialog';
+import type { Entity, PlayerId } from './entity';
+import type { Vec2 } from './math';
+import type { World } from './world';
+/**
+ * An effect the rules play on the screens, as the engine's `effect` event carries it (`world.effect`)
+ *
+ * @beta
+ */
+export interface EffectCue {
+    /** The rules' handle on it, for `world.stopEffect` */
+    id: number;
+    /** Which of the view's effects, by name (`GameView.fx.defs`) */
+    effect: string;
+    /** Where: a place, at a height or on the ground */
+    x?: number;
+    y?: number;
+    z?: number;
+    /** Or on an entity, by its id: it follows it on the screen, at a point of its model */
+    on?: number;
+    point?: string;
+    /** Its knobs, over the effect's own: plain data, as it goes to every screen */
+    params?: Record<string, unknown>;
+    /** What its random parts go by: the same on every screen */
+    seed: number;
+    /** Who sees it: everyone who sees the place when left out */
+    to?: PlayerId[];
+    /** Seen over the fog of war, by whom it is for: what is there to be noticed */
+    overFog?: boolean;
+}
+/**
+ * How the rules play an effect (`world.effect`)
+ *
+ * @beta
+ */
+export interface EffectOptions {
+    /** A place: on the ground (`{ x, z }`) or at a height (`{ x, y, z }`) */
+    at?: Vec2 | {
+        x: number;
+        y: number;
+        z: number;
+    };
+    /** Or an entity: on the screen it follows it, and ends with it */
+    on?: Entity | number;
+    /** A point of the entity's model (`ModelDef.points`) */
+    point?: string;
+    /** Its knobs, over the effect's own (`EffectDef.params`): plain data */
+    params?: Record<string, unknown>;
+    /** What its random parts go by: one made from the tick when left out, the same on every screen all the same */
+    seed?: number;
+    /** Who sees it: a player, some, or everyone who sees the place (when left out) */
+    to?: Audience;
+    /** Seen over the fog of war by whom it is for, as what is there to be noticed. No when left out */
+    overFog?: boolean;
+}
+/**
+ * How many effects a world played, for their ids and their seeds: the world's, and saved with it, so that the game
+ * loaded from a save gives its next effect the id and the seed the game that went on does (and a stop finds its start)
+ */
+export declare const played: import("./components").Component<number, number>;
+/**
+ * Plays one of the view's effects on the screens of the players who see where it is (or those it is for), now. What it
+ * gives back stops it (`stopEffect`). Not in the world's state but for its count: a save, and a player who joins later,
+ * know nothing of the effect itself
+ *
+ * @beta
+ */
+export declare function playEffect(world: World, effect: string, options?: EffectOptions): number;
+/**
+ * Stops an effect the rules played (`playEffect`), on every screen: as its own `stop` says, over `fade` seconds
+ *
+ * @beta
+ */
+export declare function stopEffect(world: World, id: number, options?: {
+    fade?: number;
+}): void;
+/** An effect the rules play: to whom it is for, who sees where it is (what is there to be noticed, over the fog) */
+export declare const toldEffect: import("./replication").ReplicatedEvent;
+/** An effect stopped: to whom saw it start */
+export declare const toldEffectStopped: import("./replication").ReplicatedEvent;

package/dist/endings.d.ts

@@ -0,0 +1,22 @@
+import type { PlayerId } from './entity';
+import type { World } from './world';
+/** How many pauses each player has used, by player */
+export declare const pauses: import("./components").Component<{
+    used: Record<number, number>;
+}, {
+    used: Record<number, number>;
+}>;
+/**
+ * How many pauses a player has left (`GameRules.talk.pauses.each`, less what they used)
+ *
+ * @beta
+ */
+export declare function pausesLeft(world: World, player: PlayerId): number;
+/**
+ * A player gives up: out of the game as if beaten, once the game's `beforeSurrender` lets them. The rest of their
+ * side plays on; a side with nobody left loses, as the game's own way to win says (`lastTeamStanding` counts one who
+ * gave up as one who was in the game)
+ *
+ * @beta
+ */
+export declare function surrender(world: World, player: PlayerId): void;

package/dist/engagement.d.ts

@@ -0,0 +1,108 @@
+import type { Entity } from './entity';
+import type { Vec2 } from './math';
+import type { World } from './world';
+/**
+ * Where an attacker fights from: `ground`, `air` and `water` for the engine, any other name for a game's own
+ *
+ * @beta
+ */
+export type EngageLayer = 'ground' | 'air' | 'water' | (string & {});
+/**
+ * Seconds a target that could not be got at is left alone (see `shun`)
+ *
+ * @beta
+ */
+export declare const SHUN_TIME = 4;
+/**
+ * The ring an attacker fights from, by its reach: 0 for the melee
+ *
+ * @beta
+ */
+export declare function bandOf(world: World, attacker: Entity): number;
+/**
+ * The layer an attacker fights from, as the game's rules say (`GameRules.combat.engageLayer`)
+ *
+ * @beta
+ */
+export declare function engageLayer(world: World, attacker: Entity): EngageLayer;
+/**
+ * The engine's: from the air for what flies, from the water for boats, from the ground for the rest
+ *
+ * @beta
+ */
+export declare function defaultEngageLayer(_world: World, attacker: Entity): EngageLayer;
+/**
+ * The engine's room around a target for attackers like this one: as many as stand side by side around it, on the ring
+ * they fight from. Few for the melee around a footman, many around a town hall, all of them for long guns
+ *
+ * @beta
+ */
+export declare function defaultEngageRoom(world: World, target: Entity, attacker: Entity): number;
+/**
+ * How many attackers like this one may fight the target at once, as the game's rules say (`GameRules.combat.engageRoom`)
+ *
+ * @beta
+ */
+export declare function roomFor(world: World, target: Entity, attacker: Entity): number;
+/**
+ * Everyone fighting the target or closing in on it: of one layer only, when one is named
+ *
+ * @beta
+ */
+export declare function attackersOf(world: World, target: Entity, layer?: EngageLayer): Entity[];
+/**
+ * How many attackers like this one (the same layer, the same ring) the target has already, the attacker left out
+ *
+ * @beta
+ */
+export declare function engagedLike(world: World, target: Entity, attacker: Entity): number;
+/**
+ * Whether the target has no room left for another attacker like this one
+ *
+ * @beta
+ */
+export declare function isCrowded(world: World, target: Entity, attacker: Entity): boolean;
+/**
+ * What the attacker is fighting or closing in on, if anything
+ *
+ * @beta
+ */
+export declare function engagedWith(world: World, attacker: Entity): Entity | undefined;
+/**
+ * Marks the attacker engaged with the target, giving it a spot around it when it fights from close by (and has none
+ * there yet). The engine does this as a unit fights or closes in; a game's own fighting can too
+ *
+ * @beta
+ */
+export declare function engageWith(world: World, attacker: Entity, target: Entity): void;
+/**
+ * Lets go of whatever the attacker was engaged with, and of its spot there
+ *
+ * @beta
+ */
+export declare function release(attacker: Entity, world?: World): void;
+/**
+ * Where the attacker goes to fight the target from: its spot around it, out where its weapon reaches, or the target
+ * itself without one. The game's `approach` hook has the last word
+ *
+ * @beta
+ */
+export declare function spotFor(world: World, attacker: Entity, target: Entity): Vec2;
+/**
+ * Whether the attacker has been closing in on the target for longer than the game lets it (`GameRules.combat.giveUpChase`) without getting closer
+ *
+ * @beta
+ */
+export declare function isBlocked(world: World, attacker: Entity, target: Entity): boolean;
+/**
+ * Has the attacker leave the target alone for a while: not picked by itself again until then
+ *
+ * @beta
+ */
+export declare function shun(world: World, attacker: Entity, target: Entity, seconds?: number): void;
+/**
+ * Whether the attacker leaves the target alone for now (see `shun`)
+ *
+ * @beta
+ */
+export declare function isShunned(world: World, attacker: Entity, target: Entity): boolean;