@v12-engine/engine 0.1.0 → 0.4.0

package/dist/debugCommands.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"debugCommands.js","names":[],"sources":["../src/debugCommands.ts"],"sourcesContent":["import { type CommandDef, defineCommand, type DefinedCommand } from './commands'\nimport { footprintOf } from './defs'\nimport type { PlayerId } from './entity'\nimport { bool, type Check, type Checked, type Fields, id, ids, Invalid, isObject, number, object, oneOf, optional, point, string } from './fields'\nimport { grantXp, heroesOf, setHeroLevel } from './hero'\nimport { createItem, giveItem } from './items'\nimport { gameOver } from './engineEvents'\nimport { defeat } from './systems/victory'\nimport { earn } from './player'\nimport type { World } from './world'\nimport { teamMemory } from './session/memory'\nimport {\n\tblankDefinition,\n\tCOPY_OF,\n\tDATA_KINDS,\n\tdefinitionIn,\n\teditableFields,\n\tfitValue,\n\tnested,\n\tNEW_DEFINITION,\n\tpathCheck,\n\tvalueCheck\n} from './gameData'\nimport { hypot } from './exactMath'\nimport { replicateEvent, snapshotField } from './replication'\nimport { groundReshaped } from './engineEvents'\nimport { type TerrainPatch, terrainPatchProblem } from './ground'\nimport type { MapObject } from './map'\nimport { giveMapOrders, spawnMapObject } from './mapObjects'\nimport { corpses } from './summons'\n\n/*\n * The debug tools as commands: cheats, the fog lifted, the time of day, the speed, things created and cleared, and\n * resources, experience and deaths given out. Commands like any other, so that they work the same wherever the\n * simulation runs, a server included; and only from players the session lets use them (`world.debugPlayers`): a seat\n * in the page that asked for it, a server started to allow it. Everyone else is told no\n */\n\n/**\n * A debug command of a game's or a scene's own: one that goes through only for players allowed the debug tools\n * (`world.debugPlayers`), and tells others so. Otherwise like `defineCommand`\n *\n * @beta\n */\nexport function defineDebugCommand<const T extends string, F extends Fields>(\n\ttype: T,\n\tfields: F,\n\texecute: (world: World, player: PlayerId, command: Checked<F>) => void\n): DefinedCommand<T, F> {\n\treturn defineCommand(type, fields, (world, player, command) => {\n\t\tif (!world.debugPlayers.has(player)) {\n\t\t\tworld.message(player, { key: 'debugNotAllowed' })\n\t\t\treturn\n\t\t}\n\t\texecute(world, player, command)\n\t})\n}\n\n/**\n * A prefab of the game's put down where it says, for the sender, turned as said: to try one out, and for the editor's Play\n *\n * @beta\n */\nexport const spawnPrefabCommand = defineDebugCommand(\n\t'debug.spawnPrefab',\n\t{ prefab: string, at: point, facing: optional(number) },\n\t(world, player, command) => {\n\t\tif (!world.registry.prefabs.has(command.prefab)) return world.message(player, { key: 'unknownPrefab', params: { prefab: command.prefab } })\n\t\tworld.spawnPrefab(command.prefab, { at: command.at, owner: player, facing: command.facing })\n\t}\n)\n\n/**\n * A switch for trying things out: abilities used again at once, abilities that cost no mana, the units of those who may\n * use the debug tools unharmed (`World.cheats`)\n *\n * @beta\n */\nexport const cheatCommand = defineDebugCommand(\n\t'debug.cheat',\n\t{ cheat: oneOf('noCooldowns', 'noManaCosts', 'invulnerable'), on: bool },\n\t(world, _player, command) => {\n\t\tworld.cheats[command.cheat] = command.on\n\t}\n)\n\n/**\n * Lifts the fog for the sender's team, or puts it back: in the simulation itself, so that units react to what is shown\n *\n * @beta\n */\nexport const revealCommand = defineDebugCommand('debug.reveal', { on: bool }, (world, player, command) => {\n\tworld.fog.setRevealed(world.player(player).team, command.on)\n})\n\n/**\n * The whole map explored for everyone, as a map that starts explored has it (`FogSettings.startExplored`): the fog stays,\n * over what is not seen now, but the ground is dim, not black, and what stands on it and is no player's is known. Or no\n * longer: each team has explored what it sees now, and forgets what it does not\n *\n * @beta\n */\nexport const exploreCommand = defineDebugCommand('debug.explore', { on: bool }, (world, _player, command) => {\n\tworld.fog.exploreFromStart(command.on)\n\tfor (const [team, memory] of Object.entries(world.state(teamMemory))) {\n\t\t// what stands on it put among what each team knows again, at its next look (`TeamMemory.startKnown`)\n\t\tmemory.startKnown = false\n\t\tif (command.on) continue\n\t\tfor (const [id, state] of Object.entries(memory.structures))\n\t\t\tif (!world.fog.isVisible(Number(team), state.x, state.z)) delete memory.structures[Number(id)]\n\t}\n})\n\n/**\n * The time of day, in a game with days and nights\n *\n * @beta\n */\nexport const hourCommand = defineDebugCommand('debug.hour', { hour: number }, (world, _player, command) => {\n\tif (world.registry.day) world.clock.setHour(((command.hour % 24) + 24) % 24)\n})\n\n/**\n * How fast the game goes, 0 to pause, 8 at most: whoever runs it (a session in the page, a server) goes by it\n *\n * @beta\n */\nexport const speedCommand = defineDebugCommand('debug.speed', { speed: number }, (world, _player, command) => {\n\tworld.cheats.speed = Math.min(Math.max(command.speed, 0), 8)\n})\n\n/**\n * Creates something at a point, for a player: a building or a resource where there is room, or a group of units\n * (`count`, 50 at most). `hidden`: what can be invisible is out of sight from the start\n *\n * @beta\n */\nexport const spawnCommand = defineDebugCommand(\n\t'debug.spawn',\n\t{ unitType: string, owner: id, point, count: optional(number), hidden: optional(bool) },\n\t(world, player, command) => {\n\t\tif (!world.registry.units.has(command.unitType) || !world.players.has(command.owner)) return\n\t\tconst def = world.registry.unit(command.unitType)\n\t\tconst at = command.point\n\t\tif (def.kind !== 'unit') {\n\t\t\tconst fp = footprintOf(def)\n\t\t\tconst cell = world.grid.cellFor(at.x, at.z, fp.w, fp.d)\n\t\t\tif (!world.grid.canPlace(cell.x, cell.z, fp.w, fp.d)) world.message(player, { key: 'noRoomHere' })\n\t\t\telse world.spawn(def.id, command.owner, at)\n\t\t\treturn\n\t\t}\n\t\tconst count = Math.min(Math.max(Math.round(command.count ?? 1), 1), 50)\n\t\tconst columns = Math.ceil(Math.sqrt(count))\n\t\tconst spacing = def.radius * 2 + 0.4\n\t\tfor (let i = 0; i < count; i++) {\n\t\t\tconst column = (i % columns) - (columns - 1) / 2\n\t\t\tconst row = Math.floor(i / columns) - (Math.ceil(count / columns) - 1) / 2\n\t\t\tconst entity = world.spawn(def.id, command.owner, { x: at.x + column * spacing, z: at.z - row * spacing })\n\t\t\tif (command.hidden && entity.unseenIn !== null) entity.unseenIn = 0\n\t\t}\n\t}\n)\n\n/**\n * A brush: fills a circle with what stands on the grid (trees, rocks), thinner towards its edge, wherever there is room;\n * or, with `erase`, clears it of that type\n *\n * @beta\n */\nexport const paintCommand = defineDebugCommand(\n\t'debug.paint',\n\t{ unitType: string, owner: id, point, radius: number, erase: bool },\n\t(world, _player, command) => {\n\t\tif (!world.registry.units.has(command.unitType)) return\n\t\tconst def = world.registry.unit(command.unitType)\n\t\tconst { point: at } = command\n\t\tconst radius = Math.min(Math.max(command.radius, 0.5), 20)\n\t\tif (command.erase) {\n\t\t\tfor (const entity of [...world.entities.values()]) {\n\t\t\t\tif (entity.def.id === def.id && hypot(entity.pos.x - at.x, entity.pos.z - at.z) <= radius) world.kill(entity, undefined, false, 'removed')\n\t\t\t}\n\t\t\treturn\n\t\t}\n\t\tif (def.kind === 'unit' || !world.players.has(command.owner)) return\n\t\tconst fp = footprintOf(def)\n\t\tfor (let z = Math.floor(at.z - radius); z <= at.z + radius; z += fp.d) {\n\t\t\tfor (let x = Math.floor(at.x - radius); x <= at.x + radius; x += fp.w) {\n\t\t\t\tconst centre = { x: x + fp.w / 2, z: z + fp.d / 2 }\n\t\t\t\tconst distance = hypot(centre.x - at.x, centre.z - at.z)\n\t\t\t\tif (distance > radius) continue\n\t\t\t\t// thinner towards the edge, the same way for the same cell so that a stroke does not fill up by going over it\n\t\t\t\tconst chance = ((x * 73856093) ^ (z * 19349663)) >>> 0\n\t\t\t\tif (distance > radius * 0.6 && chance % 100 < ((distance / radius - 0.6) / 0.4) * 70) continue\n\t\t\t\tif (!world.grid.canPlace(x, z, fp.w, fp.d)) continue\n\t\t\t\tworld.spawn(def.id, command.owner, centre)\n\t\t\t}\n\t\t}\n\t}\n)\n\n/**\n * Gives the sender this much of every resource\n *\n * @beta\n */\nexport const giveCommand = defineDebugCommand('debug.give', { amount: number }, (world, player, command) => {\n\tfor (const resource of world.registry.resources) earn(world.player(player).resources, resource.id, command.amount)\n})\n\n/**\n * Gives the sender's heroes this much experience\n *\n * @beta\n */\nexport const experienceCommand = defineDebugCommand('debug.experience', { amount: number }, (world, player, command) => {\n\tfor (const hero of heroesOf(world, player)) if (hero.alive) grantXp(world, hero, command.amount)\n})\n\n/**\n * Puts units at a point, side by side, wherever they stood: structures stay where they were built. The way there is\n * not their concern (`World.place`)\n *\n * @internal\n */\nexport const teleportCommand = defineDebugCommand('debug.teleport', { entities: ids, point }, (world, _player, command) => {\n\tconst units = command.entities.flatMap((entityId) => {\n\t\tconst entity = world.get(entityId)\n\t\treturn entity?.alive && entity.isUnit ? [entity] : []\n\t})\n\tconst columns = Math.ceil(Math.sqrt(units.length))\n\tunits.forEach((entity, i) => {\n\t\tconst spacing = entity.def.radius * 2 + 0.4\n\t\tconst column = (i % columns) - (columns - 1) / 2\n\t\tconst row = Math.floor(i / columns) - (Math.ceil(units.length / columns) - 1) / 2\n\t\tworld.place(entity, { x: command.point.x + column * spacing, z: command.point.z - row * spacing })\n\t})\n})\n\n/**\n * Gives what it names to another player (`World.setOwner`): what it was doing is called off\n *\n * @internal\n */\nexport const setOwnerCommand = defineDebugCommand('debug.setOwner', { entities: ids, owner: id }, (world, _player, command) => {\n\tif (!world.players.has(command.owner)) return\n\tfor (const entityId of command.entities) {\n\t\tconst entity = world.get(entityId)\n\t\tif (entity?.alive) world.setOwner(entity, command.owner)\n\t}\n})\n\n/**\n * Puts an item of the game's in the first free slot of what carries things\n *\n * @beta\n */\nexport const giveItemCommand = defineDebugCommand('debug.giveItem', { entity: id, item: string }, (world, _player, command) => {\n\tconst entity = world.get(command.entity)\n\tif (!entity?.alive || !world.registry.items.has(command.item)) return\n\tgiveItem(world, entity, createItem(world, command.item))\n})\n\n/**\n * Researches an upgrade for the sender, to the level asked (its last when left out), at once and for nothing: what it\n * does to the units there are runs for each level it gains\n *\n * @internal\n */\nexport const researchCommand = defineDebugCommand('debug.research', { upgrade: string, level: optional(number) }, (world, player, command) => {\n\tif (!world.registry.upgrades.has(command.upgrade)) return\n\tconst def = world.registry.upgrade(command.upgrade)\n\tconst who = world.player(player)\n\tconst to = Math.min(Math.max(Math.round(command.level ?? def.maxLevel ?? 1), 0), def.maxLevel ?? 1)\n\tfor (let level = (who.upgrades.get(command.upgrade) ?? 0) + 1; level <= to; level++) {\n\t\twho.setUpgrade(command.upgrade, level)\n\t\tif (def.apply) for (const entity of [...world.index.ownedBy(player)]) if (entity.alive) def.apply(world, entity, level)\n\t}\n\twho.researching.delete(command.upgrade)\n})\n\n/**\n * Raises heroes to a level (never down, and no further than they can go: `setHeroLevel`)\n *\n * @beta\n */\nexport const setLevelCommand = defineDebugCommand('debug.setLevel', { entities: ids, level: number }, (world, _player, command) => {\n\tfor (const entityId of command.entities) {\n\t\tconst entity = world.get(entityId)\n\t\tif (entity?.alive) setHeroLevel(world, entity, command.level)\n\t}\n})\n\n/**\n * Wins the game for the sender's team: the others are out, and it is over. A game with a way to win of its own is\n * ended all the same\n *\n * @beta\n */\nexport const winCommand = defineDebugCommand('debug.win', {}, (world, player) => {\n\tif (world.winner !== null) return\n\tconst team = world.player(player).team\n\tfor (const other of world.players.values()) {\n\t\tif (other.neutral || other.creeps) continue\n\t\tother.established = true\n\t\tif (other.team !== team && !other.defeated) defeat(world, other.id)\n\t}\n\tworld.winner = team\n\tworld.events.emit(gameOver, { winner: team })\n})\n\n/**\n * Puts the sender out of the game, as if beaten: the others play on, or win by the game's own rule\n *\n * @beta\n */\nexport const loseCommand = defineDebugCommand('debug.lose', {}, (world, player) => {\n\tconst who = world.player(player)\n\tif (who.neutral || who.creeps || who.defeated || world.winner !== null) return\n\twho.established = true\n\tdefeat(world, player)\n})\n\n/**\n * Kills what it names, whoever's it is: what cannot be hurt included, but not scenery the map is made of\n *\n * @beta\n */\nexport const killCommand = defineDebugCommand('debug.kill', { entities: ids }, (world, _player, command) => {\n\tfor (const entityId of command.entities) {\n\t\tconst entity = world.get(entityId)\n\t\tif (entity?.alive && !entity.def.invulnerable) world.kill(entity, undefined, false, 'removed')\n\t}\n})\n\n/**\n * Changes a field of a definition while the game runs, as the editor's Data panel tries it: only one the game lets be\n * changed (`Rules.editable`), and for players allowed the debug tools\n *\n * @beta\n */\nexport const redefineCommand = defineDebugCommand(\n\t'debug.redefine',\n\t{ kind: oneOf(...DATA_KINDS), id: string, path: pathCheck, value: valueCheck },\n\t(world, player, command) => {\n\t\tconst def = definitionIn(world.registry, command.kind, command.id)\n\t\t// a copy made, of one the game lets be changed\n\t\tif (!def && command.path === COPY_OF && typeof command.value === 'string') {\n\t\t\tconst base = definitionIn(world.registry, command.kind, command.value)\n\t\t\tif (base && editableFields(world.registry.module, command.kind, base).length)\n\t\t\t\tworld.redefine(command.kind, command.id, { [COPY_OF]: command.value })\n\t\t\treturn\n\t\t}\n\t\t// one of its own made of nothing, of a kind the game lets be changed\n\t\tif (!def && command.path === NEW_DEFINITION && command.value === true) {\n\t\t\tif (editableFields(world.registry.module, command.kind, blankDefinition(command.kind, command.id)).length)\n\t\t\t\tworld.redefine(command.kind, command.id, { [NEW_DEFINITION]: true })\n\t\t\treturn\n\t\t}\n\t\tif (!def) return\n\t\tconst field = editableFields(world.registry.module, command.kind, def).find((each) => each.path === command.path)\n\t\tconst fit = field ? fitValue(field, command.value) : { error: `${command.path} cannot be changed` }\n\t\tif ('error' in fit) world.message(player, { key: 'dataRefused', params: { why: fit.error } })\n\t\telse world.redefine(command.kind, command.id, nested(command.path, fit.value))\n\t}\n)\n\n/** The most of anything a value of a map's own may hold, and as deep: a field of the game's, not a file */\nconst PLAIN_MOST = 10_000\nconst PLAIN_DEPTH = 16\n\n/** What the map's own fields hold (`MapObject.data`): numbers, words, switches, lists and objects of them, and nothing else */\nconst plain: Check<unknown> = (value, path) => {\n\tlet count = 0\n\tconst copy = (each: unknown, at: string, depth: number): unknown => {\n\t\tif (++count > PLAIN_MOST || depth > PLAIN_DEPTH) throw new Invalid(`${path} is more than a field of the map holds`)\n\t\tif (each === null || typeof each === 'boolean' || typeof each === 'string') return each\n\t\tif (typeof each === 'number') return number(each, at)\n\t\tif (Array.isArray(each)) return each.map((item, i) => copy(item, `${at}[${i}]`, depth + 1))\n\t\tif (isObject(each)) return Object.fromEntries(Object.entries(each).map(([key, item]) => [key, copy(item, `${at}.${key}`, depth + 1)]))\n\t\tthrow new Invalid(`${at} is not a value of the map's`)\n\t}\n\treturn copy(value, path, 0)\n}\n\n/** A list of what a check takes, so long at most */\nconst listOf =\n\t<T>(check: Check<T>, most: number): Check<T[]> =>\n\t(value, path) => {\n\t\tif (!Array.isArray(value) || value.length > most) throw new Invalid(`${path} is a list of at most ${most}`)\n\t\treturn value.map((item, i) => check(item, `${path}[${i}]`))\n\t}\n\n/** What a cell of the ground holds: 0 to 255 */\nconst byte: Check<number> = (value, path) => {\n\tif (!Number.isInteger(value) || (value as number) < 0 || (value as number) > 255) throw new Invalid(`${path} is a whole number of 0 to 255`)\n\treturn value as number\n}\n\n/** The most cells a patch of the ground has: a map of 2048 a side */\nconst MOST_CELLS = 2049 * 2049\n\n/** A patch of the ground (`TerrainPatch`), each layer the size the ground says, checked as it is put in */\nconst terrainPatchCheck: Check<TerrainPatch> = (value, path) => {\n\tconst checked = object({\n\t\tx: id,\n\t\tz: id,\n\t\twidth: id,\n\t\tdepth: id,\n\t\theights: listOf(number, MOST_CELLS),\n\t\twaterHeights: listOf(number, MOST_CELLS),\n\t\tlevels: listOf(byte, MOST_CELLS),\n\t\twater: listOf(byte, MOST_CELLS),\n\t\ttiles: listOf(byte, MOST_CELLS),\n\t\tblocked: listOf(byte, MOST_CELLS),\n\t\tcells: optional((layers, at): Record<string, number[]> => {\n\t\t\tif (!isObject(layers)) throw new Invalid(`${at} is the layers of cells by id`)\n\t\t\treturn Object.fromEntries(\n\t\t\t\tObject.entries(layers).map(([layer, cells]) => [string(layer, at), listOf(byte, MOST_CELLS)(cells, `${at}.${layer}`)])\n\t\t\t)\n\t\t})\n\t})(value, path)\n\treturn checked as TerrainPatch\n}\n\n/** An object of the map (`MapObject`), as the editor has it: what of it the world reads, checked. Not turned, and as big as its type, when it does not say */\nconst mapObjectCheck: Check<MapObject> = (value, path) =>\n\t({\n\t\tfacing: 0,\n\t\tscale: 1,\n\t\t...object({\n\t\t\tid,\n\t\t\ttype: string,\n\t\t\towner: id,\n\t\t\tx: number,\n\t\t\tz: number,\n\t\t\tfacing: optional(number),\n\t\t\tscale: optional(number),\n\t\t\tlook: optional(string),\n\t\t\tdrops: optional(string),\n\t\t\tname: optional(string),\n\t\t\thealth: optional(number),\n\t\t\tmana: optional(number),\n\t\t\tlevel: optional(number),\n\t\t\tabilities: optional(plain),\n\t\t\titems: optional(listOf(string, 100)),\n\t\t\tamount: optional(number),\n\t\t\tunderConstruction: optional(bool),\n\t\t\tlifetime: optional(number),\n\t\t\torders: optional(plain),\n\t\t\tdata: optional(plain)\n\t\t})(value, path)\n\t}) as MapObject\n\n/**\n * An object placed on the map put in the world as the map's are as the world is made (`spawnMapObject`): its type,\n * owner, where it stands and how it is turned, and the rest the map says of it (its health, level, items, the game's\n * fields, its orders), kept as the entity of that object (`World.fromMap`): what the editor's Play here sends as\n * something is placed on the map while it plays (EQ10). A building where there is no room is refused, as `debug.spawn`\n * refuses it\n *\n * @beta\n */\nexport const mapObjectCommand = defineDebugCommand('debug.mapObject', { object: mapObjectCheck }, (world, player, command) => {\n\tconst { object } = command\n\tif (!world.registry.units.has(object.type) || !world.players.has(object.owner)) return\n\tconst def = world.registry.unit(object.type)\n\tif (def.kind !== 'unit') {\n\t\tconst fp = footprintOf(def)\n\t\tconst cell = world.grid.cellFor(object.x, object.z, fp.w, fp.d)\n\t\tif (!world.grid.canPlace(cell.x, cell.z, fp.w, fp.d)) return world.message(player, { key: 'noRoomHere' })\n\t}\n\tconst entity = spawnMapObject(world, object)\n\tif (Array.isArray(object.orders) && object.orders.length) giveMapOrders(world, entity, object.orders)\n})\n\n/**\n * Moves what an object of the map became (`World.fromMap`, by the object's id) where it stands on the map now,\n * turned as it is: a unit is put there (`World.place`), the way there not its concern. A structure is not moved: the\n * editor takes it away and puts it down again\n *\n * @beta\n */\nexport const placeCommand = defineDebugCommand('debug.place', { object: id, point, facing: optional(number) }, (world, _player, command) => {\n\tconst entity = world.get(world.fromMap.get(command.object))\n\tif (!entity?.alive || entity.isStructure) return\n\tworld.place(entity, command.point)\n\tif (command.facing !== undefined) entity.facing = command.facing\n})\n\n/**\n * Takes what objects of the map became (`World.fromMap`, by the objects' ids) out of the world, whatever they\n * are, scenery included: no corpse is left. What the editor's Play here sends as something is taken off the map\n *\n * @beta\n */\nexport const unplaceCommand = defineDebugCommand('debug.unplace', { objects: ids }, (world, _player, command) => {\n\tconst gone = new Set<number>()\n\tfor (const object of command.objects) {\n\t\tconst entity = world.get(world.fromMap.get(object))\n\t\tworld.fromMap.delete(object)\n\t\tif (!entity?.alive) continue\n\t\tworld.kill(entity, undefined, false, 'removed')\n\t\tgone.add(entity.id)\n\t}\n\tconst lying = world.state(corpses)\n\tif (lying.some((corpse) => gone.has(corpse.id)))\n\t\tworld.setState(\n\t\t\tcorpses,\n\t\t\tlying.filter((corpse) => !gone.has(corpse.id))\n\t\t)\n})\n\n/**\n * Reshapes a part of the ground as the patch has it (`World.reshapeGround`): what the editor's Play here sends of the\n * map's ground as its heights, cliffs, water and paint are edited while it plays. A patch that does not fit the ground\n * is refused\n *\n * @beta\n */\nexport const groundCommand = defineDebugCommand('debug.ground', { patch: terrainPatchCheck }, (world, player, command) => {\n\tconst problem = terrainPatchProblem(world.terrain, command.patch)\n\tif (problem) return world.message(player, { key: 'dataRefused', params: { why: problem } })\n\tworld.reshapeGround(command.patch)\n})\n\n/** The ground reshaped (`World.reshapeGround`): to everyone, as it is now */\nexport const toldGround = replicateEvent(groundReshaped, 'ground', ({ patch }) => ({ type: 'ground', patch: structuredClone(patch) }))\n\n/**\n * The debug commands of the engine, which every game has; they go through only for who may use them\n *\n * @beta\n */\nexport const debugCommands: CommandDef[] = [\n\tcheatCommand,\n\trevealCommand,\n\texploreCommand,\n\thourCommand,\n\tspeedCommand,\n\tspawnCommand,\n\tpaintCommand,\n\tgiveCommand,\n\texperienceCommand,\n\tkillCommand,\n\tspawnPrefabCommand,\n\tteleportCommand,\n\tsetOwnerCommand,\n\tgiveItemCommand,\n\tresearchCommand,\n\tsetLevelCommand,\n\twinCommand,\n\tloseCommand,\n\tmapObjectCommand,\n\tplaceCommand,\n\tunplaceCommand,\n\tgroundCommand\n] as unknown as CommandDef[]\n\n/** What a player who may use the debug commands is told of them (`Snapshot.debug`): the switches on, and whether the map started explored */\nexport const debugPart = snapshotField(\n\t'debug',\n\t({ world, player }) => (world.debugPlayers.has(player) ? { ...world.cheats, explored: world.fog.exploredFromStart } : undefined),\n\ttrue\n)\n"],"mappings":"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"}

