@v12-engine/engine 0.1.0 → 0.4.0

package/dist/rules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rules.js","names":[],"sources":["../src/rules.ts"],"sourcesContent":["import { type DamageType, type ItemDef, type Stats, supplyOf, type UnitTypeDef } from './defs'\nimport type { MessageRef } from './messages'\nimport type { Registry } from './registry'\nimport { orderSays } from './orders/facts'\nimport { clamp } from './math'\nimport { damageScale, healingScale, mitigation } from './stats'\nimport { cleaveOf, type CleaveNow, shootsUphill, UPHILL_MISS } from './systems/combat'\nimport { defaultPickAttack, farthestAcquisition } from './attacks'\nimport type { Entity, PlayerId } from './entity'\nimport { type Upkeep, upkeepOf } from './upkeep'\nimport { defaultEngageLayer, defaultEngageRoom, defaultQueueDistance } from './engagement'\nimport type { World } from './world'\nimport type { OrderInit } from './registry'\nimport { groundSpeedAt } from './groundSpeed'\nimport type { ScoreSettings } from './score'\nimport { defaultHeroSettings, type HeroSettings } from './hero'\nimport { moving } from './entity'\nimport { type AttackModifier, bySlot } from './abilities/triggers'\n\n/**\n * A rule of `HudSharing`: one value for every unit, or a function deciding it for each (only heroes', only a boss's)\n *\n * @beta\n */\nexport type HudShareRule<T> = T | ((world: World, entity: Entity) => T)\n\n/**\n * What of a unit the players who see it are told beyond what they always are (`RuleSettings.hud`), each for the plates\n * over it to show. What is not shared never reaches a player, so no screen can show it. A game's own data goes in a\n * component with `replicate` (the client's `hudData` reads it)\n *\n * @beta\n */\nexport interface HudSharing {\n\t/**\n\t * The seconds left of its buffs (`EntityState.buffTimes`): to everyone who sees it (`true`), to its owner and their\n\t * allies (`'allies'`), or to no one (`false`, when left out)\n\t */\n\tshareBuffTimes?: HudShareRule<boolean | 'allies'>\n\t/**\n\t * Its abilities (`EntityState.abilities`) to everyone who sees it, its side's or not: those it has learned and\n\t * their levels (`'icons'`), with how much of their cooldowns is left too (`'cooldowns'`), or none (`'none'`, when\n\t * left out: its side has them in `own` all the same)\n\t */\n\tshareAbilities?: HudShareRule<'none' | 'icons' | 'cooldowns'>\n\t/** A hero's experience (`HeroSent.xp`) to everyone who sees it. Its side's alone when left out */\n\tshareXp?: HudShareRule<boolean>\n}\n\n/**\n * A unit in a queue, not made yet, as the supply it will take is asked of it (`RuleSettings.supply.of`)\n *\n * @beta\n */\nexport interface QueuedUnit {\n\t/** The unit type being queued */\n\treadonly def: UnitTypeDef\n\t/** The player who queued it */\n\treadonly owner: PlayerId\n\t/** Always true: tells a queued unit from an `Entity` where the supply it takes is asked */\n\treadonly queued: true\n}\n\n/**\n * How the fog of war keeps what was seen (`RuleSettings.fog`)\n *\n * @beta\n */\nexport interface FogSettings {\n\t/** Part of its sight a unit has at night, for types that do not say (`UnitTypeDef.sightNight`) */\n\tnightSight: number\n\t/**\n\t * What is kept of what was seen once: `remembered`, ground drawn dim and buildings as they were last seen (when left\n\t * out); `nothing`, out of sight is as never seen (ground black again, buildings forgotten; building there is still\n\t * allowed)\n\t */\n\texplored?: 'remembered' | 'nothing'\n\t/**\n\t * The whole map explored from the start, the fog over it all the same (as classic RTS melee maps are): the ground drawn\n\t * dim, and what stands on it and belongs to no player (trees, mines, rocks, neutral buildings: shops, taverns, the\n\t * creeps' own) seen from the first moment, as it stood then; units, and players' buildings, only once in sight. A map\n\t * says otherwise (`MapDef.explored`). No when left out\n\t */\n\tstartExplored?: boolean\n\t/** How ground never seen is drawn: `black` (when left out), or `dim` as explored ground is */\n\tmask?: 'black' | 'dim'\n}\n\n/**\n * The numbers and formulas of a kind of game that are not about any one unit: the supply cap, what selling gives\n * back, how a hit is mitigated. In groups, each about one thing: supply, production, the economy, combat, movement,\n * the fog, talk, the camps, heroes, what the HUD is told, the score. A game module changes the ones it wants\n * (`Rules.settings`: any of a group, the rest of it the engine's) and a pack the ones it brings (`GamePack.settings`).\n *\n * Read them from `world.settings` in the simulation, and from `session.registry.settings` on a player's screen.\n *\n * @beta\n */\nexport interface RuleSettings {\n\t/** What armies cost in supply, and how much a player may have (`SupplySettings`) */\n\tsupply: SupplySettings\n\t/** What buildings make and how they go up (`ProductionSettings`) */\n\tproduction: ProductionSettings\n\t/** What is paid back, paid for and given away (`EconomySettings`) */\n\teconomy: EconomySettings\n\t/**\n\t * What a hero may carry and how what it carries works (`ItemSettings`): the limits of groups of items (one pair of\n\t * boots), unique passives counted once, the game's own rule of what may be carried\n\t *\n\t * @beta\n\t */\n\titems: ItemSettings\n\t/**\n\t * Shops (`ShopSettings`): the seconds within which a purchase is taken back\n\t *\n\t * @beta\n\t */\n\tshop: ShopSettings\n\t/** How a hit lands and how much of it is felt, and who fights whom (`CombatSettings`) */\n\tcombat: CombatSettings\n\t/** How units find their way among each other (`MovementSettings`) */\n\tmovement: MovementSettings\n\t/** What is seen and kept of what was (`FogSettings`) */\n\tfog: FogSettings\n\t/** Pings, chat and pauses (`TalkSettings`) */\n\ttalk: TalkSettings\n\t/**\n\t * Creeps' camps (`camps.ts`, `CampSettings`): how far from its centre a camp fights (`leash`), how long a creep chases\n\t * without a blow (`chaseTime`), how long after the last blow the camp goes home (`resetAfter`), whether all of it\n\t * answers a hit at once (`helpAtOnce`), whether creeps sleep at home at night until attacked (`sleep`), and the\n\t * seconds after a camp is cleared that it comes back (`respawn`; never when left out). What makes creeps keep to them,\n\t * sleep and come back is the heroes pack's (`heroesPack`). See docs/creeps.md\n\t */\n\tcamps: CampSettings\n\t/**\n\t * Heroes' numbers (`HeroSettings`): how many a player may have, the experience a level takes, what bringing one back\n\t * costs. The heroes pack's to change (`heroesPack(rules)`); the classic RTS numbers when left out\n\t */\n\theroes: HeroSettings\n\t/**\n\t * What of a unit the players who see it are told beyond what they always are (its health, mana, level, buffs and\n\t * their stacks), for the plates over it to show (indicators-plan U3): the seconds left of its buffs, its abilities,\n\t * a hero's experience. Nothing more than that when left out\n\t *\n\t * @beta\n\t */\n\thud: HudSharing\n\t/**\n\t * What the game counts of its players for its score (a classic RTS score screen): kills, losses, damage, healing,\n\t * resources, its own (`ScoreSettings`, `presetScore()`, `defineStat`). Counted by the rules as the game goes, kept in\n\t * saves, told to the players as it says. Nothing is counted when left out\n\t *\n\t * @beta\n\t */\n\tscore?: ScoreSettings\n\t/**\n\t * Whether a player may command an entity: its owner, and whoever the owner shares control with\n\t * (`world.sides.shareControl`, a force's `sharedControl`), when left out. What every command is checked against, and\n\t * what decides whose units a player is told the own state of (orders, the queue, the bag)\n\t */\n\tmayCommand(world: World, player: PlayerId, entity: Entity): boolean\n}\n\n/**\n * Supply (`RuleSettings.supply`)\n *\n * @beta\n */\nexport interface SupplySettings {\n\t/** Supply no player can go past, however much they build to provide it */\n\tmax: number\n\t/**\n\t * Pools of supply besides the one there always is (`supply`, food), by name, each with what it is called and its\n\t * most: a cap on commanders, on vehicles. A unit takes of one with `supply`, a building provides with\n\t * `supplyGiven`. None when left out\n\t */\n\tpools?: Record<string, { name: string; max: number }>\n\t/**\n\t * Supply a unit takes: summons taking none, an aura that lowers it. Its type's `supply`, when left out. Asked of the\n\t * units there are, and of those in a queue, which are not yet (`QueuedUnit`: their type and owner)\n\t */\n\tof(world: World, unit: Entity | QueuedUnit): number\n}\n\n/**\n * Production and construction (`RuleSettings.production`)\n *\n * @beta\n */\nexport interface ProductionSettings {\n\t/** Things a building can have waiting to be made */\n\tqueue: number\n\t/** Part of what a structure cost that comes back when it is called off while being built */\n\tcancelRefund: number\n\t/** Part of its health a structure starts being built with */\n\tconstructionHealth: number\n\t/** How fast a structure goes up with so many builders at it, as a part of its build time a second: the first builder all of it, every other half, when left out */\n\tbuildRate(world: World, structure: Entity, builders: number): number\n}\n\n/**\n * Selling, repairing, giving and upkeep (`RuleSettings.economy`)\n *\n * @beta\n */\nexport interface EconomySettings {\n\t/** Part of an item's price a shop pays for it */\n\tsellPrice: number\n\t/** Part of what a building cost that mending all of its health costs */\n\trepairCost: number\n\t/** The part of what a player gives an ally that is lost on the way, 0..1 (see `give`). Nothing when left out */\n\ttradeTax: number\n\t/** What a player's army costs them in income. The game's upkeep tiers by supply used, when left out */\n\tupkeep(world: World, player: PlayerId): Upkeep\n}\n\n/**\n * What a hero may carry, and how what it carries works (`RuleSettings.items`)\n *\n * @beta\n */\nexport interface ItemSettings {\n\t/**\n\t * The most of a group of items (`ItemDef.group`) one carrier may have, by group: `{ boots: 1 }` when left out. An\n\t * item's own `groupLimit` comes first; a group named nowhere is 1\n\t */\n\tgroups: Record<string, number>\n\t/** Whether the passives of items sharing a `unique` name work once for all of them (yes), or each (no) */\n\tunique: boolean\n\t/**\n\t * The game's own rule of what a carrier may take, asked after the engine's (a group's limit) as it buys an item, picks\n\t * one up or is handed one: a reason to refuse (a `MessageRef`, told to the player), nothing to let it. `uses` are\n\t * the parts buying it uses up, by id (none for a pick-up or a hand-over). Everything may when left out\n\t */\n\tmayCarry?: (world: World, carrier: Entity, item: ItemDef, uses: readonly string[]) => MessageRef | undefined\n}\n\n/**\n * Shops (`RuleSettings.shop`): taking a purchase back\n *\n * @beta\n */\nexport interface ShopSettings {\n\t/**\n\t * Seconds within which a purchase is undone (`undoBuy`, the `undoBuy` command: the shop window's Undo) for all it\n\t * cost, as long as the buyer stands at the shop still and has not used the item: what it took is given back, the\n\t * parts it used up come back, the shop has it back in stock. 10 when left out; 0 for no undoing\n\t */\n\tundo: number\n}\n\n/**\n * Fighting (`RuleSettings.combat`)\n *\n * @beta\n */\nexport interface CombatSettings {\n\t/**\n\t * Whether a basic attack of `attacker` strikes critically, and what it multiplies the damage by then: a number for a\n\t * critical strike, nothing for none. Asked as the attack goes off, before whether it misses. None when left out (a\n\t * game's crits: `mobaStatsPack`, or its own)\n\t */\n\tcritical(world: World, attacker: Entity, stats: Readonly<Stats>): number | undefined\n\t/**\n\t * What is left of damage once the defences of the target had their say, as a part of it. `source` is the stats\n\t * of whoever deals it, when someone does. Armor and magic resist, with penetration, when left out\n\t */\n\tmitigation(type: DamageType, target: Readonly<Stats>, source?: Readonly<Stats>): number\n\t/**\n\t * What damage is multiplied by once mitigated, before shields, for the stats of who takes it and of who deals it\n\t * (when someone does): their `incomingDamage` (and of the type: `incomingMagicDamage`) and `outgoingDamage`, never\n\t * below none, when left out (`damageScale`)\n\t */\n\tdamageScale(type: DamageType, target: Readonly<Stats>, source?: Readonly<Stats>): number\n\t/**\n\t * What healing is multiplied by, for the stats of who gets it, before the `beforeHeal` hook: its `incomingHealing`,\n\t * never below none, when left out (`healingScale`)\n\t */\n\thealingScale(target: Readonly<Stats>, source?: Readonly<Stats>): number\n\t/**\n\t * Keeps stats within what the game allows, once everything that changes them was added up. Changes them in place.\n\t * The default keeps attack speed within its limits (below)\n\t */\n\tclampStats(stats: Stats, rules: Readonly<RuleSettings>): void\n\t/** Seconds an ability takes to be ready again, for a unit with these stats. Its cooldown as it is, when left out */\n\tcooldown(seconds: number, stats: Readonly<Stats>): number\n\t/**\n\t * How much of a slow a unit with these stats takes: `slow` is what slows it, added up, below 0 (-0.3 for 30% slower).\n\t * All of it, when left out\n\t */\n\tslowTaken(stats: Readonly<Stats>, slow: number): number\n\t/** What the heals and shields `source` gives are multiplied by. 1, when left out */\n\thealPower(world: World, source: Entity): number\n\t/**\n\t * What a blow from up close of `attacker`'s weapon at that place cleaves: the part of its damage the enemies round\n\t * `target` take, how far round it, how wide a cone. Its attack's own or a buff's, the larger part, when left out\n\t * (`cleaveOf`); nothing for none\n\t */\n\tcleave(world: World, attacker: Entity, target: Entity, weapon: number): CleaveNow | undefined\n\t/**\n\t * Which of what an attack of `attacker` sets off go off (its attack modifiers: the `onHit` of its abilities, items\n\t * and buffs that can now), of those it is given, in their order. One a slot, the highest `priority`, and all of\n\t * those of no slot, when left out (`bySlot`); `(world, attacker, target, modifiers) => modifiers` for all of them\n\t */\n\tattackModifiers(world: World, attacker: Entity, target: Entity, modifiers: readonly AttackModifier[]): readonly AttackModifier[]\n\t/** Nobody attacks slower or faster than this, whatever they carry: [lowest, highest] attack speed */\n\tattackSpeedLimits: [number, number]\n\t/** Seconds a corpse lies where a unit of flesh died, for spells to use (see `raiseDead`). None at all for 0 */\n\tcorpseTime: number\n\t/** The chance, 0..1, that an attack of `attacker` at `target` goes wide. A quarter up a cliff, when left out */\n\tmissChance(world: World, attacker: Entity, target: Entity): number\n\t/**\n\t * What part of an attack that hits an area an entity standing there gets, 0..1: 0 spares it. `source` is who fired\n\t * it, `distance` how far from the middle the entity is. Everyone there but whoever fired it, all of it in the inner\n\t * half and half outside, when left out\n\t */\n\tsplash(world: World, source: Entity | undefined, other: Entity, distance: number, radius: number): number\n\t/** How far a unit looks for enemies by itself, and chases them. The farthest `acquisitionRange` of its attacks, when left out */\n\tacquisitionRange(world: World, entity: Entity): number\n\t/**\n\t * Which of its attacks (`UnitTypeDef.attacks`, by place) an attacker uses against a target, or -1 for none: it cannot\n\t * attack it. The first whose `targets` reach the target where it is, when left out (`defaultPickAttack`): a siege\n\t * weapon for what is on the ground, a second for the air. Asked for every target looked at: keep it cheap\n\t */\n\tpickAttack(world: World, attacker: Entity, target: Entity): number\n\t/**\n\t * The layer an attacker fights from, around a target: room is counted apart for each (see `engageRoom`). The air\n\t * for what flies, the water for boats, the ground for the rest, when left out; any name of the game's own besides\n\t */\n\tengageLayer(world: World, attacker: Entity): string\n\t/**\n\t * How many attackers like this one (of its layer, reaching as far) may fight a target at once. A full target is\n\t * picked last, and the melee spread around it on as many spots. As many as stand side by side around it, out where\n\t * they reach, when left out: few for swords around a footman, all of them for long guns\n\t */\n\tengageRoom(world: World, target: Entity, attacker: Entity): number\n\t/**\n\t * Seconds a unit that picked a target by itself closes in on it without getting closer before it lets it go and\n\t * fights something else (blocked by its own in a pass, say). A target it was told to attack it never lets go. One,\n\t * when left out; Infinity never\n\t */\n\tgiveUpChase(world: World, attacker: Entity, target: Entity): number\n\t/**\n\t * How far from the middle of a target an attacker waits for room there, when it was told to attack it and it has no\n\t * room for it or no way to it (`holdOff`): on its own side, out of the way of those fighting it. Just behind them\n\t * when left out (`defaultQueueDistance`): the target's size, two of the attacker, its reach and half a cell\n\t */\n\tqueueDistance(world: World, attacker: Entity, target: Entity): number\n\t/**\n\t * Whether an order given to a unit in the recovery after its blow (`AttackDef.recovery`) cuts the recovery short and\n\t * is carried out at once. Nothing is given back of the attack: its cooldown runs on. Never, when left out: the order\n\t * waits until the recovery is over\n\t */\n\trecoveryCancels(world: World, entity: Entity): boolean\n\t/**\n\t * How far from an ally that is hit an idle unit of the same owner comes to its help: it takes the attacker, as a\n\t * camp's creeps do (`helpAtOnce`). Asked of each helper, with the ally hit: how far apart they are (centre to centre)\n\t * it must be at most. Never more than `HELP_SEARCH` (20) is looked for. 0 turns it off. The helper's acquisition range\n\t * and 4 more, when left out\n\t */\n\thelpRange(world: World, helper: Entity, victim: Entity): number\n}\n\n/**\n * How units move among each other (`RuleSettings.movement`)\n *\n * @beta\n */\nexport interface MovementSettings {\n\t/**\n\t * Whether an ally standing in the way of a unit on its way steps aside when asked (see `makeWay`). Those standing\n\t * about with nothing to do, or waiting by a fight for a spot in it, when left out: not those fighting, walking or\n\t * with orders of their own\n\t */\n\tmakesWay(world: World, mover: Entity, other: Entity): boolean\n\t/**\n\t * How far ahead, in ground units, a unit on its way looks for others standing in it, to go round them\n\t * (`goesAround`) or, where it cannot, ask them to step aside (`makesWay`) before it reaches them. 0 looks no\n\t * further than its nose: it then goes round nothing, and asks only once it is held up. 3 when left out\n\t */\n\tlookAhead(world: World, mover: Entity): number\n\t/**\n\t * Whether a unit goes round the units standing in its way (`around`), where the way round is `longer` ground units\n\t * more than the `straight` way to the next corner of its path, rather than through them, which slows it until they\n\t * step aside or it has pushed past. Yes for up to a unit and a half more, and a quarter of the straight way, when\n\t * left out. Where the way round is found is the `detour` hook's\n\t */\n\tgoesAround(world: World, mover: Entity, around: readonly Entity[], longer: number, straight: number): boolean\n\t/**\n\t * Whether a group sent somewhere with a right-click moves at the pace of its slowest (`OrderParams.together`), so\n\t * that it arrives together: no when left out, each at its own speed. Attack-moves are each at their own always\n\t */\n\ttogether?: boolean\n\t/**\n\t * The formation units ordered to a point together take, by id (`FormationDef`), where the order names none\n\t * (`OrderInit.formation`): `rows` when left out, which keeps a tight group's shape and lines a scattered one up\n\t */\n\tformation(world: World, units: readonly Entity[], init: OrderInit): string\n\t/**\n\t * How fast a unit goes where it is, from its `moveSpeed`: slower in shallow water, faster on roads. Asked every\n\t * tick for every unit that moves: keep it cheap. Its speed as it is, when left out\n\t */\n\tmoveSpeed(world: World, entity: Entity, speed: number): number\n\t/**\n\t * How fast a unit turns, in radians a second, where its type says nothing of its own (`UnitTypeDef.turnRate`): on\n\t * its way, to face what it attacks, works on or casts at. 12 when left out, which is all but at once (a half turn\n\t * in a quarter of a second); 2 or 3 for units that visibly come round, as a classic RTS's do, less for ships\n\t */\n\tturnRate: number\n}\n\n/**\n * Pings, chat and pauses (`RuleSettings.talk`)\n *\n * @beta\n */\nexport interface TalkSettings {\n\t/**\n\t * Pings (see `ping`): how many a player may send `within` so many seconds, the kinds there are (a hero arena game's\n\t * when left out; a game adds its own), and what each kind asks of a computer ally (indicators-plan P4): a request on\n\t * its team's board (`help`, which computers answer by sending fighters; `attack`, `defend` and `rally`, put on the\n\t * board for the brains that read them), or nothing. A kind not named is heard and not acted on. `kinds` may be\n\t * worked out from the registry as the game plays (`(registry) => …`): from a file of the game's (`registry.file`),\n\t * one the editor writes, so a kind added there is let go at once (see `pingKinds`)\n\t */\n\tpings: {\n\t\tmost: number\n\t\twithin: number\n\t\tkinds: readonly string[] | ((registry: Registry) => readonly string[])\n\t\tmeanings: Readonly<Record<string, 'help' | 'attack' | 'defend' | 'rally' | 'ignore'>>\n\t}\n\t/** Lines of chat: how many a player may send `within` so many seconds, and how long one may be */\n\tlines: { most: number; within: number; length: number }\n\t/** Pauses in a game on a server (see `askPause`): how many each player may ask for (none at 0), and how many seconds one lasts at most */\n\tpauses: { each: number; seconds: number }\n}\n\n/**\n * The engine's rules: those of a classic RTS melee game\n *\n * @beta\n */\nexport const defaultSettings: Readonly<RuleSettings> = Object.freeze({\n\tsupply: {\n\t\tmax: 100,\n\t\t// none besides food: a game names its own\n\t\tpools: undefined,\n\t\tof: (_world: World, unit: Entity | QueuedUnit) => supplyOf(unit.def)\n\t},\n\tproduction: {\n\t\tqueue: 7,\n\t\tcancelRefund: 0.75,\n\t\tconstructionHealth: 0.1,\n\t\tbuildRate: (_world: World, _structure: Entity, builders: number) => 1 + (builders - 1) * 0.5\n\t},\n\teconomy: {\n\t\tsellPrice: 0.7,\n\t\trepairCost: 0.35,\n\t\ttradeTax: 0,\n\t\tupkeep: (world: World, player: PlayerId) => upkeepOf(world, player)\n\t},\n\t// one pair of boots a hero, a unique passive once\n\titems: { groups: { boots: 1 }, unique: true, mayCarry: undefined },\n\t// a purchase is taken back within ten seconds\n\tshop: { undo: 10 },\n\tcombat: {\n\t\tcritical: () => undefined,\n\t\tmitigation,\n\t\tdamageScale,\n\t\thealingScale,\n\t\tclampStats(stats: Stats, rules: Readonly<RuleSettings>) {\n\t\t\tconst { attackSpeedLimits } = rules.combat\n\t\t\tif (stats.attackSpeed > 0) stats.attackSpeed = clamp(stats.attackSpeed, attackSpeedLimits[0], attackSpeedLimits[1])\n\t\t},\n\t\tcooldown: (seconds: number) => seconds,\n\t\tslowTaken: (_stats: Readonly<Stats>, slow: number) => slow,\n\t\thealPower: () => 1,\n\t\tcleave: cleaveOf,\n\t\tattackModifiers: bySlot,\n\t\tattackSpeedLimits: [0.1, 5] as [number, number],\n\t\tcorpseTime: 60,\n\t\tmissChance: (world: World, attacker: Entity, target: Entity) => (shootsUphill(world, attacker, target) ? UPHILL_MISS : 0),\n\t\tsplash: (_world: World, source: Entity | undefined, other: Entity, distance: number, radius: number) =>\n\t\t\tother === source ? 0 : distance <= radius / 2 ? 1 : 0.5,\n\t\tacquisitionRange: (_world: World, entity: Entity) => farthestAcquisition(entity.def),\n\t\tpickAttack: defaultPickAttack,\n\t\tengageLayer: defaultEngageLayer,\n\t\tengageRoom: defaultEngageRoom,\n\t\tgiveUpChase: () => 1,\n\t\tqueueDistance: defaultQueueDistance,\n\t\trecoveryCancels: () => false,\n\t\thelpRange: (world: World, helper: Entity) => world.settings.combat.acquisitionRange(world, helper) + 4\n\t},\n\tmovement: {\n\t\tmakesWay: (world: World, _mover: Entity, other: Entity) =>\n\t\t\tother.get(moving)?.status !== 'moving' && !other.get(moving)?.anchored && (other.orders.length === 0 || orderSays(world, other, 'waiting')),\n\t\tlookAhead: () => 3,\n\t\tgoesAround: (_world: World, _mover: Entity, _around: readonly Entity[], longer: number, straight: number) => longer <= 1.5 + straight * 0.25,\n\t\tformation: () => 'rows',\n\t\t// slowed by the ground it stands on (a tile's or a layer of cells' `speed`), unless it flies or sails\n\t\tmoveSpeed: (world: World, entity: Entity, speed: number) => speed * groundSpeedAt(world, entity),\n\t\tturnRate: 12,\n\t\ttogether: false\n\t},\n\tfog: { nightSight: 0.6, explored: undefined, startExplored: undefined, mask: undefined },\n\ttalk: {\n\t\tpings: {\n\t\t\tmost: 4,\n\t\t\twithin: 5,\n\t\t\tkinds: ['look', 'danger', 'assist', 'onMyWay'],\n\t\t\tmeanings: { danger: 'help', assist: 'help', push: 'attack', hold: 'defend', retreat: 'rally' } as TalkSettings['pings']['meanings']\n\t\t},\n\t\tlines: { most: 5, within: 5, length: 160 },\n\t\tpauses: { each: 3, seconds: 60 }\n\t},\n\t// creeps fight up to 14 cells from their camp, let a chase go after 5 seconds without a blow, go home 6 seconds after\n\t// the last, come all at once; they sleep at night, and a camp cleared stays cleared, as in classic RTS games\n\tcamps: { leash: 14, chaseTime: 5, resetAfter: 6, helpAtOnce: true, sleep: true, respawn: undefined },\n\theroes: defaultHeroSettings,\n\t// what everyone who sees a unit is told and no more\n\thud: {},\n\tscore: undefined,\n\tmayCommand: (world: World, player: PlayerId, entity: Entity) => entity.owner === player || world.sides.controlOf(entity.owner).includes(player)\n})\n\n/**\n * Creeps' camps' rules (`RuleSettings.camps`)\n *\n * @beta\n */\nexport interface CampSettings {\n\t/**\n\t * How far from the camp's centre its creeps fight, in cells: what goes past it is let go of, and a creep led past it\n\t * turns back. 14 by default. A camp's own is `Camp.leash` (`spawnCamp`'s `leash`)\n\t */\n\tleash: number\n\t/**\n\t * Seconds a creep chases what has neither hit it nor been hit by it before it lets it go for the next of the camp's\n\t * list (`Camp.aggro`): a kiting archer is not followed round the camp for ever. 5 by default. A camp's own is\n\t * `Camp.chaseTime`\n\t */\n\tchaseTime: number\n\t/**\n\t * Seconds without a blow (none of the camp's creeps hitting or hit) before the camp gives up the fight and goes home:\n\t * until then its creeps wait where they stand for what comes next. 6 by default. A camp's own is `Camp.resetAfter`;\n\t * `resetCamp` sends one home now\n\t */\n\tresetAfter: number\n\t/**\n\t * Whether every creep of a camp answers a hit on one of them at once, as it lands, rather than at its next look round\n\t * (every fourth tick). True by default. A camp's own is `Camp.helpAtOnce`\n\t */\n\thelpAtOnce: boolean\n\t/** Whether creeps sleep at home at night, until attacked */\n\tsleep: boolean\n\t/** Seconds after a camp is cleared that it comes back, for every camp (see `Camp.respawn`). Never when left out */\n\trespawn?: number\n}\n\n/** What is said of a group of the rules: any of it, a group in it in part as well. A function, a list and a table whole */\nexport type SettingsPart<T> = T extends (...args: never[]) => unknown\n\t? T\n\t: T extends readonly unknown[]\n\t\t? T\n\t\t: T extends object\n\t\t\t? { [K in keyof T]?: SettingsPart<T[K]> }\n\t\t\t: T\n\n/**\n * What a game says of its rules (`Rules.settings`), or a pack (`GamePack.settings`): any of them, a group in part\n * (`{ supply: { max: 200 } }`), the engine's for the rest. The score and the HUD's sharing are\n * given whole\n *\n * @beta\n */\nexport type RuleSettingsInit = { [K in Exclude<keyof RuleSettings, 'score' | 'hud'>]?: SettingsPart<RuleSettings[K]> } & {\n\tscore?: ScoreSettings\n\thud?: HudSharing\n}\n\n/** Whether a value is a group of the rules to be laid over in part: a plain object of named parts, not a table or a list */\nconst isGroup = (value: unknown): value is Record<string, unknown> =>\n\ttypeof value === 'object' && value !== null && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype\n\n/**\n * Lays what is said of rules over rules, group by group: a group of named parts (`supply`, `talk.pings`) part by part,\n * everything else whole. A name the rules have not got is refused: a typo would otherwise change nothing, without a word\n *\n * @internal\n */\nexport function laySettings<T extends object>(under: T, over: object, path = ''): T {\n\tconst laid: Record<string, unknown> = { ...(under as Record<string, unknown>) }\n\tfor (const [key, value] of Object.entries(over)) {\n\t\tif (value === undefined) continue\n\t\tif (!(key in under)) throw new Error(`\"${path}${key}\" is not a game rule`)\n\t\tconst before = (under as Record<string, unknown>)[key]\n\t\tlaid[key] = isGroup(before) && Object.keys(before).length && isGroup(value) ? laySettings(before, value, `${path}${key}.`) : value\n\t}\n\treturn laid as T\n}\n\n/**\n * What is said of rules laid over what was said before (a pack's over the game's, a mod's over the game's), group by\n * group as `laySettings` does, neither of them whole\n *\n * @internal\n */\nexport function overSettings(under: RuleSettingsInit, over: RuleSettingsInit): RuleSettingsInit {\n\tconst laid: Record<string, unknown> = { ...under }\n\tfor (const [key, value] of Object.entries(over)) {\n\t\tif (value === undefined) continue\n\t\tconst before = laid[key]\n\t\tlaid[key] = isGroup(before) && isGroup(value) ? overSettings(before as RuleSettingsInit, value as RuleSettingsInit) : value\n\t}\n\treturn laid as RuleSettingsInit\n}\n\n/**\n * The names of the rules what is said of them changes, group by group (`supply.max`, `talk.pings.most`): what two\n * mods are found to both change by\n *\n * @internal\n */\nexport function rulesSaid(said: object, path = ''): string[] {\n\treturn Object.entries(said).flatMap(([key, value]) =>\n\t\tvalue === undefined ? [] : isGroup(value) && Object.keys(value).length ? rulesSaid(value, `${path}${key}.`) : [`${path}${key}`]\n\t)\n}\n\n/**\n * The rules of a game: what its module changes, over the engine's\n *\n * @internal\n */\nexport function resolveSettings(changes: RuleSettingsInit = {}): Readonly<RuleSettings> {\n\treturn Object.freeze(laySettings(defaultSettings, changes))\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AA0bA,IAAa,kBAA0C,OAAO,OAAO;CACpE,QAAQ;EACP,KAAK;EAEL,OAAO,KAAA;EACP,KAAK,QAAe,SAA8B,SAAS,KAAK,GAAG;CACpE;CACA,YAAY;EACX,OAAO;EACP,cAAc;EACd,oBAAoB;EACpB,YAAY,QAAe,YAAoB,aAAqB,KAAK,WAAW,KAAK;CAC1F;CACA,SAAS;EACR,WAAW;EACX,YAAY;EACZ,UAAU;EACV,SAAS,OAAc,WAAqB,SAAS,OAAO,MAAM;CACnE;CAEA,OAAO;EAAE,QAAQ,EAAE,OAAO,EAAE;EAAG,QAAQ;EAAM,UAAU,KAAA;CAAU;CAEjE,MAAM,EAAE,MAAM,GAAG;CACjB,QAAQ;EACP,gBAAgB,KAAA;EAChB;EACA;EACA;EACA,WAAW,OAAc,OAA+B;GACvD,MAAM,EAAE,sBAAsB,MAAM;GACpC,IAAI,MAAM,cAAc,GAAG,MAAM,cAAc,MAAM,MAAM,aAAa,kBAAkB,IAAI,kBAAkB,EAAE;EACnH;EACA,WAAW,YAAoB;EAC/B,YAAY,QAAyB,SAAiB;EACtD,iBAAiB;EACjB,QAAQ;EACR,iBAAiB;EACjB,mBAAmB,CAAC,IAAK,CAAC;EAC1B,YAAY;EACZ,aAAa,OAAc,UAAkB,WAAoB,aAAa,OAAO,UAAU,MAAM,IAAI,cAAc;EACvH,SAAS,QAAe,QAA4B,OAAe,UAAkB,WACpF,UAAU,SAAS,IAAI,YAAY,SAAS,IAAI,IAAI;EACrD,mBAAmB,QAAe,WAAmB,oBAAoB,OAAO,GAAG;EACnF,YAAY;EACZ,aAAa;EACb,YAAY;EACZ,mBAAmB;EACnB,eAAe;EACf,uBAAuB;EACvB,YAAY,OAAc,WAAmB,MAAM,SAAS,OAAO,iBAAiB,OAAO,MAAM,IAAI;CACtG;CACA,UAAU;EACT,WAAW,OAAc,QAAgB,UACxC,MAAM,IAAI,MAAM,CAAC,EAAE,WAAW,YAAY,CAAC,MAAM,IAAI,MAAM,CAAC,EAAE,aAAa,MAAM,OAAO,WAAW,KAAK,UAAU,OAAO,OAAO,SAAS;EAC1I,iBAAiB;EACjB,aAAa,QAAe,QAAgB,SAA4B,QAAgB,aAAqB,UAAU,MAAM,WAAW;EACxI,iBAAiB;EAEjB,YAAY,OAAc,QAAgB,UAAkB,QAAQ,cAAc,OAAO,MAAM;EAC/F,UAAU;EACV,UAAU;CACX;CACA,KAAK;EAAE,YAAY;EAAK,UAAU,KAAA;EAAW,eAAe,KAAA;EAAW,MAAM,KAAA;CAAU;CACvF,MAAM;EACL,OAAO;GACN,MAAM;GACN,QAAQ;GACR,OAAO;IAAC;IAAQ;IAAU;IAAU;GAAS;GAC7C,UAAU;IAAE,QAAQ;IAAQ,QAAQ;IAAQ,MAAM;IAAU,MAAM;IAAU,SAAS;GAAQ;EAC9F;EACA,OAAO;GAAE,MAAM;GAAG,QAAQ;GAAG,QAAQ;EAAI;EACzC,QAAQ;GAAE,MAAM;GAAG,SAAS;EAAG;CAChC;CAGA,OAAO;EAAE,OAAO;EAAI,WAAW;EAAG,YAAY;EAAG,YAAY;EAAM,OAAO;EAAM,SAAS,KAAA;CAAU;CACnG,QAAQ;CAER,KAAK,CAAC;CACN,OAAO,KAAA;CACP,aAAa,OAAc,QAAkB,WAAmB,OAAO,UAAU,UAAU,MAAM,MAAM,UAAU,OAAO,KAAK,CAAC,CAAC,SAAS,MAAM;AAC/I,CAAC;;AA0DD,IAAM,WAAW,UAChB,OAAO,UAAU,YAAY,UAAU,QAAQ,CAAC,MAAM,QAAQ,KAAK,KAAK,OAAO,eAAe,KAAK,MAAM,OAAO;;;;;;;AAQjH,SAAgB,YAA8B,OAAU,MAAc,OAAO,IAAO;CACnF,MAAM,OAAgC,EAAE,GAAI,MAAkC;CAC9E,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,IAAI,GAAG;EAChD,IAAI,UAAU,KAAA,GAAW;EACzB,IAAI,EAAE,OAAO,QAAQ,MAAM,IAAI,MAAM,IAAI,OAAO,IAAI,qBAAqB;EACzE,MAAM,SAAU,MAAkC;EAClD,KAAK,OAAO,QAAQ,MAAM,KAAK,OAAO,KAAK,MAAM,CAAC,CAAC,UAAU,QAAQ,KAAK,IAAI,YAAY,QAAQ,OAAO,GAAG,OAAO,IAAI,EAAE,IAAI;CAC9H;CACA,OAAO;AACR;;;;;;;AAQA,SAAgB,aAAa,OAAyB,MAA0C;CAC/F,MAAM,OAAgC,EAAE,GAAG,MAAM;CACjD,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,IAAI,GAAG;EAChD,IAAI,UAAU,KAAA,GAAW;EACzB,MAAM,SAAS,KAAK;EACpB,KAAK,OAAO,QAAQ,MAAM,KAAK,QAAQ,KAAK,IAAI,aAAa,QAA4B,KAAyB,IAAI;CACvH;CACA,OAAO;AACR;;;;;;;AAQA,SAAgB,UAAU,MAAc,OAAO,IAAc;CAC5D,OAAO,OAAO,QAAQ,IAAI,CAAC,CAAC,SAAS,CAAC,KAAK,WAC1C,UAAU,KAAA,IAAY,CAAC,IAAI,QAAQ,KAAK,KAAK,OAAO,KAAK,KAAK,CAAC,CAAC,SAAS,UAAU,OAAO,GAAG,OAAO,IAAI,EAAE,IAAI,CAAC,GAAG,OAAO,KAAK,CAC/H;AACD;;;;;;AAOA,SAAgB,gBAAgB,UAA4B,CAAC,GAA2B;CACvF,OAAO,OAAO,OAAO,YAAY,iBAAiB,OAAO,CAAC;AAC3D"}

package/dist/rulesCheck.d.ts

@@ -1,5 +1,5 @@
 import { type DataKind } from './gameData';
-import type { GameModule } from './game';
+import type { Rules } from './game';
 /**
  * What of a game's rules does not fit together (`checkRules`): an id that names nothing (an ability's buff, a unit's
  * `trains`, an upgrade's `requires`, a shop's items), an effect of a type nobody handles, requirements that wait on
@@ -16,6 +16,7 @@ export interface RulesProblem {
     where: string;
     /** The id that is wrong, or the definition the warning is about */
     id: string;
+    /** What is wrong, in words for the person writing the rules */
     message: string;
     /**
      * The definition it is in and the field, as the editor's Data panel names them (`{ kind: 'abilities', id:
@@ -28,10 +29,10 @@ export interface RulesProblem {
     };
 }
 /**
- * Checks a game's rules against themselves (`RulesProblem`): run by `defineGame` with the view's checks, and in a
+ * Checks a game's rules against themselves (`RulesProblem`): run by a game's `check()` and as a page fetches its view, and in a
  * game's tests (`expect(checkRules(rules).filter((p) => p.level === 'error')).toEqual([])`). Nothing is thrown
  *
- * @beta
+ * @public
  */
-export declare function checkRules(rules: GameModule): RulesProblem[];
+export declare function checkRules(rules: Rules): RulesProblem[];
 export { editDistance } from './nearest';