package/dist/debugging.d.ts

@@ -6,5 +6,6 @@
  * debug tools imports none of this
  */
 export { cheatCommand, debugCommands, defineDebugCommand, experienceCommand, exploreCommand, giveCommand, giveItemCommand, groundCommand, hourCommand, killCommand, loseCommand, mapObjectCommand, paintCommand, placeCommand, redefineCommand, revealCommand, setLevelCommand, spawnCommand, spawnPrefabCommand, speedCommand, unplaceCommand, winCommand } from './debugCommands';
+export { cellStylesCommand, type FoliageBrushAct, foliageCommand, foliageDebugCommands, windCommand } from './foliageDebug';
 export { type DebugChecks, setDebugChecks } from './debug';
 export { EventLog, inspect } from './inspect';

package/dist/defaultSets.d.ts

@@ -0,0 +1,183 @@
+/**
+ * The engine's default sets (items-and-spells plan, phase 5): definitions a game takes whole, takes but some of, takes
+ * and changes, or leaves (`useDefaults`). The default items (`defaultItemSet`) are one; a set of hero spells or of
+ * callings plugs in the same way, by the field of the rules its definitions go in (`DefaultSet.kind`) or by a way of
+ * its own of laying them (`DefaultSet.lay`). What the game chose is kept with its rules (`Rules.defaults`), so that its
+ * `data.json` can choose again (`GameData.defaults`, read by `layData`): the Data panel's "start from the defaults"
+ */
+import type { AbilityDef, BuffDef, TagDef, UnitTypeDef } from './defs';
+import type { Rules } from './game';
+import type { GamePack } from './packs/pack';
+/**
+ * A field of the rules a set's definitions go in (`DefaultSet.kind`): a list of definitions with ids
+ *
+ * @beta
+ */
+export type SetKind = 'units' | 'abilities' | 'buffs' | 'items' | 'upgrades' | 'races' | 'tags' | (string & {});
+/**
+ * What a set's definitions use besides themselves, each taken along as a chosen definition names its id (anywhere in
+ * it, or in another taken along): an item's ability, the buff the ability puts on, the ward it plants. Tags all come,
+ * as the vocabulary of the set, unless nothing of it is chosen
+ *
+ * @beta
+ */
+export interface SetUses {
+    /** Abilities: what items do when used, their passives */
+    abilities?: readonly AbilityDef[];
+    /** Buffs the definitions or their abilities put on */
+    buffs?: readonly BuffDef[];
+    /** Unit types they bring into the world: a ward, a wolf */
+    units?: readonly UnitTypeDef[];
+    /** The tags they say, named and given a look (`Rules.tags`) */
+    tags?: readonly TagDef[];
+}
+/**
+ * A default set of definitions: what the engine offers a game to take whole or in part (`useDefaults`)
+ *
+ * @beta
+ */
+export interface DefaultSet<D extends {
+    id: string;
+} = {
+    id: string;
+}> {
+    /** The set's id: what a choice names it by (`{ items: 'all' }`) and a `data.json` too */
+    id: string;
+    /** What the editor calls it */
+    name: string;
+    /** A line about it */
+    description?: string;
+    /** The field of the rules its definitions go in (`items`), unless it lays them its own way (`lay`) */
+    kind: SetKind;
+    /** Its definitions, in order */
+    defs: readonly D[];
+    /** What they use besides (`SetUses`), taken along as they name it */
+    uses?: SetUses;
+    /** The packs it needs (the stats its items give), added to a game that has none of their ids while anything of it is chosen */
+    packs?: () => GamePack[];
+    /**
+     * Lays what was chosen of it in the rules, for a set that goes in no list of the rules (callings handed to a pack):
+     * the definitions chosen, all of them, in the place of what an earlier choice laid (none, to take it all out)
+     */
+    lay?(rules: Rules, defs: readonly D[]): Rules;
+}
+/**
+ * What a game takes of a default set, in code: `all` of it (when left out), `none`, or some: `only` these ids, all
+ * `except` these, with definitions of its own besides or in the place of the set's of the same id (`with`), and some of
+ * them changed (`change`, by id: fields laid over the set's, or a function of it)
+ *
+ * @beta
+ */
+export type SetChoice<D extends {
+    id: string;
+} = {
+    id: string;
+}> = 'all' | 'none' | SetPick<D>;
+/**
+ * Some of a default set (`SetChoice`)
+ *
+ * @beta
+ */
+export interface SetPick<D extends {
+    id: string;
+} = {
+    id: string;
+}> {
+    /** Only these, by id: every one when left out */
+    only?: readonly string[];
+    /** All but these, by id */
+    except?: readonly string[];
+    /** Definitions of the game's besides: one with the id of one of the set's takes its place */
+    with?: readonly D[];
+    /** Changes to some of the set's, by id: fields laid over it (deep, a list whole), or a function of it */
+    change?: Readonly<Record<string, DeepPart<D> | ((def: D) => D)>>;
+}
+/**
+ * What a game takes of a set, as `useDefaults` is given it for sets of any kind (`SetChoice`): a function of `change`
+ * says the kind of definition it is given (`(def: ItemDef) => ({ ...def, cost: { gold: 900 } })`)
+ *
+ * @beta
+ */
+export type AnySetChoice = 'all' | 'none' | {
+    only?: readonly string[];
+    except?: readonly string[];
+    with?: readonly {
+        id: string;
+    }[];
+    change?: Readonly<Record<string, object | ((def: never) => {
+        id: string;
+    })>>;
+};
+/**
+ * Part of a definition, at any depth: what a set's `change` lays over one
+ *
+ * @beta
+ */
+export type DeepPart<T> = T extends readonly unknown[] ? T : T extends object ? {
+    [K in keyof T]?: DeepPart<T[K]>;
+} : T;
+/**
+ * What a `data.json` takes of a default set (`GameData.defaults`): all of it, none, only some ids, or all but some.
+ * Over what the code chose of it, whose own definitions (`with`) and changes stay; the data changes the set's
+ * definitions as any other (`items.<id>`)
+ *
+ * @beta
+ */
+export type DataSetChoice = 'all' | 'none' | {
+    only?: string[];
+    except?: string[];
+};
+/**
+ * The default sets a game took, kept with its rules (`Rules.defaults`): the sets, what was chosen of each, and what
+ * they added to the rules by field (ids; `packs` by pack id), so that a choice made again takes it out first
+ *
+ * @beta
+ */
+export interface ChosenDefaults {
+    /** The sets, by their order of taking */
+    readonly sets: readonly DefaultSet<{
+        id: string;
+    }>[];
+    /** What was chosen of each, by set id */
+    readonly chosen: Readonly<Record<string, AnySetChoice>>;
+    /** What they put in the rules, by field (`items`, `abilities`, `packs`…), by id */
+    readonly added: Readonly<Record<string, readonly string[]>>;
+    /** The game's unit types before what it did not take of the sets came off their shops and loot, where something did */
+    readonly units?: Rules['units'];
+}
+/**
+ * The definitions a choice takes of a default set (`SetChoice`): those it keeps, changed as it says, and its own
+ * besides, one with an id of the set's in that one's place
+ *
+ * @beta
+ */
+export declare function chooseSet<D extends {
+    id: string;
+}>(set: Pick<DefaultSet<D>, 'defs'>, choice?: SetChoice<D>): D[];
+/**
+ * The game with default sets taken, as it chooses of each (`SetChoice`, all of a set it says nothing of): their
+ * definitions in the fields of the rules they go in, after the game's own, one of the game's with the id of one of a
+ * set's in that one's place; what they use besides (`SetUses`); the packs they need, where the game has none of their
+ * id. Kept with the rules (`Rules.defaults`), so that its `data.json` can choose again (`layData`), and so that calling
+ * it again chooses again: `useDefaults(game, [], { items: 'none' })`. The game given is not changed
+ *
+ * ```ts
+ * export const game = layData(useDefaults(rules, [defaultItemSet], { items: { except: ['sightWard'] } }), dataFile)
+ * ```
+ *
+ * @beta
+ */
+export declare function useDefaults(rules: Rules, sets: readonly DefaultSet[], choices?: Readonly<Record<string, AnySetChoice>>): Rules;
+/**
+ * What a `data.json` takes of a set laid over what the code took (`DataSetChoice`): the data's all, none, only or except
+ * in the place of the code's, the code's own definitions (`with`) and changes kept
+ *
+ * @beta
+ */
+export declare function overChoice(code: AnySetChoice | undefined, data: DataSetChoice): AnySetChoice;
+/**
+ * Why what a `data.json` says of the default sets is not right, where it first is not: nothing when it is
+ *
+ * @beta
+ */
+export declare function dataDefaultsProblem(said: unknown, rules: Rules): string | undefined;

package/dist/defaultSets.js

@@ -0,0 +1,216 @@
+//#region src/defaultSets.ts
+var isPlain = (value) => typeof value === "object" && value !== null && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype;
+/** `over` laid on `under` at any depth: plain objects part by part, anything else (a list) whole */
+function deepLay(under, over) {
+	if (!isPlain(under) || !isPlain(over)) return over;
+	const out = { ...under };
+	for (const [key, value] of Object.entries(over)) out[key] = value === void 0 ? out[key] : deepLay(out[key], value);
+	return out;
+}
+/** A choice as a pick: `all` nothing said, `none` only nothing */
+function pickOf(choice) {
+	if (choice === void 0 || choice === "all") return {};
+	if (choice === "none") return { only: [] };
+	return choice;
+}
+/**
+* The definitions a choice takes of a default set (`SetChoice`): those it keeps, changed as it says, and its own
+* besides, one with an id of the set's in that one's place
+*
+* @beta
+*/
+function chooseSet(set, choice) {
+	const pick = pickOf(choice);
+	const own = new Map((pick.with ?? []).map((def) => [def.id, def]));
+	return [...set.defs.filter((def) => (pick.only ? pick.only.includes(def.id) : true) && !pick.except?.includes(def.id)).map((def) => {
+		if (own.has(def.id)) {
+			const mine = own.get(def.id);
+			own.delete(def.id);
+			return mine;
+		}
+		const change = pick.change?.[def.id];
+		if (change === void 0) return def;
+		return typeof change === "function" ? change(def) : deepLay(def, change);
+	}), ...own.values()];
+}
+/** Every string anywhere in a value: the ids a definition names, wherever it names them */
+function stringsIn(value, into, seen = /* @__PURE__ */ new Set()) {
+	if (typeof value === "string") into.add(value);
+	else if (typeof value === "object" && value !== null && !seen.has(value)) {
+		seen.add(value);
+		for (const each of Array.isArray(value) ? value : Object.values(value)) stringsIn(each, into, seen);
+	}
+}
+/** What of a set's uses the chosen definitions need: those whose ids they name, and those these name, by field */
+function usedBy(defs, uses) {
+	const out = {};
+	if (!uses || !defs.length) return out;
+	const named = /* @__PURE__ */ new Set();
+	stringsIn(defs, named);
+	const taken = /* @__PURE__ */ new Set();
+	for (let more = true; more;) {
+		more = false;
+		for (const field of [
+			"abilities",
+			"buffs",
+			"units"
+		]) for (const def of uses[field] ?? []) {
+			if (taken.has(def) || !named.has(def.id)) continue;
+			taken.add(def);
+			(out[field] ??= []).push(def);
+			stringsIn(def, named);
+			more = true;
+		}
+	}
+	if (uses.tags?.length) out.tags = [...uses.tags];
+	return out;
+}
+/** The rules with what earlier choices added taken out (`ChosenDefaults.added`), and the sets that lay their own way cleared */
+function withoutDefaults(rules) {
+	const kept = rules.defaults;
+	if (!kept) return rules;
+	let out = { ...rules };
+	const table = out;
+	for (const [field, ids] of Object.entries(kept.added)) {
+		const list = table[field];
+		if (!Array.isArray(list)) continue;
+		const gone = new Set(ids);
+		table[field] = list.filter((def) => !gone.has(def.id));
+	}
+	for (const set of kept.sets) if (set.lay) out = set.lay(out, []);
+	if (kept.units) out.units = kept.units;
+	delete out.defaults;
+	return out;
+}
+/**
+* The game with default sets taken, as it chooses of each (`SetChoice`, all of a set it says nothing of): their
+* definitions in the fields of the rules they go in, after the game's own, one of the game's with the id of one of a
+* set's in that one's place; what they use besides (`SetUses`); the packs they need, where the game has none of their
+* id. Kept with the rules (`Rules.defaults`), so that its `data.json` can choose again (`layData`), and so that calling
+* it again chooses again: `useDefaults(game, [], { items: 'none' })`. The game given is not changed
+*
+* ```ts
+* export const game = layData(useDefaults(rules, [defaultItemSet], { items: { except: ['sightWard'] } }), dataFile)
+* ```
+*
+* @beta
+*/
+function useDefaults(rules, sets, choices = {}) {
+	const before = rules.defaults;
+	const all = [...(before?.sets ?? []).filter((set) => !sets.some((each) => each.id === set.id)), ...sets];
+	const chosen = {
+		...before?.chosen,
+		...choices
+	};
+	let out = { ...withoutDefaults(rules) };
+	const table = () => out;
+	const added = {};
+	/** Puts definitions after a field's own, those of an id already there left out: the game's own come first */
+	const put = (field, defs) => {
+		const there = table()[field] ?? [];
+		const ids = new Set(there.map((def) => def.id));
+		const fresh = defs.filter((def) => !ids.has(def.id));
+		if (!fresh.length) return;
+		table()[field] = [...there, ...fresh];
+		(added[field] ??= []).push(...fresh.map((def) => def.id));
+	};
+	for (const set of all) {
+		const defs = chooseSet(set, chosen[set.id]);
+		if (set.lay) out = set.lay(out, defs);
+		else put(set.kind, defs);
+		for (const [field, used] of Object.entries(usedBy(defs, set.uses))) put(field, used);
+		if (!defs.length || !set.packs) continue;
+		for (const pack of set.packs()) {
+			if ((out.packs ?? []).some((each) => each.id === pack.id)) continue;
+			out = {
+				...out,
+				packs: [...out.packs ?? [], pack]
+			};
+			(added.packs ??= []).push(pack.id);
+		}
+	}
+	const shops = withoutLeftItems(out, all);
+	return {
+		...shops,
+		defaults: {
+			sets: all,
+			chosen,
+			added,
+			...shops.units !== out.units && { units: out.units }
+		}
+	};
+}
+/**
+* The rules with the items of a set the game did not take off its shops and its loot (`UnitTypeDef.sells`, `drops`): a
+* shop of the game's that sells the set's items whole sells what was taken of them
+*/
+function withoutLeftItems(rules, sets) {
+	const offered = new Set(sets.filter((set) => set.kind === "items").flatMap((set) => set.defs.map((def) => def.id)));
+	if (!offered.size) return rules;
+	const have = new Set((rules.items ?? []).map((def) => def.id));
+	const left = (id) => offered.has(id) && !have.has(id);
+	if (!rules.units.some((unit) => unit.sells?.some(left) || Array.isArray(unit.drops) && unit.drops.some((drop) => left(drop.item)))) return rules;
+	return {
+		...rules,
+		units: rules.units.map((unit) => {
+			const sells = unit.sells?.some(left) ? unit.sells.filter((id) => !left(id)) : unit.sells;
+			const drops = Array.isArray(unit.drops) && unit.drops.some((drop) => left(drop.item)) ? unit.drops.filter((drop) => !left(drop.item)) : unit.drops;
+			return sells === unit.sells && drops === unit.drops ? unit : {
+				...unit,
+				sells,
+				drops
+			};
+		})
+	};
+}
+/**
+* What a `data.json` takes of a set laid over what the code took (`DataSetChoice`): the data's all, none, only or except
+* in the place of the code's, the code's own definitions (`with`) and changes kept
+*
+* @beta
+*/
+function overChoice(code, data) {
+	const { with: own, change } = pickOf(code);
+	return {
+		...data === "all" ? {} : data === "none" ? { only: [] } : {
+			only: data.only,
+			except: data.except
+		},
+		...own && { with: own },
+		...change && { change }
+	};
+}
+/**
+* Why what a `data.json` says of the default sets is not right, where it first is not: nothing when it is
+*
+* @beta
+*/
+function dataDefaultsProblem(said, rules) {
+	if (!isPlain(said)) return "defaults is no object of sets";
+	const sets = rules.defaults?.sets ?? [];
+	for (const [id, choice] of Object.entries(said)) {
+		if (!sets.some((set) => set.id === id)) return `defaults.${id}: the game takes no default set "${id}" (useDefaults)`;
+		if (choice === "all" || choice === "none") continue;
+		if (!isPlain(choice)) return `defaults.${id} is all, none, or { only, except }`;
+		for (const [key, ids] of Object.entries(choice)) {
+			if (key !== "only" && key !== "except") return `defaults.${id}.${key} is nothing a data.json chooses by (only, except)`;
+			if (!Array.isArray(ids) || !ids.every((each) => typeof each === "string")) return `defaults.${id}.${key} is no list of ids`;
+		}
+	}
+}
+/**
+* The game with what its `data.json` takes of the default sets (`GameData.defaults`) over what its code took: what
+* `layData` does first
+*
+* @internal
+*/
+function dataDefaults(rules, said) {
+	const chosen = rules.defaults?.chosen ?? {};
+	const choices = {};
+	for (const [id, choice] of Object.entries(said)) choices[id] = overChoice(chosen[id], choice);
+	return useDefaults(rules, [], choices);
+}
+//#endregion
+export { chooseSet, dataDefaults, dataDefaultsProblem, overChoice, useDefaults };
+
+//# sourceMappingURL=defaultSets.js.map

package/dist/defaultSets.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaultSets.js","names":[],"sources":["../src/defaultSets.ts"],"sourcesContent":["/**\n * The engine's default sets (items-and-spells plan, phase 5): definitions a game takes whole, takes but some of, takes\n * and changes, or leaves (`useDefaults`). The default items (`defaultItemSet`) are one; a set of hero spells or of\n * callings plugs in the same way, by the field of the rules its definitions go in (`DefaultSet.kind`) or by a way of\n * its own of laying them (`DefaultSet.lay`). What the game chose is kept with its rules (`Rules.defaults`), so that its\n * `data.json` can choose again (`GameData.defaults`, read by `layData`): the Data panel's \"start from the defaults\"\n */\nimport type { AbilityDef, BuffDef, TagDef, UnitTypeDef } from './defs'\nimport type { Rules } from './game'\nimport type { GamePack } from './packs/pack'\n\n/**\n * A field of the rules a set's definitions go in (`DefaultSet.kind`): a list of definitions with ids\n *\n * @beta\n */\nexport type SetKind = 'units' | 'abilities' | 'buffs' | 'items' | 'upgrades' | 'races' | 'tags' | (string & {})\n\n/**\n * What a set's definitions use besides themselves, each taken along as a chosen definition names its id (anywhere in\n * it, or in another taken along): an item's ability, the buff the ability puts on, the ward it plants. Tags all come,\n * as the vocabulary of the set, unless nothing of it is chosen\n *\n * @beta\n */\nexport interface SetUses {\n\t/** Abilities: what items do when used, their passives */\n\tabilities?: readonly AbilityDef[]\n\t/** Buffs the definitions or their abilities put on */\n\tbuffs?: readonly BuffDef[]\n\t/** Unit types they bring into the world: a ward, a wolf */\n\tunits?: readonly UnitTypeDef[]\n\t/** The tags they say, named and given a look (`Rules.tags`) */\n\ttags?: readonly TagDef[]\n}\n\n/**\n * A default set of definitions: what the engine offers a game to take whole or in part (`useDefaults`)\n *\n * @beta\n */\nexport interface DefaultSet<D extends { id: string } = { id: string }> {\n\t/** The set's id: what a choice names it by (`{ items: 'all' }`) and a `data.json` too */\n\tid: string\n\t/** What the editor calls it */\n\tname: string\n\t/** A line about it */\n\tdescription?: string\n\t/** The field of the rules its definitions go in (`items`), unless it lays them its own way (`lay`) */\n\tkind: SetKind\n\t/** Its definitions, in order */\n\tdefs: readonly D[]\n\t/** What they use besides (`SetUses`), taken along as they name it */\n\tuses?: SetUses\n\t/** The packs it needs (the stats its items give), added to a game that has none of their ids while anything of it is chosen */\n\tpacks?: () => GamePack[]\n\t/**\n\t * Lays what was chosen of it in the rules, for a set that goes in no list of the rules (callings handed to a pack):\n\t * the definitions chosen, all of them, in the place of what an earlier choice laid (none, to take it all out)\n\t */\n\tlay?(rules: Rules, defs: readonly D[]): Rules\n}\n\n/**\n * What a game takes of a default set, in code: `all` of it (when left out), `none`, or some: `only` these ids, all\n * `except` these, with definitions of its own besides or in the place of the set's of the same id (`with`), and some of\n * them changed (`change`, by id: fields laid over the set's, or a function of it)\n *\n * @beta\n */\nexport type SetChoice<D extends { id: string } = { id: string }> = 'all' | 'none' | SetPick<D>\n\n/**\n * Some of a default set (`SetChoice`)\n *\n * @beta\n */\nexport interface SetPick<D extends { id: string } = { id: string }> {\n\t/** Only these, by id: every one when left out */\n\tonly?: readonly string[]\n\t/** All but these, by id */\n\texcept?: readonly string[]\n\t/** Definitions of the game's besides: one with the id of one of the set's takes its place */\n\twith?: readonly D[]\n\t/** Changes to some of the set's, by id: fields laid over it (deep, a list whole), or a function of it */\n\tchange?: Readonly<Record<string, DeepPart<D> | ((def: D) => D)>>\n}\n\n/**\n * What a game takes of a set, as `useDefaults` is given it for sets of any kind (`SetChoice`): a function of `change`\n * says the kind of definition it is given (`(def: ItemDef) => ({ ...def, cost: { gold: 900 } })`)\n *\n * @beta\n */\nexport type AnySetChoice =\n\t| 'all'\n\t| 'none'\n\t| {\n\t\t\tonly?: readonly string[]\n\t\t\texcept?: readonly string[]\n\t\t\twith?: readonly { id: string }[]\n\t\t\tchange?: Readonly<Record<string, object | ((def: never) => { id: string })>>\n\t  }\n\n/**\n * Part of a definition, at any depth: what a set's `change` lays over one\n *\n * @beta\n */\nexport type DeepPart<T> = T extends readonly unknown[] ? T : T extends object ? { [K in keyof T]?: DeepPart<T[K]> } : T\n\n/**\n * What a `data.json` takes of a default set (`GameData.defaults`): all of it, none, only some ids, or all but some.\n * Over what the code chose of it, whose own definitions (`with`) and changes stay; the data changes the set's\n * definitions as any other (`items.<id>`)\n *\n * @beta\n */\nexport type DataSetChoice = 'all' | 'none' | { only?: string[]; except?: string[] }\n\n/**\n * The default sets a game took, kept with its rules (`Rules.defaults`): the sets, what was chosen of each, and what\n * they added to the rules by field (ids; `packs` by pack id), so that a choice made again takes it out first\n *\n * @beta\n */\nexport interface ChosenDefaults {\n\t/** The sets, by their order of taking */\n\treadonly sets: readonly DefaultSet<{ id: string }>[]\n\t/** What was chosen of each, by set id */\n\treadonly chosen: Readonly<Record<string, AnySetChoice>>\n\t/** What they put in the rules, by field (`items`, `abilities`, `packs`…), by id */\n\treadonly added: Readonly<Record<string, readonly string[]>>\n\t/** The game's unit types before what it did not take of the sets came off their shops and loot, where something did */\n\treadonly units?: Rules['units']\n}\n\nconst isPlain = (value: unknown): value is Record<string, unknown> =>\n\ttypeof value === 'object' && value !== null && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype\n\n/** `over` laid on `under` at any depth: plain objects part by part, anything else (a list) whole */\nfunction deepLay<T>(under: T, over: unknown): T {\n\tif (!isPlain(under) || !isPlain(over)) return over as T\n\tconst out: Record<string, unknown> = { ...under }\n\tfor (const [key, value] of Object.entries(over)) out[key] = value === undefined ? out[key] : deepLay(out[key], value)\n\treturn out as T\n}\n\n/** A choice as a pick: `all` nothing said, `none` only nothing */\nfunction pickOf<D extends { id: string }>(choice: SetChoice<D> | undefined): SetPick<D> {\n\tif (choice === undefined || choice === 'all') return {}\n\tif (choice === 'none') return { only: [] }\n\treturn choice\n}\n\n/**\n * The definitions a choice takes of a default set (`SetChoice`): those it keeps, changed as it says, and its own\n * besides, one with an id of the set's in that one's place\n *\n * @beta\n */\nexport function chooseSet<D extends { id: string }>(set: Pick<DefaultSet<D>, 'defs'>, choice?: SetChoice<D>): D[] {\n\tconst pick = pickOf(choice)\n\tconst own = new Map((pick.with ?? []).map((def) => [def.id, def]))\n\tconst kept = set.defs.filter((def) => (pick.only ? pick.only.includes(def.id) : true) && !pick.except?.includes(def.id))\n\tconst out = kept.map((def) => {\n\t\tif (own.has(def.id)) {\n\t\t\tconst mine = own.get(def.id)!\n\t\t\town.delete(def.id)\n\t\t\treturn mine\n\t\t}\n\t\tconst change = pick.change?.[def.id]\n\t\tif (change === undefined) return def\n\t\treturn typeof change === 'function' ? change(def) : deepLay(def, change)\n\t})\n\treturn [...out, ...own.values()]\n}\n\n/** Every string anywhere in a value: the ids a definition names, wherever it names them */\nfunction stringsIn(value: unknown, into: Set<string>, seen = new Set<unknown>()): void {\n\tif (typeof value === 'string') into.add(value)\n\telse if (typeof value === 'object' && value !== null && !seen.has(value)) {\n\t\tseen.add(value)\n\t\tfor (const each of Array.isArray(value) ? value : Object.values(value)) stringsIn(each, into, seen)\n\t}\n}\n\n/** What of a set's uses the chosen definitions need: those whose ids they name, and those these name, by field */\nfunction usedBy(defs: readonly { id: string }[], uses: SetUses | undefined): Record<string, { id: string }[]> {\n\tconst out: Record<string, { id: string }[]> = {}\n\tif (!uses || !defs.length) return out\n\tconst named = new Set<string>()\n\tstringsIn(defs, named)\n\tconst taken = new Set<unknown>()\n\tfor (let more = true; more; ) {\n\t\tmore = false\n\t\tfor (const field of ['abilities', 'buffs', 'units'] as const) {\n\t\t\tfor (const def of uses[field] ?? []) {\n\t\t\t\tif (taken.has(def) || !named.has(def.id)) continue\n\t\t\t\ttaken.add(def)\n\t\t\t\t;(out[field] ??= []).push(def)\n\t\t\t\tstringsIn(def, named)\n\t\t\t\tmore = true\n\t\t\t}\n\t\t}\n\t}\n\tif (uses.tags?.length) out.tags = [...uses.tags]\n\treturn out\n}\n\n/** The rules with what earlier choices added taken out (`ChosenDefaults.added`), and the sets that lay their own way cleared */\nfunction withoutDefaults(rules: Rules): Rules {\n\tconst kept = rules.defaults\n\tif (!kept) return rules\n\tlet out: Rules = { ...rules }\n\tconst table = out as unknown as Record<string, unknown>\n\tfor (const [field, ids] of Object.entries(kept.added)) {\n\t\tconst list = table[field]\n\t\tif (!Array.isArray(list)) continue\n\t\tconst gone = new Set(ids)\n\t\ttable[field] = list.filter((def: { id?: string }) => !gone.has(def.id as string))\n\t}\n\tfor (const set of kept.sets) if (set.lay) out = set.lay(out, [])\n\tif (kept.units) out.units = kept.units\n\tdelete out.defaults\n\treturn out\n}\n\n/**\n * The game with default sets taken, as it chooses of each (`SetChoice`, all of a set it says nothing of): their\n * definitions in the fields of the rules they go in, after the game's own, one of the game's with the id of one of a\n * set's in that one's place; what they use besides (`SetUses`); the packs they need, where the game has none of their\n * id. Kept with the rules (`Rules.defaults`), so that its `data.json` can choose again (`layData`), and so that calling\n * it again chooses again: `useDefaults(game, [], { items: 'none' })`. The game given is not changed\n *\n * ```ts\n * export const game = layData(useDefaults(rules, [defaultItemSet], { items: { except: ['sightWard'] } }), dataFile)\n * ```\n *\n * @beta\n */\nexport function useDefaults(rules: Rules, sets: readonly DefaultSet[], choices: Readonly<Record<string, AnySetChoice>> = {}): Rules {\n\tconst before = rules.defaults\n\tconst all = [...(before?.sets ?? []).filter((set) => !sets.some((each) => each.id === set.id)), ...sets]\n\tconst chosen: Record<string, AnySetChoice> = { ...before?.chosen, ...choices }\n\tlet out: Rules = { ...withoutDefaults(rules) }\n\tconst table = () => out as unknown as Record<string, unknown>\n\tconst added: Record<string, string[]> = {}\n\t/** Puts definitions after a field's own, those of an id already there left out: the game's own come first */\n\tconst put = (field: string, defs: readonly { id: string }[]) => {\n\t\tconst there = (table()[field] as { id: string }[] | undefined) ?? []\n\t\tconst ids = new Set(there.map((def) => def.id))\n\t\tconst fresh = defs.filter((def) => !ids.has(def.id))\n\t\tif (!fresh.length) return\n\t\ttable()[field] = [...there, ...fresh]\n\t\t;(added[field] ??= []).push(...fresh.map((def) => def.id))\n\t}\n\tfor (const set of all) {\n\t\tconst defs = chooseSet(set, chosen[set.id] as SetChoice | undefined)\n\t\tif (set.lay) out = set.lay(out, defs)\n\t\telse put(set.kind, defs)\n\t\tfor (const [field, used] of Object.entries(usedBy(defs, set.uses))) put(field, used)\n\t\tif (!defs.length || !set.packs) continue\n\t\tfor (const pack of set.packs()) {\n\t\t\tif ((out.packs ?? []).some((each) => each.id === pack.id)) continue\n\t\t\tout = { ...out, packs: [...(out.packs ?? []), pack] }\n\t\t\t;(added.packs ??= []).push(pack.id)\n\t\t}\n\t}\n\tconst shops = withoutLeftItems(out, all)\n\treturn { ...shops, defaults: { sets: all, chosen, added, ...(shops.units !== out.units && { units: out.units }) } }\n}\n\n/**\n * The rules with the items of a set the game did not take off its shops and its loot (`UnitTypeDef.sells`, `drops`): a\n * shop of the game's that sells the set's items whole sells what was taken of them\n */\nfunction withoutLeftItems(rules: Rules, sets: readonly DefaultSet[]): Rules {\n\tconst offered = new Set(sets.filter((set) => set.kind === 'items').flatMap((set) => set.defs.map((def) => def.id)))\n\tif (!offered.size) return rules\n\tconst have = new Set((rules.items ?? []).map((def) => def.id))\n\tconst left = (id: string) => offered.has(id) && !have.has(id)\n\tif (!rules.units.some((unit) => unit.sells?.some(left) || (Array.isArray(unit.drops) && unit.drops.some((drop) => left(drop.item))))) return rules\n\treturn {\n\t\t...rules,\n\t\tunits: rules.units.map((unit) => {\n\t\t\tconst sells = unit.sells?.some(left) ? unit.sells.filter((id) => !left(id)) : unit.sells\n\t\t\tconst drops = Array.isArray(unit.drops) && unit.drops.some((drop) => left(drop.item)) ? unit.drops.filter((drop) => !left(drop.item)) : unit.drops\n\t\t\treturn sells === unit.sells && drops === unit.drops ? unit : { ...unit, sells, drops }\n\t\t})\n\t}\n}\n\n/**\n * What a `data.json` takes of a set laid over what the code took (`DataSetChoice`): the data's all, none, only or except\n * in the place of the code's, the code's own definitions (`with`) and changes kept\n *\n * @beta\n */\nexport function overChoice(code: AnySetChoice | undefined, data: DataSetChoice): AnySetChoice {\n\tconst { with: own, change } = pickOf(code as SetChoice | undefined)\n\tconst said = data === 'all' ? {} : data === 'none' ? { only: [] } : { only: data.only, except: data.except }\n\treturn { ...said, ...(own && { with: own }), ...(change && { change }) }\n}\n\n/**\n * Why what a `data.json` says of the default sets is not right, where it first is not: nothing when it is\n *\n * @beta\n */\nexport function dataDefaultsProblem(said: unknown, rules: Rules): string | undefined {\n\tif (!isPlain(said)) return 'defaults is no object of sets'\n\tconst sets = rules.defaults?.sets ?? []\n\tfor (const [id, choice] of Object.entries(said)) {\n\t\tif (!sets.some((set) => set.id === id)) return `defaults.${id}: the game takes no default set \"${id}\" (useDefaults)`\n\t\tif (choice === 'all' || choice === 'none') continue\n\t\tif (!isPlain(choice)) return `defaults.${id} is all, none, or { only, except }`\n\t\tfor (const [key, ids] of Object.entries(choice)) {\n\t\t\tif (key !== 'only' && key !== 'except') return `defaults.${id}.${key} is nothing a data.json chooses by (only, except)`\n\t\t\tif (!Array.isArray(ids) || !ids.every((each) => typeof each === 'string')) return `defaults.${id}.${key} is no list of ids`\n\t\t}\n\t}\n\treturn undefined\n}\n\n/**\n * The game with what its `data.json` takes of the default sets (`GameData.defaults`) over what its code took: what\n * `layData` does first\n *\n * @internal\n */\nexport function dataDefaults(rules: Rules, said: Record<string, DataSetChoice>): Rules {\n\tconst chosen = rules.defaults?.chosen ?? {}\n\tconst choices: Record<string, AnySetChoice> = {}\n\tfor (const [id, choice] of Object.entries(said)) choices[id] = overChoice(chosen[id], choice)\n\treturn useDefaults(rules, [], choices)\n}\n"],"mappings":"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"}

package/dist/definitions.d.ts

@@ -17,6 +17,11 @@ export declare class Definitions<T> {
     /** What a definition must be to be taken: throws for one that is not */
     private readonly check?;
     private readonly byKey;
+    /**
+     * A number that changes whenever a definition is defined, defined again or taken out: what keeps something worked
+     * out of them (the flags of an entity's buffs) can tell it is out of date
+     */
+    readonly version: number;
     constructor(
     /** What one is called, for what is said of one there is not: `unit type`, `ability` */
     kind: string, 
@@ -38,6 +43,7 @@ export declare class Definitions<T> {
     /** Every key, in the order they were defined */
     keys(): string[];
     get size(): number;
+    private changed;
     /** Takes another's definitions over its own: those it has that the other has not are kept */
     takeFrom(other: Definitions<T>): void;
 }

package/dist/definitions.js

@@ -0,0 +1,78 @@
+//#region src/definitions.ts
+/**
+* One kind of definition of a game's, by key (`Definitions`): its unit types, its abilities, its buffs... What every
+* kind of a registry is, so that each is defined, found, listed and replaced the one way, and a tool that walks every
+* kind (the Data panel, mods, saves) walks one list (`Registry.kinds`)
+*/
+/** The last `Definitions.version` handed out: one count for every registry, so that two never share a version */
+var versions = 0;
+/**
+* The definitions of one kind, by key: in the order they were defined, one of a key defined again in the place of the
+* one before it
+*
+* @beta
+*/
+var Definitions = class {
+	kind;
+	keyOf;
+	check;
+	byKey = /* @__PURE__ */ new Map();
+	/**
+	* A number that changes whenever a definition is defined, defined again or taken out: what keeps something worked
+	* out of them (the flags of an entity's buffs) can tell it is out of date
+	*/
+	version = ++versions;
+	constructor(kind, keyOf = (def) => def.id, check) {
+		this.kind = kind;
+		this.keyOf = keyOf;
+		this.check = check;
+	}
+	/** Takes a definition, in the place of the one of its key where there is one */
+	define(def) {
+		this.check?.(def);
+		this.byKey.set(this.keyOf(def), def);
+		this.changed();
+		return this;
+	}
+	/** Takes the definition of a key out: false for one there is not */
+	remove(key) {
+		this.changed();
+		return this.byKey.delete(key);
+	}
+	/** The definition of a key: throws for one there is not */
+	get(key) {
+		const def = this.byKey.get(key);
+		if (def === void 0) throw new Error(`Unknown ${this.kind} "${key}"`);
+		return def;
+	}
+	/** The definition of a key, or nothing for one there is not */
+	find(key) {
+		return this.byKey.get(key);
+	}
+	has(key) {
+		return this.byKey.has(key);
+	}
+	/** Every definition, in the order they were defined */
+	all() {
+		return [...this.byKey.values()];
+	}
+	/** Every key, in the order they were defined */
+	keys() {
+		return [...this.byKey.keys()];
+	}
+	get size() {
+		return this.byKey.size;
+	}
+	changed() {
+		this.version = ++versions;
+	}
+	/** Takes another's definitions over its own: those it has that the other has not are kept */
+	takeFrom(other) {
+		for (const [key, def] of other.byKey) this.byKey.set(key, def);
+		this.changed();
+	}
+};
+//#endregion
+export { Definitions };
+
+//# sourceMappingURL=definitions.js.map

package/dist/definitions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"definitions.js","names":[],"sources":["../src/definitions.ts"],"sourcesContent":["/**\n * One kind of definition of a game's, by key (`Definitions`): its unit types, its abilities, its buffs... What every\n * kind of a registry is, so that each is defined, found, listed and replaced the one way, and a tool that walks every\n * kind (the Data panel, mods, saves) walks one list (`Registry.kinds`)\n */\n\n/** The last `Definitions.version` handed out: one count for every registry, so that two never share a version */\nlet versions = 0\n\n/**\n * The definitions of one kind, by key: in the order they were defined, one of a key defined again in the place of the\n * one before it\n *\n * @beta\n */\nexport class Definitions<T> {\n\tprivate readonly byKey = new Map<string, T>()\n\t/**\n\t * A number that changes whenever a definition is defined, defined again or taken out: what keeps something worked\n\t * out of them (the flags of an entity's buffs) can tell it is out of date\n\t */\n\treadonly version: number = ++versions\n\n\tconstructor(\n\t\t/** What one is called, for what is said of one there is not: `unit type`, `ability` */\n\t\treadonly kind: string,\n\t\t/** Its key: the id, or an order's or a command's type */\n\t\tprivate readonly keyOf: (def: T) => string = (def) => (def as { id: string }).id,\n\t\t/** What a definition must be to be taken: throws for one that is not */\n\t\tprivate readonly check?: (def: T) => void\n\t) {}\n\n\t/** Takes a definition, in the place of the one of its key where there is one */\n\tdefine(def: T): this {\n\t\tthis.check?.(def)\n\t\tthis.byKey.set(this.keyOf(def), def)\n\t\tthis.changed()\n\t\treturn this\n\t}\n\n\t/** Takes the definition of a key out: false for one there is not */\n\tremove(key: string): boolean {\n\t\tthis.changed()\n\t\treturn this.byKey.delete(key)\n\t}\n\n\t/** The definition of a key: throws for one there is not */\n\tget(key: string): T {\n\t\tconst def = this.byKey.get(key)\n\t\tif (def === undefined) throw new Error(`Unknown ${this.kind} \"${key}\"`)\n\t\treturn def\n\t}\n\n\t/** The definition of a key, or nothing for one there is not */\n\tfind(key: string): T | undefined {\n\t\treturn this.byKey.get(key)\n\t}\n\n\thas(key: string): boolean {\n\t\treturn this.byKey.has(key)\n\t}\n\n\t/** Every definition, in the order they were defined */\n\tall(): T[] {\n\t\treturn [...this.byKey.values()]\n\t}\n\n\t/** Every key, in the order they were defined */\n\tkeys(): string[] {\n\t\treturn [...this.byKey.keys()]\n\t}\n\n\tget size(): number {\n\t\treturn this.byKey.size\n\t}\n\n\tprivate changed(): void {\n\t\t;(this as { version: number }).version = ++versions\n\t}\n\n\t/** Takes another's definitions over its own: those it has that the other has not are kept */\n\ttakeFrom(other: Definitions<T>): void {\n\t\tfor (const [key, def] of other.byKey) this.byKey.set(key, def)\n\t\tthis.changed()\n\t}\n}\n"],"mappings":";;;;;;;AAOA,IAAI,WAAW;;;;;;;AAQf,IAAa,cAAb,MAA4B;CAUjB;CAEQ;CAEA;CAblB,wBAAyB,IAAI,IAAe;;;;;CAK5C,UAA2B,EAAE;CAE7B,YAEC,MAEA,SAA8C,QAAS,IAAuB,IAE9E,OACC;EALQ,KAAA,OAAA;EAEQ,KAAA,QAAA;EAEA,KAAA,QAAA;CACf;;CAGH,OAAO,KAAc;EACpB,KAAK,QAAQ,GAAG;EAChB,KAAK,MAAM,IAAI,KAAK,MAAM,GAAG,GAAG,GAAG;EACnC,KAAK,QAAQ;EACb,OAAO;CACR;;CAGA,OAAO,KAAsB;EAC5B,KAAK,QAAQ;EACb,OAAO,KAAK,MAAM,OAAO,GAAG;CAC7B;;CAGA,IAAI,KAAgB;EACnB,MAAM,MAAM,KAAK,MAAM,IAAI,GAAG;EAC9B,IAAI,QAAQ,KAAA,GAAW,MAAM,IAAI,MAAM,WAAW,KAAK,KAAK,IAAI,IAAI,EAAE;EACtE,OAAO;CACR;;CAGA,KAAK,KAA4B;EAChC,OAAO,KAAK,MAAM,IAAI,GAAG;CAC1B;CAEA,IAAI,KAAsB;EACzB,OAAO,KAAK,MAAM,IAAI,GAAG;CAC1B;;CAGA,MAAW;EACV,OAAO,CAAC,GAAG,KAAK,MAAM,OAAO,CAAC;CAC/B;;CAGA,OAAiB;EAChB,OAAO,CAAC,GAAG,KAAK,MAAM,KAAK,CAAC;CAC7B;CAEA,IAAI,OAAe;EAClB,OAAO,KAAK,MAAM;CACnB;CAEA,UAAwB;EACtB,KAA8B,UAAU,EAAE;CAC5C;;CAGA,SAAS,OAA6B;EACrC,KAAK,MAAM,CAAC,KAAK,QAAQ,MAAM,OAAO,KAAK,MAAM,IAAI,KAAK,GAAG;EAC7D,KAAK,QAAQ;CACd;AACD"}