@v12-engine/engine 0.1.1 → 0.4.0

package/dist/defs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"defs.js","names":[],"sources":["../src/defs.ts"],"sourcesContent":["import type { AbilityAiView } from './ai/micro'\nimport type { AiHints } from './ai/roles'\nimport type { AbilityTextContext, AbilityValueDef, CasterFacts, TextSegment } from './abilities/text'\nimport type { EffectContext } from './abilities/effects'\nimport type { EntityState } from './session/protocol'\n/**\n * Static game data. Everything a game module (melee, custom map, mod) defines about\n * its units lives in plain objects like these, the engine never hardcodes a unit.\n */\n\nimport type { RuleSettings } from './rules'\nimport type { AbilityState, BuffInstance, Entity } from './entity'\nimport type { Vec2 } from './math'\nimport type { World } from './world'\nimport type { BurnsDef } from './burning'\n\n/**\n * A value that can grow with the level of an ability: one number, or one per level\n *\n * @beta\n */\nexport type Scaled = number | number[]\n\n/**\n * What an amount in code is asked with (`EffectValue`): the ability's level and what the caster brings now, and the effect\n * as it lands, where it is landing. The tooltip asks it too (`abilityValues`), with no `effect` and no target\n *\n * @beta\n */\nexport interface EffectValueContext {\n\t/** The level of the ability */\n\tlevel: number\n\t/** What the caster brings to the numbers now: its stats, its level as a hero (`casterFacts`) */\n\tcaster: CasterFacts\n\t/** The effect as it lands: the world, the caster, where, how far a missile came. Not there for the tooltip */\n\teffect?: EffectContext\n}\n\n/**\n * An amount, a time or a size of an effect: a number, one per level (`Scaled`), or worked out in code for each target as\n * it lands (`(context, target) => number`: a share of what the target lacks, more for each mark on it, by how far it\n * flew). Code is asked with no target where the effect is not for one (a zone's time, an area's size) and by the\n * tooltip; what the screen draws before a cast (the aim) has no caster to ask, and takes `AbilityDef.aim`\n *\n * @beta\n */\nexport type EffectValue = Scaled | ((context: EffectValueContext, target?: Entity) => number)\n\n/**\n * The value at a level. Levels past the end of the list get the last one\n *\n * @beta\n */\nexport function at(value: Scaled | undefined, level: number, fallback = 0): number {\n\tif (value === undefined) return fallback\n\tif (typeof value === 'number') return value\n\treturn value[Math.min(Math.max(level, 1), value.length) - 1] ?? fallback\n}\n\n/**\n * The value of an amount where there is no caster to ask its code (`EffectValue`): at the level, or `fallback` for code.\n * What the aim the screen draws and a computer player's guesses go by\n *\n * @beta\n */\nexport function declaredAt(value: EffectValue | undefined, level: number, fallback = 0): number {\n\treturn typeof value === 'function' ? fallback : at(value, level, fallback)\n}\n\n/**\n * The stats the engine reads: what a unit has of health, mana and their regeneration, how it moves, sees and attacks,\n * and its armor and magic resist (the two kinds of damage there are besides true). Levels, items, buffs and research\n * change them. A game adds stats of its own with `Rules.stats`, a pack its own (`GamePack.stats`: the MOBA\n * stats of `mobaStatsPack`).\n *\n * @beta\n */\nexport interface CoreStats {\n\t// ---- offense\n\t/** What a basic attack deals, before the armor of the target */\n\tattackDamage: number\n\t/** Attacks per second */\n\tattackSpeed: number\n\t/** Measured between the edges of attacker and target */\n\tattackRange: number\n\n\t// ---- defense\n\t/** The most health a unit has; the entity's `maxHealth` follows it */\n\thealth: number\n\t/** Against physical damage: 100 of it halve what arrives */\n\tarmor: number\n\t/** The same against magic damage */\n\tmagicResist: number\n\t/**\n\t * Part by which the damage it takes is more or less, after armor or magic resist and before shields: -0.3 takes 30%\n\t * less, 0.2 a fifth more. Added up with the part of the damage's own type (below), and never below none\n\t */\n\tincomingDamage: number\n\t/** The same, of physical damage only, on top of `incomingDamage` */\n\tincomingPhysicalDamage: number\n\t/** The same, of magic damage only, on top of `incomingDamage` */\n\tincomingMagicDamage: number\n\t/** The same, of true damage only, on top of `incomingDamage` */\n\tincomingTrueDamage: number\n\t/**\n\t * Part by which all the damage it deals, of attacks and abilities, is more or less: -0.35 deals 35% less. Never below\n\t * none\n\t */\n\toutgoingDamage: number\n\t/** Part by which the healing it gets is more or less: -0.4 heals 40% less (an anti-heal). Never below none */\n\tincomingHealing: number\n\n\t// ---- sustain and resources\n\t/** Per second */\n\thealthRegen: number\n\t/** The most mana a unit has */\n\tmana: number\n\t/** Per second */\n\tmanaRegen: number\n\n\t// ---- utility\n\t/** Units per second. Who has none cannot move */\n\tmoveSpeed: number\n\t/** How far it sees. At night the unit type says how far that is */\n\tsight: number\n}\n\n/**\n * The name of one of the engine's stats\n *\n * @internal\n */\nexport type CoreStatKey = keyof CoreStats\n\n/**\n * All of a unit's stats: the engine's, and the game's own by their ids\n *\n * @beta\n */\nexport type Stats = CoreStats & Record<string, number>\n\n/**\n * A stat: one of the engine's (`CoreStatKey`), or one a game defined. Checked when the game is built\n *\n * @beta\n */\nexport type StatKey = string\n\n/**\n * A stat of a game's own, next to the engine's\n *\n * @beta\n */\nexport interface StatDef {\n\t/** The stat's id, which units, changes and abilities name it by */\n\tid: string\n\t/** What the player sees the stat called */\n\tname: string\n\t/** Shown when the pointer is over it */\n\tdescription?: string\n\t/** What every unit has of it unless its type says. 0 when left out */\n\tdefault?: number\n\t/** It never goes below or above these, whatever changes it */\n\tmin?: number\n\t/** The highest the stat goes, whatever changes it; no upper bound when left out */\n\tmax?: number\n\t/** How it is shown: a whole number, a decimal, or a part of one as a percentage. A whole number when left out */\n\tformat?: 'number' | 'decimal' | 'percent'\n}\n\n/**\n * The keys of the engine's stats, in the order `CoreStats` lists them\n *\n * @internal\n */\nexport const CORE_STAT_KEYS: CoreStatKey[] = [\n\t'attackDamage',\n\t'attackSpeed',\n\t'attackRange',\n\t'health',\n\t'armor',\n\t'magicResist',\n\t'incomingDamage',\n\t'incomingPhysicalDamage',\n\t'incomingMagicDamage',\n\t'incomingTrueDamage',\n\t'outgoingDamage',\n\t'incomingHealing',\n\t'healthRegen',\n\t'mana',\n\t'manaRegen',\n\t'moveSpeed',\n\t'sight'\n]\n\n/**\n * Gives a `CoreStats` with every stat at 0\n *\n * @beta\n */\nexport const noStats = (): CoreStats => ({\n\tattackDamage: 0,\n\tattackSpeed: 0,\n\tattackRange: 0,\n\thealth: 0,\n\tarmor: 0,\n\tmagicResist: 0,\n\tincomingDamage: 0,\n\tincomingPhysicalDamage: 0,\n\tincomingMagicDamage: 0,\n\tincomingTrueDamage: 0,\n\toutgoingDamage: 0,\n\tincomingHealing: 0,\n\thealthRegen: 0,\n\tmana: 0,\n\tmanaRegen: 0,\n\tmoveSpeed: 0,\n\tsight: 0\n})\n\n/**\n * How the days go by. Hours run from 0 to 24\n *\n * @beta\n */\nexport interface DayCycle {\n\t/** Seconds a whole day and night take */\n\tlength: number\n\t/** Hour of the day the game starts at */\n\tstart: number\n\t/** Hour the sun comes up */\n\tdawn: number\n\t/** Hour it goes down */\n\tdusk: number\n}\n\n/**\n * Hour of the day after so many seconds of play. Noon in a game without days\n *\n * @beta\n */\nexport function hourOf(day: DayCycle | null, seconds: number): number {\n\tif (!day) return 12\n\treturn (day.start + (seconds / day.length) * 24) % 24\n}\n\n/**\n * Whether the hour (0..24) is night under the day cycle, before its dawn or from its dusk; never night without a day cycle\n *\n * @beta\n */\nexport const isNight = (day: DayCycle | null, hour: number): boolean => !!day && (hour < day.dawn || hour >= day.dusk)\n\n/**\n * Something that changes stats: `stats` is added, `percent` makes them bigger or smaller by a part of what\n * they are with everything added. Parts from different places add up: two times +10% are +20%.\n *\n * @beta\n */\nexport interface StatChange {\n\t/** Amounts added to stats, by stat */\n\tstats?: Partial<Stats>\n\t/** Parts stats grow or shrink by, by stat: 0.1 is 10% more, and the parts add up before they are applied */\n\tpercent?: Partial<Stats>\n}\n\n/**\n * A change that grows with the level of the ability it comes from\n *\n * @beta\n */\nexport interface ScaledStatChange {\n\t/** Amounts added to stats, by stat, each growing with the ability's level */\n\tstats?: Partial<Record<StatKey, Scaled>>\n\t/** Parts stats grow or shrink by, by stat, each growing with the ability's level */\n\tpercent?: Partial<Record<StatKey, Scaled>>\n}\n\n/**\n * Physical damage is held off by armor, magic damage by magic resist, true damage by nothing\n *\n * @beta\n */\nexport type DamageType = 'physical' | 'magic' | 'true'\n\n/**\n * What makes a unit a hero: it gains levels, grows with them and learns abilities\n *\n * @beta\n */\nexport interface HeroDef {\n\t/** What every level after the first adds */\n\tgrowth: StatChange\n\t/** Abilities the hero can put points into */\n\tlearns: string[]\n\t/** Abilities it has from the start and does not learn: the two spells every hero brings along. No mana, and nothing shortens their cooldown */\n\tspells?: string[]\n\t/**\n\t * Its innate: an ability it has from level 1, for no point, that grows with it: its level is the hero's (up to the\n\t * ability's own `maxLevel` where it says one), or goes up at the hero levels of `innateLevels`. A passive most often\n\t * (its buffs, its triggers), or one it casts\n\t *\n\t * @beta\n\t */\n\tinnate?: string\n\t/**\n\t * The hero levels its innate goes up a level at, from its first: `[1, 6, 11, 16]` has it at level 2 from the hero's\n\t * sixth. The hero's own level, when left out\n\t *\n\t * @beta\n\t */\n\tinnateLevels?: number[]\n\t/**\n\t * What it is good at, by calling (`CallingDef`, the game's: `heroesPack({ callings })`), each with a strength from 1\n\t * to 3: `{ stalker: 3, roamer: 2 }`. They lock nothing: the shop's suggestions and filters, the tooltips and the\n\t * computer players go by them\n\t *\n\t * @beta\n\t */\n\tcallings?: Record<string, 1 | 2 | 3>\n\t/** The level it stops at. 10 when left out */\n\tmaxLevel?: number\n\t/** A buff whose stacks are shown next to its health and mana, as so many points out of as many as it can have */\n\tmeter?: string\n\t/**\n\t * The forms it takes (a `morph` effect's `into`), by unit type: what it learns in each (`HeroForm`). A form is a\n\t * hero's type of its own (its stats, its growth, its look); this says what of the hero's it takes along\n\t *\n\t * @beta\n\t */\n\tforms?: Record<string, HeroForm>\n}\n\n/**\n * What becomes of a hero's cooldowns going in and out of a form (`HeroForm.cooldowns`)\n *\n * @beta\n */\nexport type FormCooldowns = 'keep' | 'reset' | 'shared'\n\n/**\n * What a hero is in one of its forms (`HeroDef.forms`): the abilities it learns there by id (`learns`), the level each\n * starts at (`levels`: that of one of the hero's own, or a number), and what of its own the form leaves in place\n * (`keeps`). Everything else of its own is put away until it turns back\n *\n * ```ts\n * // Nidalee's cougar: Takedown at Rocket Grab's level and Pounce at Void Swarm's, Swipe learned in the form; the\n * // aspect (it made the form) and the ultimate stay as they are\n * forms: { cougar: { learns: ['takedown', 'pounce', 'swipe'], levels: { takedown: 'rocketGrab', pounce: 'voidSwarm' }, keeps: ['heartbreaker'] } }\n * ```\n *\n * The shorter shape, a list alone with neither `levels` nor `keeps`, is read by slot: the first at the level of the\n * first the hero learns as itself, the second of the second, and so on (Q is Q), a point put into one in the form going\n * to the hero's own at that slot too\n *\n * @beta\n */\nexport interface HeroForm {\n\t/**\n\t * The abilities it learns in the form, by id: what the HUD's card and hero panel show there, and what its points go\n\t * into, in this order (the hero's own it keeps after them). One of the hero's own named here is kept as it is. What\n\t * the form's type learns (its `hero.learns`) when left out\n\t */\n\tlearns?: string[]\n\t/**\n\t * The level each of `learns` starts at in the form, by id: the id of one of the hero's own abilities, whose level it\n\t * has (a point put into it in the form goes to that one too), or a number. 0 for what is not said: learned in the form\n\t */\n\tlevels?: Record<string, string | number>\n\t/**\n\t * The hero's own abilities the form leaves in place, by id: castable in the form as they are, level and cooldown (an\n\t * ultimate, a passive); learned there, those it learns as itself. The ability that made the form and the spells it\n\t * brought along (`HeroDef.spells`) are kept unsaid\n\t */\n\tkeeps?: string[]\n\t/**\n\t * What becomes of the cooldowns of what the form puts away and of what it brings, when the hero goes in and out of it\n\t * within the time of a cooldown:\n\t *\n\t * - left out: what the hero puts away runs down by the time it is away, and comes back with what is left; what the\n\t *   form brings starts ready each time. The default\n\t * - `'keep'`: what is put away comes back exactly as it was left, the time away not counted: a form is not a way to\n\t *   wait out a cooldown\n\t * - `'reset'`: what is put away comes back ready, its cooldown 0: a form is a way to get them back\n\t * - `'shared'`: an ability of the form whose level is one of the hero's own (`levels` by id, or by slot in the shorter\n\t *   shape) has one cooldown with it: it starts with the cooldown of the one it takes the place of, and gives its\n\t *   own, what it has by then (cast in the form or run down), back as the hero turns back. The rest as when left out\n\t *\n\t * What the form keeps in place (`keeps`, the ability that made it, the spells) is one ability in both and is never\n\t * touched by any of them\n\t */\n\tcooldowns?: FormCooldowns\n}\n\n/**\n * What turns a form back into the hero it was (`EffectFields.back`): the ability that made it cast again (`ability`),\n * its time up (`time`), or its death (`death`: it falls as itself, and is brought back as itself)\n *\n * @beta\n */\nexport type MorphBack = 'ability' | 'time' | 'death'\n\n/**\n * What an entity is: a unit, a building or a resource\n *\n * @beta\n */\nexport type EntityKind = 'unit' | 'building' | 'resource'\n\n/**\n * Where something is: on the ground, or above it\n *\n * @beta\n */\nexport type Layer = 'ground' | 'air'\n\n/**\n * The stats an attack reads how hard, how fast and how far it hits from (`AttackDef.stats`): the unit's\n * `attackDamage`, `attackSpeed` and `attackRange` for what is left out\n *\n * @beta\n */\nexport interface AttackStats {\n\t/** What a hit deals, before the armour of the target. `attackDamage` when left out */\n\tdamage?: StatKey\n\t/** Hits a second. `attackSpeed` when left out */\n\tspeed?: StatKey\n\t/** How far it reaches, between the edges. `attackRange` when left out */\n\trange?: StatKey\n}\n\n/**\n * One of the ways a unit attacks (`UnitTypeDef.attacks`): what it hits, how its blow lands. How hard, how fast and how\n * far are stats: the unit's `attackDamage`, `attackSpeed` and `attackRange`, or stats of the game's own that the attack\n * names (`stats`: a second weapon's)\n *\n * @beta\n */\nexport interface AttackDef {\n\t/**\n\t * The stats its numbers are, by id: a stat of the game's (`Rules.stats`) for a weapon whose damage, speed or\n\t * range is not the unit's first's. What changes those stats (research, items, buffs) changes this attack alone\n\t */\n\tstats?: AttackStats\n\t/** Physical when left out */\n\tdamageType?: DamageType\n\t/** Seconds from the start of the swing until damage lands (or the projectile leaves), at the attack speed the unit starts with */\n\tdamagePoint: number\n\t/**\n\t * Seconds after the blow during which the unit is held: an order it is given (a move, another attack) waits until\n\t * they are over, unless the rules let it cut them (`RuleSettings.combat.recoveryCancels`). At the attack speed the unit\n\t * starts with, shorter as it attacks faster, and never past its next swing. None when left out: it may walk away\n\t * the moment the blow lands (kiting), as in LoL\n\t */\n\trecovery?: number\n\t/** Enemies closer than this are attacked automatically */\n\tacquisitionRange: number\n\t/**\n\t * How near is too near, edge to edge: what is closer than this the attack does not hit (a siege weapon's dead zone).\n\t * Another of the unit's attacks takes over there where one reaches (`RuleSettings.combat.pickAttack`); with none, a unit\n\t * told to attack steps back out of it first, and one left to itself does not pick what is that near. None when left out\n\t */\n\tminRange?: number\n\t/**\n\t * Fires as the unit walks (a horse archer, a tank's turret): told to move, it hits what it passes within the attack's\n\t * range without stopping or turning to it, at the attack's speed. Every other order fights as any attack does\n\t * (it stops to). Not when left out\n\t */\n\tonTheMove?: boolean\n\t/** Set for ranged attacks */\n\tprojectileSpeed?: number\n\t/**\n\t * What this attack can hit: kinds of things, and where they are. Everything on the ground when left out.\n\t * What flies is only hit by attacks that name `air`, and an attack that names `air` alone does not hit the ground\n\t */\n\ttargets?: (EntityKind | Layer)[]\n\t/**\n\t * Radius around the point of impact in which everyone is hit, friends too: in full in the inner half, by half further out.\n\t * Shots of such an attack land where they were aimed, they do not follow their target\n\t */\n\tsplash?: number\n\t/** Can be told to attack a spot on the ground */\n\tground?: boolean\n\t/** Brings down what is `fellable` in the area it hits */\n\tfells?: boolean\n\t/**\n\t * A blow from up close (no missile) also strikes the target's other enemies near it, a part of its damage each:\n\t * a cleave. With a buff's (`BuffDef.cleave`), the one of the larger part counts\n\t *\n\t * @beta\n\t */\n\tcleave?: Cleave\n\t/**\n\t * How what this attack kills dies, for the screen (`'shot'`, `'crushed'`, `'burnt'`): the death's `how`, which the\n\t * view shows its way (`UnitLook.death`). A word, or one decided for each blow. The `death` hook has the last say\n\t */\n\thow?:\n\t\t| string\n\t\t| ((hit: { attacker: Entity; target?: Entity; damage: number; type: DamageType; crit: boolean; tags?: readonly string[] }) => string | undefined)\n}\n\n/**\n * What a blow from up close does to the enemies around its target (`AttackDef.cleave`, `BuffDef.cleave`): a part of\n * its damage, before their armor, for each of them within `radius` of the target and, where `angle` says, within a\n * cone of that angle that opens from the attacker through the target (so ahead of the attacker, round and behind the\n * target). Not the target itself, nor anyone the attack could not hit\n *\n * @beta\n */\nexport interface Cleave {\n\t/** The part of the blow's damage each other enemy takes, by level for a buff's: 0.5 is half */\n\tpart: Scaled\n\t/** How far from the target's edge the enemies it reaches stand */\n\tradius: number\n\t/** How wide the cone is, in radians (1.57: a quarter turn). All the way round the target when left out */\n\tangle?: number\n}\n\n/**\n * The id of a resource, as its game module defines it (`ResourceDef`)\n *\n * @beta\n */\nexport type ResourceId = string\n\n/**\n * Something players have amounts of and pay with, like gold, lumber or crystals. A game module lists its own\n *\n * @beta\n */\nexport interface ResourceDef {\n\t/** The resource's id, which prices, players' amounts and gatherers name it by */\n\tid: ResourceId\n\t/** What the player sees the resource called */\n\tname: string\n\t/** What every player starts a game with. Nothing when left out */\n\tstart?: number\n\t/** What workers gather of it is cut by the upkeep of the army, see `UpkeepTier` */\n\tupkeep?: boolean\n}\n\n/**\n * What something costs: an amount of each resource it takes, by resource id. What is left out costs nothing\n *\n * @beta\n */\nexport type Cost = Record<ResourceId, number>\n\n/**\n * How a type goes up once it is put down (`UnitTypeDef.construction`): `builder`, `self` (also `buildsItself`) or\n * `instant`\n *\n * @internal\n */\nexport function constructionOf(def: Pick<UnitTypeDef, 'construction' | 'buildsItself'>): 'builder' | 'self' | 'instant' {\n\treturn def.construction ?? (def.buildsItself ? 'self' : 'builder')\n}\n\n/**\n * The definition of a unit type: a unit, building or resource, with its stats, abilities, costs and what it does\n *\n * @public\n */\nexport interface UnitTypeDef {\n\t/** The type's id, shared by every game: give it a prefix of the game's */\n\tid: string\n\t/** What the player sees the type called */\n\tname: string\n\t/**\n\t * The definition this one is a copy of, made from the data (`copyOf` in a `data.json`, the editor's Copy as new):\n\t * what it is drawn, heard and pictured as where the game gives it no look of its own\n\t */\n\tbasedOn?: string\n\t/** Whether the type is a unit, a building or a resource */\n\tkind: EntityKind\n\t/**\n\t * Words of the game's for what it is (`undead`, `mechanical`, `ward`): what an effect's `tags`, an ability's\n\t * `targets.tags` and an `if`'s condition (`UnitCondition.tags`) go by\n\t *\n\t * @beta\n\t */\n\ttags?: string[]\n\t/** Collision radius */\n\tradius: number\n\t/** Size in grid cells. Required for buildings and resources */\n\tfootprint?: { w: number; d: number }\n\t/** What it starts with. What is left out is 0, a critical strike is worth 175% */\n\tstats: Partial<Stats> & { health: number }\n\t/** Mana it comes into the world with. All of it when left out */\n\tinitialMana?: number\n\t/** Vision radius by day */\n\tsight: number\n\t/** Vision radius at night. A part of the one by day when left out */\n\tsightNight?: number\n\t/** Flies: over cliffs, trees and buildings, out of reach of whatever cannot hit the air */\n\tflying?: boolean\n\t/**\n\t * Goes on deep water and nowhere else: a boat. Sent onto land, it goes to the water nearest where it was sent. On\n\t * the ground, as far as what can hit it goes\n\t */\n\tnaval?: boolean\n\t/**\n\t * A waygate, in a game with the portals pack (`portalsPack`): a unit told to it walks in and is at once where it\n\t * leads (its `waygate` field, a point of the map; `setWaygate` in code)\n\t */\n\twaygate?: boolean\n\t/**\n\t * Rocks, a barricade, a gate to break down, in a game with the destructibles pack (`destructiblesPack`): it stands in\n\t * the way as any building does until it is brought down, and any unit whose attack reaches it attacks it when told\n\t * to, never of its own accord\n\t */\n\tdestructible?: boolean\n\t/**\n\t * Carries others: a boat, a wagon. Units of its side get in by being told to (right-clicking it), are out of the\n\t * world while in, and get out on the land nearest it (the `unload` order). It takes `capacity` of them, of the\n\t * kinds `takes` says (every unit that walks when left out). What it carries dies with it\n\t */\n\t/**\n\t * Carries others: a boat, or a building they go into (a garrison). `takes` says who may get in; `armed`, for a\n\t * building with an attack, is the attack damage each one inside adds, and it attacks only while someone is inside,\n\t * as an orc burrow does. What a building holds comes out when it falls; what a boat holds goes down with it\n\t */\n\ttransport?: {\n\t\tcapacity: number\n\t\ttakes?: (def: UnitTypeDef) => boolean\n\t\t/** Attack damage each one inside adds; or in code, all of what they add, by who is inside (none for nobody) */\n\t\tarmed?: number | ((world: World, building: Entity, inside: Entity[]) => number)\n\t}\n\t/** How fast it turns, in radians a second: the game's for every unit (`RuleSettings.movement.turnRate`, 12) when left out */\n\tturnRate?: number\n\t/**\n\t * How it attacks, as the classic RTS two weapons: against each target the first that reaches it (its `targets`), or\n\t * the one the game picks (`RuleSettings.combat.pickAttack`). It swings one at a time: a hit's cooldown is that attack's,\n\t * whichever swings next. None for what does not attack\n\t */\n\tattacks?: AttackDef[]\n\t/** Makes the type a hero, with its levels and the rest of `HeroDef`; none for a unit that is not one */\n\thero?: HeroDef\n\t/** How dangerous it is, for creeps. Shown to the player, and added up per camp */\n\tlevel?: number\n\t/** Gold for whoever kills it, rolled between the two */\n\tbounty?: [min: number, max: number]\n\t/**\n\t * Whether it leaves a corpse when it dies, for spells to use (see `raiseDead`). Units do, unless this says no:\n\t * machines, spirits. Decided for each death in code: false for none, true or seconds for one (how long it lies)\n\t */\n\tcorpse?: boolean | ((world: World, entity: Entity) => boolean | number)\n\t/**\n\t * Immune to spells: abilities do not touch it, of friends or enemies, unless they say they get through\n\t * (`piercesImmunity`). Decided in code whenever it is asked: while it stands on holy ground. The player's screen only\n\t * knows the plain `true` of it, to grey out a target; the simulation goes by the code\n\t */\n\tspellImmune?: boolean | ((world: World, entity: Entity) => boolean)\n\t/** Experience heroes get for killing it. Follows from its cost when left out */\n\txp?: number\n\t/** Building types the player has to have before this can be built or trained */\n\trequires?: string[]\n\t/**\n\t * The race it is of (`Rules.races`): only its players may build or train it. Everyone's when left out: creeps,\n\t * what is shared. What a player may have is the game's to change (the `available` hook)\n\t */\n\trace?: string\n\t/** Building types this one counts as, for requirements. A keep is a town hall too */\n\tprovides?: string[]\n\t/**\n\t * Type this building can be upgraded into, where it stands; or the types, for one that may become one of several (a\n\t * keep that turns into a castle or a citadel, `upgradesOf`). The first is what an upgrade is into where none is named\n\t */\n\tupgradesTo?: string | string[]\n\t/** Slots for items. Heroes have six */\n\tinventory?: number\n\t/** Items this building sells */\n\tsells?: string[]\n\t/**\n\t * Units it hires out to whoever has one of theirs there, by type: a tavern's heroes, a dock's boats. Their cost,\n\t * and a hero only once (see `hire`). Neutral, it hires to everyone\n\t */\n\thires?: string[]\n\t/**\n\t * What it may leave behind when it dies, each with its chance from 0 to 1. Or code: the items it leaves, decided as\n\t * it dies (one random level-3 item; more for a stronger killer)\n\t */\n\tdrops?: { item: string; chance: number }[] | ((world: World, entity: Entity, killer?: Entity) => string[])\n\t/** Brings fallen heroes back */\n\trevives?: boolean\n\t/** Ids of the abilities the unit has */\n\tabilities?: string[]\n\t/** What it costs to build or train, in resources */\n\tcost?: Cost\n\t/**\n\t * Supply (food) it takes up for as long as it lives, and while it is being trained: of the one pool there always is, or by\n\t * pool (`{ supply: 2, command: 1 }`: `supply` that one, the rest the game's own, `RuleSettings.supply.pools`). Read with\n\t * `supplyOf` and `supplyPoolsOf`\n\t */\n\tsupply?: number | Record<string, number>\n\t/** Seconds to build or train */\n\tbuildTime?: number\n\t/** What it provides once it stands finished: of the one pool, or by pool, as `supply` is said. Read with `supplyGivenOf` and `supplyPoolsGivenOf` */\n\tsupplyGiven?: number | Record<string, number>\n\t/** Makes it a worker that gathers: how much it carries, seconds a load takes, and which resources it gathers */\n\tharvester?: {\n\t\tcapacity: number\n\t\tgatherTime: number\n\t\t/**\n\t\t * The kinds of resource it gathers: all of them when left out. The undead's acolytes gold and nothing else, ghouls\n\t\t * lumber. The `canHarvest` hook has the last word (`canHarvest`)\n\t\t */\n\t\tids?: ResourceId[]\n\t}\n\t/** Building types this unit can construct */\n\tbuilds?: string[]\n\t/** Unit types this building can train */\n\ttrains?: string[]\n\t/** Upgrades that can be researched here */\n\tresearches?: string[]\n\t/** Accepts harvested resources: all of them, or only the ones listed */\n\tdropOff?: boolean | ResourceId[]\n\t/**\n\t * Goes up on a resource of this kind, over it, of the same footprint: the undead's cursed gold mine. The resource is\n\t * its owner's alone from then on (`canHarvest`); one that takes what is gathered there (`dropOff`) has its owner's\n\t * workers gather at it from around it, handing in where they stand, as many at once as `gatherers` says. It goes\n\t * down with the resource, which stands again where it is destroyed\n\t */\n\tbuiltOn?: ResourceId\n\t/** Workers that gather at once at it, when it stands on a resource (`builtOn`): 5 when left out */\n\tgatherers?: number\n\t/**\n\t * Goes up on its own once it is put down, as the undead summon theirs: the builder is free at once, and nobody\n\t * helps (`RuleSettings.production.buildRate` of one builder, all the way). The same as `construction: 'self'`\n\t */\n\tbuildsItself?: boolean\n\t/**\n\t * How it goes up once it is put down: with builders at it (`builder`, the more the faster, as `buildRate` says), on\n\t * its own with the builder free at once (`self`, the undead's), or whole at once (`instant`: a wall piece, a\n\t * ward). `builder` when left out (`self` with `buildsItself`)\n\t *\n\t * @beta\n\t */\n\tconstruction?: 'builder' | 'self' | 'instant'\n\t/**\n\t * How fast it goes up with so many builders at it, 1 being one builder's: the game's rule (`RuleSettings.production.buildRate`) for\n\t * every type when left out\n\t *\n\t * @beta\n\t */\n\tbuildRate?: (builders: number, world: World, structure: Entity) => number\n\t/** Makes it a deposit that can be gathered from: which resource, how much, how many workers fit and how they gather */\n\tresource?: {\n\t\tid: ResourceId\n\t\tamount: number\n\t\t/** Workers that fit inside at once, for resources that are entered */\n\t\tslots: number\n\t\t/** Workers go inside to gather, like into a gold mine, instead of working on it from next to it */\n\t\tentered?: boolean\n\t\t/** Seconds a load takes, when that is not what the worker usually needs */\n\t\tgatherTime?: number\n\t}\n\t/** Key used in the command card when building or training this type */\n\thotkey?: string\n\t/** Higher values are picked first when acquiring targets */\n\tthreat?: number\n\t/** Whether it cannot be hurt */\n\tinvulnerable?: boolean\n\t/**\n\t * Ids of the abilities that alone may target it (a soul that only `possess` takes). Nothing else may: not an ability\n\t * clicked on it or used on it by the AI, nor an attack, nor the area of one, nor a heal; the ones named get through\n\t * the target rules as they say (`targets`). It is untouched as `invulnerable` is, but for them\n\t */\n\ttargetableBy?: string[]\n\t/** Takes damage like anything else but never dies of it: it is left with a little health, like something to practise on */\n\tundying?: boolean\n\t/** Seconds after it was last hurt that it is whole again, all at once */\n\trecovers?: number\n\t/** Nobody picks a fight with it on their own: it is only attacked when someone is told to */\n\tignored?: boolean\n\t/** Destroyed by attacks that fell, like a tree by a catapult, whatever else it withstands */\n\tfellable?: boolean\n\t/**\n\t * Whether it burns, in a game with the burning pack (`burningPack`), and how (`BurnsDef`: for how long, what it\n\t * leaves, whether its wood is kept, what kind of burning it is): `true` as the pack says, `false` never. What can be\n\t * felled (`fellable`: trees) burns when left out; anything else does not\n\t *\n\t * @beta\n\t */\n\tburns?: boolean | BurnsDef\n\t/**\n\t * A piece of wall (`wallsPack`): it joins with the pieces of its family beside it, and its shape (`single`, `end`,\n\t * `straight`, `corner`, `tee`, `cross`) is its look. A gate (`gate`) joins as a piece does, turned along its line,\n\t * and its owner opens and shuts it for everyone (`wallGateCommand`): its look `open` or `shut`. Pieces join by their\n\t * footprints, so a gate wider than a cell sits in a line of pieces of one: one of a cell lets nobody through, the\n\t * ground about a wall being kept off by the radius of what walks (a gatehouse of 3 by 3 lets through what is 1 wide) @beta\n\t */\n\twall?: { family: string; gate?: boolean }\n\t/** Seconds it lasts before it is gone by itself, like a ward */\n\tlifetime?: number\n\t/** Enemies cannot see it, `after` seconds after it came into the world, unless something reveals it to them */\n\tinvisible?: { after?: number }\n\t/**\n\t * Finds what of its enemies is invisible or camouflaged within this far of it, for its team, for as long as it stays\n\t * that near, in a game with the vision pack (`visionPack`): a Sentry Ward's true sight, a Control Ward\n\t *\n\t * @beta\n\t */\n\ttrueSight?: number\n\t/**\n\t * Goes down after this many attacks and spells, whatever they deal: its health counts hits, and its most health is\n\t * this whatever its `stats.health` or what changes its stats say\n\t */\n\tuses?: number\n\t/**\n\t * A trap, a mine, a pickup, in a game with the ground objects pack (`groundObjectsPack`): an ability of the game's that\n\t * goes off as one of those it is for comes within its `radius` (`GroundTrigger`)\n\t *\n\t * @beta\n\t */\n\ttrigger?: GroundTrigger\n\t/**\n\t * Something others click on, in a game with the ground objects pack (`groundObjectsPack`): a unit of those it is for\n\t * told to it (right-clicked) walks up to it and uses it, an ability of the game's going off (`GroundUse`): Thresh's\n\t * lantern, Bard's portals\n\t *\n\t * @beta\n\t */\n\tuse?: GroundUse\n\t/**\n\t * Stops the missiles of abilities that come at it, in a game with the ground objects pack (`groundObjectsPack`):\n\t * those of its enemies (`enemies`), or of everyone (`all`); they are gone where they meet it, with nothing happening\n\t * (Yasuo's Wind Wall, a line of them: `EffectFields.line`). A missile thrown (`arc`) flies over it\n\t *\n\t * @beta\n\t */\n\tblocksMissiles?: 'enemies' | 'all'\n\t/**\n\t * What happens where it dies, in a game with the ground objects pack (`groundObjectsPack`): an ability of the game's\n\t * goes off there in its maker's name (`ability`), and those of its type and owner within `chain` of it die too and\n\t * go off in turn: Gangplank's barrels (`uses: 3` counts the hits that bring one down)\n\t *\n\t * @beta\n\t */\n\tburst?: { ability: string; chain?: number }\n\t/**\n\t * Resources of its own beside mana, in a game with the resources pack (`resourcesPack`), by id: energy, fury, heat,\n\t * flow, ammo (`PoolDef`: how much at most, at the start, back each second, lost each second when nothing used it,\n\t * gained by walking, refilled when empty, and buffs at thresholds). What its abilities cost of them (`AbilityDef.cost`)\n\t * and give (`gain`), what its attacks cost (`attackCost`), the `gain` effect\n\t *\n\t * @beta\n\t */\n\tpools?: Record<string, PoolDef>\n\t/**\n\t * What each of its attacks costs of its pools (`pools`), in a game with the resources pack: with less than that it\n\t * does not attack (Jhin's four shots, then the reload)\n\t *\n\t * @beta\n\t */\n\tattackCost?: Record<string, number>\n\t/**\n\t * What the computer player takes it for (`AiHints`): its roles (`worker`, `hall`, `soldier`...), the game's words\n\t * about it, what it answers. Declared where what the kit infers from the rest of the definition is wrong or cannot\n\t * be known; inferred otherwise (`inferRoles` in `@v12-engine/engine/ai`)\n\t */\n\tai?: AiHints\n}\n\n/**\n * The names of a game's own ways of aiming an ability (`defineTargeting`), by declaration merging:\n * `declare module '@v12-engine/engine' { interface AbilityTargetings { wall: true } }` makes `target: 'wall'` an\n * ability's way of aiming\n *\n * @beta\n */\nexport interface AbilityTargetings {}\n\n/**\n * How an ability is aimed: the engine's ways (`AimKind`: `none`, `unit`, `point`, `direction`, `vector`, `passive`), or a\n * game's own (`AbilityTargetings`, `defineTargeting`)\n *\n * @beta\n */\nexport type AbilityTarget = 'none' | 'unit' | 'point' | 'direction' | 'vector' | 'passive' | keyof AbilityTargetings\n\n/**\n * How an ability is cast again after it is cast (`AbilityDef.recast`): for `window` seconds the same button casts the\n * recast, `count` times, each doing its `effects` (no wind-up, no channel, `manaCost` its own: none when left out); the\n * cooldown waits for the last recast or the window's end (`after`) or starts at the first cast (`first`). The window\n * and its recasts are the ability's state (`AbilityState.recast`), saved and told to its owner's button\n * (`AbilityInfo.recast`)\n *\n * @beta\n */\nexport interface AbilityRecast {\n\t/** Seconds it may be cast again for, from the cast */\n\twindow: Scaled\n\t/** How many times it may be cast again in the window: once when left out */\n\tcount?: number\n\t/** What a recast does: the ability's own `effects` when left out */\n\teffects?: EffectDef[]\n\t/** How a recast is aimed: as the ability is when left out; with a `mark`, at the marked unit, with no aim of its own */\n\ttarget?: AbilityTarget\n\t/** How far away a recast's target may be: the ability's `range` when left out */\n\trange?: Scaled\n\t/**\n\t * A buff the cast leaves on a unit (Sonic Wave's mark): a recast goes to the unit that carries it from the caster\n\t * (the nearest, where there are more), its target and its point, and is refused while none does (`noMark`)\n\t */\n\tmark?: string\n\t/**\n\t * When the cooldown starts: `after` the last recast, or the window's end (when left out), with what it was as the\n\t * ability was cast; or at the `first` cast, as usual, the recasts not waiting for it\n\t */\n\tcooldown?: 'after' | 'first'\n\t/** Mana a recast costs: none when left out */\n\tmanaCost?: Scaled\n}\n\n/**\n * What every effect may say, whatever its type: who of what it reaches it applies to (`effectTargets`)\n *\n * @beta\n */\nexport interface EffectCommon {\n\t/** Only hits what carries this buff */\n\tifBuff?: string\n\t/**\n\t * Which look of its ability the screen draws it with (`AbilityLook.effects` in the client: by this name, else by its\n\t * place in the ability or its type). Nothing to the rules: the same game with another look\n\t *\n\t * @beta\n\t */\n\tlook?: string\n\t/** Only hits heroes */\n\tonly?: 'heroes'\n\t/**\n\t * Only hits what has one of these tags of its type (`UnitTypeDef.tags`): `['undead']`. Everything when left out\n\t *\n\t * @beta\n\t */\n\ttags?: string[]\n\t/**\n\t * It happens by chance: this share of the times it would (0.25 one in four), drawn from the world's numbers\n\t * (`world.rng`), so the same every run. Once each time its list runs, for all it reaches; for a trigger (`onHit`,\n\t * `onDamaged`…), each time it would go off (Bash), its cooldown starting only when it does; for an `if`, a\n\t * condition like its others, drawn for each it asks of (and `otherwise` when the draw fails). A number, one per\n\t * level, or code (`EffectValue`) asked with the target\n\t *\n\t * @beta\n\t */\n\tchance?: EffectValue\n\t/** Only hits these kinds of things. Everything but resources when left out */\n\tkinds?: EntityKind[]\n\t/** Where what it hits has to be: on the ground, in the air. Both when left out */\n\tlayers?: Layer[]\n\t/**\n\t * Makes the effect hit everything around the point of impact. Required for auras, and the size of a missile. In code\n\t * (`EffectValue`), asked as it lands with no target\n\t */\n\tradius?: EffectValue\n\t/**\n\t * What ground it covers (`EffectShape`), turned the way the ability was aimed: `circle` (its `radius`, what an effect\n\t * with a radius alone covers), `cone` (`length`, `angle`), `line` (`length`, `width`), `rect` (`length`, `width`),\n\t * `ring` (`radius`, `width`), `arc` (`radius`, `angle`, `width`), `cross` (`length`, `width`). A circle, a ring, a\n\t * rectangle and a cross lie around where it landed; a cone, a line and an arc go off from the caster (or the\n\t * context's `origin`) the way of where it landed. Everything in it, as `affects` says, is hit (`effectArea`,\n\t * `inArea`). Of a zone: what is inside it, for `onEnter`, `onLeave` and `edge`\n\t *\n\t * @beta\n\t */\n\tshape?: EffectShape\n\t/** Of a `cone`, a `line`, a `rect` and a `cross`: how long it is, end to end. In code (`EffectValue`), asked as it lands @beta */\n\tlength?: EffectValue\n\t/**\n\t * Of a `line`, a `rect` and a `cross`: how far it covers on either side of its middle; of a `ring` and an `arc`, how\n\t * thick it is, inwards from its `radius`. 1 when left out\n\t *\n\t * @beta\n\t */\n\twidth?: EffectValue\n\t/** Of a `cone` and an `arc`: how wide it opens, in radians @beta */\n\tangle?: EffectValue\n\t/** Who an effect with a radius applies to. Follows from the kind of effect when left out */\n\taffects?: 'enemies' | 'allies' | 'all'\n\t/**\n\t * Only hits what this says of it (`UnitCondition`: a buff or none, health under or over a share, a hero, tags, enemy\n\t * or ally of the caster), or code (`UnitConditionCheck`, asked with the target): `{ healthBelow: 0.5, notTags:\n\t * ['mechanical'] }`. Of an effect with an area, asked of each in it; of one without, of its target\n\t *\n\t * @beta\n\t */\n\twhere?: UnitCondition | UnitConditionCheck\n\t/**\n\t * Of what its area reaches, the order it goes to them in (`TargetOrder`), or a comparison: the first `limit` of it are\n\t * hit. The nearest to the middle of its area (where it landed, or the caster for a cone, a line and an arc) when left\n\t * out with a `limit`\n\t *\n\t * @beta\n\t */\n\tsort?: TargetOrder | ((a: Entity, b: Entity) => number)\n\t/**\n\t * Of what its area reaches, at most this many, the first by `sort`: a number, or one per level. `{ sort:\n\t * 'lowestHealthShare', limit: 3 }` heals the three most hurt; `{ sort: 'random', limit: 1 }` strikes one of them.\n\t * Chosen before the game has its say (`beforeEffect`): a spell shield on one chosen takes the blow\n\t *\n\t * @beta\n\t */\n\tlimit?: Scaled\n\t/** Applies to the caster, wherever the ability was aimed */\n\ton?: 'caster'\n\t/**\n\t * When it happens, in a chain (`EffectMoment`): not now, but as the nearest effect before it in its list that\n\t * comes to that moment gets there: `hit` a missile's every hit, `arrived` a pull's target arriving, `landed` a\n\t * dash's end, `end` a missile's or zone's end. `[missile, { type: 'damage', when: 'hit' }]` is `[{ ...missile, effects: [damage] }]`:\n\t * what waits goes into what it waits on (`lowerChain`), so one waiting on what waits itself happens later still.\n\t * One with nothing before it to wait on never happens (`checkRules` says so)\n\t *\n\t * @beta\n\t */\n\twhen?: EffectMoment\n\t/**\n\t * Goes off from units of the caster's of a type (`ProxyOrigin`), not from the caster: once from each it picks, that one\n\t * the context's `origin` (a missile starts there, an area never takes it in, the strike says it came from there), the\n\t * caster still who does it (whose the damage, the kills and the scaling are). Zed's shadows, Orianna's ball, Syndra's\n\t * spheres, Azir's soldiers. Nothing where none is picked, unless `caster` says otherwise\n\t *\n\t * @beta\n\t */\n\torigin?: ProxyOrigin\n}\n\n/**\n * Units of the caster's an effect goes off from (`EffectCommon.origin`): proxies, a shadow, a ball, a sphere, a soldier.\n * The caster's are those it put down (`madeBy`, a `spawn` of the ground objects pack), or, of one nobody says put down,\n * those of its owner. In code, a game's effect runs its effects from a unit of its own choice (`EffectContext.origin`,\n * `runEffects`), or asks which a proxy origin picks (`proxiesOf`)\n *\n * @beta\n */\nexport interface ProxyOrigin {\n\t/** The unit type of the caster's it goes off from */\n\tproxy: string\n\t/**\n\t * Which of them: the one `nearest` to where it was aimed (when left out), `all` of them (each in the order they came\n\t * into the world), the `newest` or the `oldest`\n\t */\n\tpick?: 'nearest' | 'all' | 'newest' | 'oldest'\n\t/**\n\t * From the caster as well (`true`: Zed and his shadows, each a Razor Shuriken), or from the caster where none is\n\t * picked (`otherwise`: Orianna's ball, with her when it is nowhere). From the picked alone when left out\n\t */\n\tcaster?: boolean | 'otherwise'\n\t/** Only those within this far of the caster: Azir's soldiers within his reach. Any distance when left out */\n\trange?: number\n\t/** Only those within this far of where it was aimed: the soldiers near what Azir attacks. Any distance when left out */\n\tnear?: number\n\t/**\n\t * Where it lands: where it was aimed (`aim`, when left out), or where each it goes off from stands (`proxy`: Orianna's\n\t * Dissonance around the ball, Zed's Shadow Slash around each shadow)\n\t */\n\tat?: 'aim' | 'proxy'\n\t/** The one it goes off from is its target too: a swap with it (Zed's Living Shadow cast again), a dash to it */\n\ttarget?: boolean\n}\n\n/**\n * The shapes of ground an effect may cover (`EffectCommon.shape`)\n *\n * @beta\n */\nexport type EffectShape = 'circle' | 'cone' | 'line' | 'rect' | 'ring' | 'arc' | 'cross'\n\n/**\n * A resource of a unit's own beside mana (`UnitTypeDef.pools`), in a game with the resources pack (`resourcesPack`):\n * Akali's energy (`regen`), Tryndamere's fury (gained by attacks, `decay` after `idle`), Rumble's heat (gained by casts,\n * overheating at a threshold), Yasuo's flow (`moving`), Jhin's ammo (`reload`)\n *\n * @beta\n */\nexport interface PoolDef {\n\t/** What it is called on the screen: its id when left out */\n\tname?: string\n\t/** The colour of its bar, a CSS colour: the client's own when left out */\n\tcolor?: string\n\t/** How much it holds at most */\n\tmax: number\n\t/** How much it holds as the unit comes into the world: full when left out */\n\tstart?: number\n\t/** How much comes back each second, always (energy) */\n\tregen?: number\n\t/** How much goes each second once nothing has spent or given any for `idle` seconds (fury, heat) */\n\tdecay?: number\n\t/** Seconds without its being spent or given before it decays: at once when left out */\n\tidle?: number\n\t/** How much comes for each cell the unit walks (Yasuo's flow) */\n\tmoving?: number\n\t/** Seconds after it runs out until it is full again (a reload) */\n\treload?: number\n\t/** Buffs its carrier gets as it fills (`PoolThreshold`): overheated, in the danger zone */\n\tthresholds?: PoolThreshold[]\n}\n\n/**\n * A buff a unit gets as one of its pools reaches `at` (`PoolDef.thresholds`): kept on while it holds that much or more\n * (`kept`: Rumble's danger zone), or put on once as it gets there; one that `empties` holds the pool still while it\n * lasts, and empties it as it ends (Rumble's overheat)\n *\n * @beta\n */\nexport interface PoolThreshold {\n\t/** How much the pool holds for it */\n\tat: number\n\t/** The buff, in the carrier's own name */\n\tbuff: string\n\t/** On while the pool holds `at` or more, off below: put on once as it gets there when left out */\n\tkept?: boolean\n\t/** The pool stays as it is while the buff lasts, and is empty as it ends (not with `kept`) */\n\tempties?: boolean\n}\n\n/**\n * What an `if` asks of a unit, its caster or its target (`EffectFields.caster`, `EffectFields.target`): each part it\n * says must hold. Or code (`UnitConditionCheck`)\n *\n * @beta\n */\nexport interface UnitCondition {\n\t/** It carries this buff */\n\tbuff?: string\n\t/** It does not carry this buff */\n\tnoBuff?: string\n\t/** Its health is under this share of its max (0.2: below 20%: an execute) */\n\thealthBelow?: number\n\t/** Its health is at or over this share of its max (1: unhurt) */\n\thealthAbove?: number\n\t/** It is a hero (true) or not (false) */\n\thero?: boolean\n\t/**\n\t * It is a structure, a building (true), or not (false). `{ hero: false, structure: false }` is a creep: any unit\n\t * that is neither, a camp's, a lane's, a summon. What a passive that works in every kind of game names\n\t *\n\t * @beta\n\t */\n\tstructure?: boolean\n\t/** Its type has one of these tags (`UnitTypeDef.tags`) */\n\ttags?: string[]\n\t/** Its type has none of these tags: `['undead']` for the living */\n\tnotTags?: string[]\n\t/** What it is to the caster: an `enemy` or an `ally` (the caster itself is one) */\n\tis?: 'enemy' | 'ally'\n}\n\n/**\n * The orders a query and an effect sort what they found in (`WorldQuery.sort`, `EffectCommon.sort`): `nearest` and\n * `farthest` to its point (by the edge of each), the least or most `health`, the least or most of it as a share of its\n * max (`lowestHealthShare`: the most hurt), or `random`, drawn from the world's numbers (`world.rng`), so the same every\n * run. Ties go by who came into the world first\n *\n * @beta\n */\nexport type TargetOrder = 'nearest' | 'farthest' | 'lowestHealth' | 'highestHealth' | 'lowestHealthShare' | 'highestHealthShare' | 'random'\n\n/**\n * An `if`'s condition in code: whether it holds of the unit (the caster or the target), as the effect lands\n *\n * @beta\n */\nexport type UnitConditionCheck = (context: EffectValueContext, unit: Entity) => boolean\n\n/**\n * A ground object's trap, mine or pickup (`UnitTypeDef.trigger`), in a game with the ground objects pack\n *\n * @beta\n */\nexport interface GroundTrigger {\n\t/**\n\t * The ability whose `effects` go off: in the name of whoever put it down (its maker, a `spawn` of the pack's: the\n\t * object's own where there is none or it is gone), the one who came its target, the object where they go off from\n\t * (`EffectContext.origin`), at the level it was put down at\n\t */\n\tability: string\n\t/** How near its edge one comes for it to go off: 1 when left out */\n\tradius?: number\n\t/** Who sets it off: `enemies` of its owner (when left out), `allies`, `all`, or its `maker` alone (a soul, a chime) */\n\tby?: 'enemies' | 'allies' | 'all' | 'maker'\n\t/** Seconds after it is put down before it works (a mine arming): at once when left out */\n\tarm?: number\n\t/** Times it goes off before it is gone: once when left out, for ever with 0 */\n\ttimes?: number\n}\n\n/**\n * Something on the ground others use (`UnitTypeDef.use`), in a game with the ground objects pack\n *\n * @beta\n */\nexport interface GroundUse {\n\t/**\n\t * The ability whose `effects` go off as one uses it: in its maker's name (its own where there is none), the one who\n\t * uses it the target, the object the `origin`, and the point the next of those put down with it (the other end of a\n\t * portal) or the object itself\n\t */\n\tability: string\n\t/** Who may use it: `allies` of its owner (when left out), `enemies` or `all` */\n\tby?: 'allies' | 'enemies' | 'all'\n\t/** How near its edge one comes to use it: 1 when left out */\n\trange?: number\n\t/** Times it is used before it is gone: for ever when left out */\n\ttimes?: number\n}\n\n/**\n * The spots a `spawn` of the ground objects pack lays its units on (`EffectFields.line`): `count` of them, ends\n * included, along the way it was aimed, `length` long around where it landed (or from where it went off from to there,\n * when left out), or `across` it, a quarter turn round (a wall in front of the caster)\n *\n * @beta\n */\nexport interface SpawnLine {\n\t/** How many, ends included */\n\tcount: number\n\t/** How long it is, around where it landed: from where it went off from to there when left out */\n\tlength?: number\n\t/** It lies across the way it was aimed, a quarter turn round: a wall in front */\n\tacross?: boolean\n}\n\n/**\n * Which way a `knockback` throws, in a game with the moves pack (`EffectFields.direction`)\n *\n * @beta\n */\nexport type KnockbackDirection = 'away' | 'aim' | 'over' | 'towards'\n\n/**\n * The moment an effect of a chain waits for (`EffectCommon.when`): a missile's hit (`hit`), a pull's arrival\n * (`arrived`), a dash's landing (`landed`), a missile's or a zone's end (`end`)\n *\n * @beta\n */\nexport type EffectMoment = 'hit' | 'arrived' | 'landed' | 'end'\n\n/**\n * What an effect waiting for a moment waits on (`EffectCommon.when`): the types that come to it, and the list of\n * theirs it goes into\n *\n * @beta\n */\nexport const EFFECT_MOMENTS: Readonly<Record<EffectMoment, { readonly types: readonly string[]; readonly into: 'effects' | 'onEnd' }>> = {\n\thit: { types: ['missile'], into: 'effects' },\n\tarrived: { types: ['pull'], into: 'effects' },\n\tlanded: { types: ['dash'], into: 'effects' },\n\tend: { types: ['missile', 'zone'], into: 'onEnd' }\n}\n\n/**\n * The fields the engine's effects read, by name: each type of effect has those of them it reads (`EffectTypes`, a\n * `Pick` of these), and a game's own type picks of them or says its own\n *\n * @beta\n */\nexport interface EffectFields {\n\t/**\n\t * For `teleport`: where to, however far: the caster's side's home (`homeOf`), where it was aimed, or by its target.\n\t * For `dash`, in a game with the moves pack (`movesPack`): `target` rushes to the unit it was cast on, after it as it\n\t * moves, to its edge (or `through` it); its `effects` happen to it there\n\t */\n\tto?: 'home' | 'point' | 'target'\n\t/**\n\t * For a `dash` to a unit (`to: 'target'`), in a game with the moves pack: it goes on through the unit, this far past\n\t * its middle, along the way from where the caster set off (Yasuo's Sweeping Blade); the place is fixed as it sets off\n\t *\n\t * @beta\n\t */\n\tthrough?: number\n\t/**\n\t * For `dash` and `knockback`, in a game with the moves pack (`movesPack`): what happens to each enemy of the caster\n\t * the one moved meets on its way, once each, in the caster's name, the one met its target and the one moved where they\n\t * go off from (`EffectContext.origin`): Lee Sin's Dragon's Rage (who the kicked one flies into is hurt and thrown up),\n\t * Rammus's Powerball\n\t *\n\t * @beta\n\t */\n\tcollide?: EffectDef[]\n\t/** For `dash` and `knockback` with `collide`: the one moved stops at the first one it meets @beta */\n\tstops?: boolean\n\t/**\n\t * For `knockback`, in a game with the moves pack (`movesPack`): which way it throws (`KnockbackDirection`): `away` from\n\t * where the effects go off from (the caster, or the context's `origin`: what it always did), `aim` the way the ability\n\t * was aimed (Thresh's Flay, Vayne's Condemn, Poppy's charge), `over` the caster to land `distance` beyond it on its\n\t * other side (Singed's Fling: give it a `leap`), or `towards` it, to its edge at the most (a yank)\n\t *\n\t * @beta\n\t */\n\tdirection?: KnockbackDirection\n\t/**\n\t * For `attach`, in a game with the moves pack: who is put on whom: the `caster` on the unit it was cast on (Yuumi's\n\t * You and Me!, when left out) or that unit on the caster (Kalista's Fate's Call)\n\t *\n\t * @beta\n\t */\n\trider?: 'caster' | 'target'\n\t/** For `raiseDead`: the corpses rise as what they were, the caster's (Animate Dead), rather than as its `unit` @beta */\n\tas?: 'themselves'\n\t/** For `onFatal`: the share of its max health the carrier is left with, rather than dying: all of it when left out @beta */\n\thealth?: number\n\t/**\n\t * For `if`: what must hold of the caster (`UnitCondition`, or code), for `effects` to happen rather than `otherwise`\n\t *\n\t * @beta\n\t */\n\tcaster?: UnitCondition | UnitConditionCheck\n\t/**\n\t * For `if`: what must hold of the target (`UnitCondition`, or code): the unit it was cast on, or each one within its\n\t * `radius` or `shape`, where it has one. With no target there, it does not hold\n\t *\n\t * @beta\n\t */\n\ttarget?: UnitCondition | UnitConditionCheck\n\t/**\n\t * How much: of damage, healing, mana, a shield (`buff`). A number, one per level, or code asked for each target\n\t * (`EffectValue`); with what the caster's stats add (`scaling`) and the formulas of `damage`, `heal` and `buff`\n\t * (`byMaxHealth`, `byCurrentHealth`, `byMissingHealth`, `byStacks`, `byDistance`, `targetScaling`) on top\n\t */\n\tamount?: EffectValue\n\t/** Id of the buff to put on the targets */\n\tbuff?: string\n\t/** Unit type, for effects that bring one into the world */\n\tunit?: string\n\t/** For `spawn`: whose it is: the caster's when left out, or the neutral player's (a soul nobody owns) */\n\towner?: 'neutral'\n\t/** For `spawn`: drawn as the target or the caster is (its model, its owner's colour, its size), while it stays what its own type is */\n\tlooksLike?: 'target' | 'caster'\n\t/** For `spawn`: components it starts with, by id, in the form a save keeps them in */\n\tdata?: Record<string, unknown>\n\t/**\n\t * For `spawn`, in a game with the ground objects pack (`groundObjectsPack`): so many along a line (`SpawnLine`),\n\t * buildings one to a cell: Anivia's Crystallize (`across`), Taliyah's Weaver's Wall, Yasuo's Wind Wall, Bard's portals\n\t * (two: one where he stands, one where he aimed)\n\t *\n\t * @beta\n\t */\n\tline?: SpawnLine\n\t/**\n\t * For `spawn`, in a game with the ground objects pack: `count` round a circle of `radius` about where it landed, the\n\t * first the way it was aimed: Jarvan's Cataclysm\n\t *\n\t * @beta\n\t */\n\tring?: { count: number; radius: number }\n\t/**\n\t * For `gain`, in a game with the resources pack (`resourcesPack`): which of the pools (`UnitTypeDef.pools`) of what it\n\t * reaches it fills (or empties, with an `amount` under 0)\n\t *\n\t * @beta\n\t */\n\tpool?: string\n\t/** For `onHit` and `onKill`: only while the carrier carries this buff */\n\twhileBuff?: string\n\t/**\n\t * For `onHit`: only every so many of the carrier's attacks that land (while it carries `whileBuff`, where it says),\n\t * counted on the carrier and saved with it: Jhin's fourth shot, a third strike. Every attack when left out\n\t *\n\t * @beta\n\t */\n\tevery?: number\n\t/**\n\t * For `onHit`: the attack that sets it off uses up one of `whileBuff`'s stacks, the buff for its last (or one that does\n\t * not count them): \"the next attack\" of Power Fist, Siphoning Strike, Nether Blade, Flurry's two. Used up by the\n\t * attack that kills too, after what the kill sets off (`onKill` still sees it)\n\t *\n\t * @beta\n\t */\n\tconsumes?: boolean\n\t/**\n\t * For `onHit`: the slot it takes among what the carrier's attacks set off (its attack modifiers: an orb, a poison, a\n\t * frost), from its abilities, items and buffs alike. Of those that share a slot only one goes off, the one of the\n\t * highest `priority`; those of different slots, and those of none, all add up (`RuleSettings.combat.attackModifiers`)\n\t *\n\t * @beta\n\t */\n\tslot?: string\n\t/**\n\t * For `onHit` with a `slot`: which of those sharing it goes off, the highest first (0 when left out); the first of\n\t * the carrier's abilities, then items, then buffs among equals\n\t *\n\t * @beta\n\t */\n\tpriority?: number\n\t/**\n\t * For the triggers of a passive (`onHit`, `onKill`, `onCast`, `onDamaged`, `onAbilityHit`, `onLowHealth`): seconds\n\t * before it can go off again once it did, kept on the ability's own cooldown (`AbilityState.cooldown`, shown on its\n\t * button) for an ability, on the carrier for an item's or a buff's. Every time when left out\n\t *\n\t * @beta\n\t */\n\tcooldown?: Scaled\n\t/**\n\t * For `onLowHealth`: the part of its max health (0.3: 30%) the carrier's health falls below for it to go off: once\n\t * as it falls past it, not again until it is back above\n\t *\n\t * @beta\n\t */\n\tbelow?: number\n\t/**\n\t * For `onDamaged`: only for an attack that hits from up close (one with no missile: `AttackDef.projectileSpeed`\n\t * left out): Thorns Aura, Spiked Carapace\n\t *\n\t * @beta\n\t */\n\tmelee?: boolean\n\t/**\n\t * For `removeBuff`: how many stacks of `buff` come off: all of it when left out, the buff itself once none is left\n\t *\n\t * @beta\n\t */\n\tstacks?: Scaled\n\t/** For `charged`: what happens when the ability is not charged. For `if`: what happens when its conditions do not hold */\n\totherwise?: EffectDef[]\n\t/** For missiles: buildings and trees in its way stop it, without anything happening to them */\n\tblocked?: boolean\n\t/** For `onKill`: only when it was an attack of the carrier that killed. For `onDamaged`: only when an attack hurt it */\n\tattack?: boolean\n\t/**\n\t * For `refresh`: the ability that is ready again, when it is not the one the effect belongs to. For `grantAbility`\n\t * and `swapAbility`, in a game with the ability changes pack (`abilityChangesPack`): the ability given\n\t */\n\tability?: string\n\t/**\n\t * For `swapAbility`, in a game with the ability changes pack: the caster's ability that gives way, the one the effect\n\t * belongs to when left out\n\t *\n\t * @beta\n\t */\n\tfrom?: string\n\t/**\n\t * For `grantAbility`, `swapAbility` and `stealAbility`, in a game with the ability changes pack: casts of it before it\n\t * is gone (and what it took the place of is back): one for a stolen one when left out, for ever otherwise\n\t *\n\t * @beta\n\t */\n\tuses?: number\n\t/**\n\t * For `grantAbility` and `swapAbility`, in a game with the ability changes pack: the level it is given at: the level of\n\t * what it takes the place of, or the effect's own, when left out\n\t *\n\t * @beta\n\t */\n\tatLevel?: number\n\t/**\n\t * For `stealAbility`, in a game with the ability changes pack: which of the target's abilities it takes: its\n\t * `ultimate` (when left out), its `first`, or one at `random` (`world.rng`)\n\t *\n\t * @beta\n\t */\n\tpick?: 'ultimate' | 'first' | 'random'\n\t/** For `dash`: how high the caster rises on the way, which makes it a leap. For whoever draws it */\n\tleap?: number\n\t/**\n\t * For a leap: how much higher than where it takes off the ground on its way may stand. What stands higher\n\t * is a wall to it: it comes down in front of it. Over anything when left out\n\t */\n\tclimb?: number\n\t/** Seconds the buff lasts, when that is different from its usual duration. In code (`EffectValue`), asked for each target */\n\tduration?: EffectValue\n\t/**\n\t * What the stats of the caster add to the amount: `{ abilityPower: 0.6 }` adds 60% of its ability power.\n\t * `level` is for every level of the hero past the first\n\t */\n\tscaling?: Scaling\n\t/** For damage. Magic when left out */\n\tdamageType?: DamageType\n\t/** For damage: how what it kills dies, for the screen, over the ability's own `how` */\n\thow?: string\n\t/** For missiles: seconds they take shape where they were cast before they set off. The caster is free to go */\n\tdelay?: Scaled\n\t/** For missiles: how fast they travel, in units per second, and how far */\n\tspeed?: number\n\t/** For missiles: how far they fly, in cells */\n\tdistance?: Scaled\n\t/** For missiles: how many are sent, spread over an angle in radians. What one of them hit the others pass by */\n\tcount?: Scaled\n\t/** For missiles: the angle, in radians, the missiles are spread over */\n\tspread?: number\n\t/** For missiles: flies after the unit the ability was cast on, and only hits that one */\n\thoming?: boolean\n\t/**\n\t * For missiles: flies to the spot the ability was aimed at and stops there, `distance` away at the most. For `pull`:\n\t * drags to where the effect landed (a zone's middle, the spot of an `after`) rather than to the caster\n\t */\n\ttoPoint?: boolean\n\t/** For missiles: how far the team of the caster sees around it */\n\tsight?: number\n\t/**\n\t * What happens to what is hit. For missiles: everything they pass through. For `onHit`: the target of an attack.\n\t * For `dash`: what is around where it ends. For `pull`: what was pulled, as it arrives. For `after`: what is there when the time is up. For `zone`: what is inside, over and over\n\t */\n\teffects?: EffectDef[]\n\t/** For missiles that were not stopped, and for zones: what happens where and when they end */\n\tonEnd?: EffectDef[]\n\t/**\n\t * For `after`: the name its arrival goes by for whoever draws it and plays its sound, where one ability sets off\n\t * several that do not look alike: the last of a barrage. The ability's own when left out\n\t */\n\timpact?: string\n\t/**\n\t * For missiles: goes on after it hit something. False for the ones that are used up by the first thing in their way;\n\t * a number for those that go through so many and are used up by the next (1: Lux's Light Binding, two at the most)\n\t */\n\tpierce?: boolean | number\n\t/**\n\t * For missiles that go through what they hit (`pierce`): what part of the amounts each one it went through takes off\n\t * the next (0.3: a third less on the second, less again on the third). Read by `damage`, `heal` and `mana` (`share`)\n\t *\n\t * @beta\n\t */\n\tfalloff?: number\n\t/**\n\t * For missiles that come back (`returns`): on the way back they hit what they pass through again, each once more\n\t * (Ahri's Orb of Deception); the caster's place is still where it ends\n\t *\n\t * @beta\n\t */\n\thitsOnReturn?: boolean\n\t/**\n\t * For missiles: they find their own targets: while one flies with nobody to go after, it turns after the nearest it may\n\t * hit within this far of it and flies after that one (Fox-Fire, Dance of Arrows); another, if that one is gone first\n\t *\n\t * @beta\n\t */\n\tseek?: number\n\t/**\n\t * For missiles: what happens where it meets a wall (ground it cannot cross, a cliff above where it set off, the edge of\n\t * the play area, a building or a tree): it stops there, and these go off there, to the last one it hit where there is\n\t * one (Bard's Cosmic Binding). For `dash` and `knockback`, in a game with the moves pack (`movesPack`): the one moved\n\t * stops at such a wall (what flies meets none), and these go off there in the caster's name, to the one moved\n\t * (Vayne's Condemn, Poppy's Heroic Charge)\n\t *\n\t * @beta\n\t */\n\tonWall?: EffectDef[]\n\t/**\n\t * For missiles: what goes off from where it is, the way it flew, once it is done (it hit what used it up, reached\n\t * whom it flew after, or came to the end of its way) or is split by the game (`splitMissile`): missiles in it fly on\n\t * from there at their own `spread` (Vel'Koz's Plasma Fission: two at a half turn's spread, a quarter either side)\n\t *\n\t * @beta\n\t */\n\tsplit?: EffectDef[]\n\t/**\n\t * For missiles: turned by their owner as they fly, towards the point the `steer` command gives (`steerMissile`), at most\n\t * `rate` radians a second (π when left out): Yuumi's Prowling Projectile, Viktor's storm\n\t *\n\t * @beta\n\t */\n\tsteer?: { rate?: number }\n\t/**\n\t * For `zone`: goes with a unit, the `caster` or the `target`, and faces the way it does; it ends (with its `onEnd`) when\n\t * that one dies or leaves the world\n\t *\n\t * @beta\n\t */\n\tfollow?: 'caster' | 'target'\n\t/**\n\t * For `zone`: what happens to each who comes into it (its own `radius` or `shape`, as `affects` says), those inside as\n\t * it is laid included. Each in it is seen to every round of the world, not four times a second\n\t *\n\t * @beta\n\t */\n\tonEnter?: EffectDef[]\n\t/** For `zone`: what happens to each who goes out of it, alive @beta */\n\tonLeave?: EffectDef[]\n\t/**\n\t * For `zone`: what happens to each who crosses its edge, in or out, once it is laid (Veigar's Event Horizon, Thresh's\n\t * Box): those inside as it is laid have not crossed it\n\t *\n\t * @beta\n\t */\n\tedge?: EffectDef[]\n\t/**\n\t * For missiles: once done (it hit what used it up or what it flew after, came to the end of its way, or came down)\n\t * it flies back to the caster, after it wherever it goes, and touches nobody on the way; its `onEnd` happens where\n\t * the caster is when it gets there, not where it turned. Gone, with nothing more, if the caster is\n\t *\n\t * @beta\n\t */\n\treturns?: boolean\n\t/**\n\t * For `pull`: how long the drag takes, from where the target is to where it ends. Its speed is set by it as it\n\t * starts: a caster that walks off makes it take longer\n\t *\n\t * @beta\n\t */\n\tseconds?: Scaled\n\t/**\n\t * For missiles: thrown, not shot. It goes `height` up in the middle of its way and comes down at its end, `time`\n\t * seconds after it set off however far that is (`speed` otherwise). It flies over everything, and what is within\n\t * its `radius` where it comes down is what it hits\n\t */\n\tarc?: { height: number; time?: number }\n\t/**\n\t * For missiles: where it would be done (it reached its target, was used up by what it hit, came down, or came to\n\t * the end of its way) it springs on to the nearest thing it may hit within `range` that it has not hit yet, and\n\t * flies after that one, `count` times. Every spring takes `falloff` of the amounts off what it does (0.25: a\n\t * quarter less each time). Its `onEnd` is where it is done for good\n\t */\n\tbounce?: { count: Scaled; range: number; falloff?: number }\n\t/** For `buff`: adds one to how many of it the target carries instead of renewing it, up to what the buff allows */\n\tstack?: boolean\n\t/** For `exchange`: the resource the caster's owner trades away, by id */\n\tsell?: string\n\t/** For `exchange`: the resource the caster's owner trades for, by id */\n\tbuy?: string\n\t/** For `exchange`: how much of `buy` comes for each one of `sell` (0.5: 100 lumber for 50 gold) */\n\trate?: number\n\t/**\n\t * For `damage`: a part of what the target has lost of its health, added to the amount for each it hits (0.1: a tenth\n\t * of its missing health), worked out as it lands\n\t *\n\t * @beta\n\t */\n\tbyMissingHealth?: Scaled\n\t/**\n\t * For `damage`, `heal` and a shield (`buff`): a part of the target's maximum health, added for each it reaches (0.08:\n\t * 8% of its max health). Death and Decay, a % health nuke\n\t *\n\t * @beta\n\t */\n\tbyMaxHealth?: Scaled\n\t/**\n\t * For `damage`, `heal` and a shield (`buff`): a part of the health the target has now, added for each it reaches\n\t *\n\t * @beta\n\t */\n\tbyCurrentHealth?: Scaled\n\t/**\n\t * For `damage`, `heal` and a shield (`buff`): `amount` more for each stack of `buff` on the target (`of: 'target'`,\n\t * when left out) or the caster: Rend's spears, a passive's marks\n\t *\n\t * @beta\n\t */\n\tbyStacks?: { buff: string; of?: 'target' | 'caster'; amount: Scaled }\n\t/**\n\t * For `damage`, `heal` and a shield (`buff`): the whole of it times 1 and `per` for every unit of distance from where\n\t * it went off to the target (a missile's way, or from the caster or the `origin`), `most` times at the most: a\n\t * javelin that hurts more the farther it flew\n\t *\n\t * @beta\n\t */\n\tbyDistance?: { per: number; most?: number }\n\t/**\n\t * For `damage`, `heal` and a shield (`buff`): parts of the target's stats added (`{ armor: 1 }`: as much as its armor;\n\t * `{ health: 0.05 }`: 5% of its max health), as `scaling` adds the caster's\n\t *\n\t * @beta\n\t */\n\ttargetScaling?: Partial<Record<StatKey, Scaled>>\n\t/**\n\t * For `damage`, `heal` and a shield (`buff`) a trigger sets off: a part of the damage that set it off\n\t * (`EffectContext.damage`), added (0.2: a fifth of it): Spiked Carapace's returned damage, a heal by what was taken\n\t *\n\t * @beta\n\t */\n\tbyDamage?: Scaled\n\t/**\n\t * For `morph`: the unit type the caster turns into where it stands, a hero's form (`HeroDef.forms`)\n\t *\n\t * @beta\n\t */\n\tinto?: string\n\t/**\n\t * For `morph`: the form lasts until the ability is cast again in it, which turns it back (a toggle); with a\n\t * `duration` too, until whichever comes first\n\t *\n\t * @beta\n\t */\n\ttoggle?: boolean\n\t/**\n\t * For `morph`: what turns the form back (`MorphBack`): the ability cast again, its `duration` up, its death. All\n\t * three when left out (the ability only with `toggle`); without `ability`, the ability cast again in the form starts\n\t * its time over\n\t *\n\t * @beta\n\t */\n\tback?: MorphBack[]\n}\n\n/**\n * The fields of the formulas an amount of `damage`, `heal` and a shield (`buff`) may add to it, for each target as it\n * lands (`effectAmount`)\n *\n * @beta\n */\nexport type AmountFormula = 'byMissingHealth' | 'byMaxHealth' | 'byCurrentHealth' | 'byStacks' | 'byDistance' | 'targetScaling' | 'byDamage'\n\n/**\n * The types of effect there are, each with the fields it reads: the engine's, and a game's own, added by declaration\n * merging as it defines them (`declare module '@v12-engine/engine' { interface EffectTypes { arrowStun: { ... } } }`,\n * with `defineEffect`)\n *\n * @beta\n */\nexport interface EffectTypes {\n\t/** Hurts what it reaches: `amount`, with what of the caster's stats adds to it (`scaling`), of a type (magic when left out) */\n\tdamage: Pick<EffectFields, 'amount' | 'scaling' | 'damageType' | 'how' | AmountFormula>\n\t/** Heals what it reaches, more for the caster's heal and shield power */\n\theal: Pick<EffectFields, 'amount' | 'scaling' | AmountFormula>\n\t/** Gives mana to what it reaches */\n\tmana: Pick<EffectFields, 'amount' | 'scaling'>\n\t/**\n\t * Fills a pool of what it reaches (`pool`, one of `UnitTypeDef.pools`) by `amount` (empties it, under 0), in a game\n\t * with the resources pack (`resourcesPack`): allies when it says nothing, the caster with `on: 'caster'` (Tryndamere's\n\t * fury from an `onHit`)\n\t *\n\t * @beta\n\t */\n\tgain: { pool: string } & Pick<EffectFields, 'amount' | 'scaling'>\n\t/**\n\t * Does something to the grass and bushes where it lands, in a game with the foliage pack (`foliagePack`): sets it\n\t * alight (`ignite`, by the caster), puts it out (`extinguish`), ruins it (`ruin`, as `how` says: `cut` when left\n\t * out), has it grow back (`regrow`, over `over` seconds) or takes it away (`clear`). Over its `radius` or `shape`,\n\t * the cell it landed on when it has neither; on `layer`, every layer of the pack when left out. It acts on cells, not\n\t * on what stands there: the fields of whom (`affects`, `kinds`, `tags`, `where`, `limit`...) say nothing to it. A\n\t * fire arrow, a mower, a rain spell\n\t *\n\t * @beta\n\t */\n\tfoliage: { act: 'ignite' | 'extinguish' | 'ruin' | 'regrow' | 'clear'; layer?: string; how?: 'cut' | 'crush' | 'scorch'; over?: number }\n\t/**\n\t * Sets alight what burns where it lands, by the caster (`light`), or puts it out (`putOut`), in a game with the\n\t * burning pack (`burningPack`): over its `radius` or `shape`, else the unit it was cast on, else what stands where it\n\t * landed. `how`: the kind of burning it sets off (a blight, frost: the look's `burning.how` and the death's), the\n\t * thing's own when left out; `seconds`: how long it burns. Of what it finds, what its fields of whom say (`affects`:\n\t * `enemies` lights the caster's enemies' alone; `kinds`, `tags`, `layers`, `where`, `sort`, `limit`), everything\n\t * that burns, trees among it, when it says none. A fire arrow, a torch, a rain spell\n\t *\n\t * @beta\n\t */\n\tburn: { act: 'light' | 'putOut'; how?: string; seconds?: number }\n\t/**\n\t * Puts a buff on what it reaches: for its own time or `duration`, one more of it with `stack`. With an `amount` (and\n\t * `scaling`, the formulas), its shield holds that rather than the buff's own `shield`\n\t */\n\tbuff: { buff: string } & Pick<EffectFields, 'duration' | 'stack' | 'amount' | 'scaling' | AmountFormula>\n\t/** Sends a missile: how fast, how far, how many, and what it does to what it passes through and where it ends */\n\tmissile: Pick<\n\t\tEffectFields,\n\t\t| 'speed'\n\t\t| 'distance'\n\t\t| 'count'\n\t\t| 'spread'\n\t\t| 'homing'\n\t\t| 'toPoint'\n\t\t| 'delay'\n\t\t| 'sight'\n\t\t| 'blocked'\n\t\t| 'pierce'\n\t\t| 'arc'\n\t\t| 'bounce'\n\t\t| 'effects'\n\t\t| 'onEnd'\n\t\t| 'returns'\n\t\t| 'falloff'\n\t\t| 'hitsOnReturn'\n\t\t| 'seek'\n\t\t| 'onWall'\n\t\t| 'split'\n\t\t| 'steer'\n\t>\n\t/** A passive's buff on what is around the carrier, kept up by the ability system */\n\taura: { buff: string }\n\t/**\n\t * Brings a unit into the world where it landed, the caster's (the neutral player's with `owner`), for `duration` seconds\n\t * or for good, with `data` and the looks of the target or the caster. In a game with the ground objects pack\n\t * (`groundObjectsPack`): so many along a `line` or round a `ring`, each knowing who put it down (`madeBy`)\n\t */\n\tspawn: { unit: string } & Pick<EffectFields, 'duration' | 'owner' | 'looksLike' | 'data' | 'line' | 'ring'>\n\t/** Puts a buff on the caster for as long as it likes, or takes it off */\n\ttoggle: { buff: string }\n\t/** The caster's team sees the spot for a while */\n\treveal: Pick<EffectFields, 'duration'>\n\t/**\n\t * A passive's (an ability's, an item's or a buff's: `BuffDef.passive`): `effects` happen to the target of every attack\n\t * of the carrier that lands, while it carries `whileBuff`; of every `every`th, using up a stack of `whileBuff` with\n\t * `consumes`, once in `cooldown` seconds\n\t */\n\tonHit: Pick<EffectFields, 'whileBuff' | 'effects' | 'every' | 'consumes' | 'cooldown' | 'slot' | 'priority'>\n\t/** The caster is ready to strike again at once */\n\tresetAttack: object\n\t/** The caster is elsewhere at once, `distance` away at the most */\n\tblink: Pick<EffectFields, 'distance'>\n\t/** The caster is elsewhere at once, however far (`to`) */\n\tteleport: Pick<EffectFields, 'to'>\n\t/**\n\t * The caster rushes to the spot (a leap with `leap`), and `effects` happen around where it ends. In a game with the\n\t * moves pack (`movesPack`): to a unit (`to: 'target'`, after it as it moves, or `through` it), with what happens to who\n\t * it meets (`collide`, `stops`) and at a wall (`onWall`)\n\t */\n\tdash: Pick<EffectFields, 'distance' | 'leap' | 'climb' | 'speed' | 'effects' | 'buff' | 'to' | 'through' | 'collide' | 'stops' | 'onWall'>\n\t/**\n\t * Throws what it reaches `distance` away from the caster. In a game with the moves pack (`movesPack`): which way\n\t * (`direction`), with what happens to who the thrown one meets (`collide`, `stops`) and at a wall (`onWall`)\n\t */\n\tknockback: Pick<EffectFields, 'distance' | 'speed' | 'leap' | 'direction' | 'collide' | 'stops' | 'onWall'>\n\t/**\n\t * The caster and the unit it was cast on trade places, at once, in a game with the moves pack (`movesPack`). Nothing\n\t * where either is a structure, rushing or dragged, or the target cannot be moved (`BuffDef.unstoppable`)\n\t *\n\t * @beta\n\t */\n\tswap: object\n\t/**\n\t * Sends the unit the effect goes off from (a proxy of the caster's: `EffectCommon.origin`) to where it was aimed, at\n\t * `speed` (at once when left out), and its `effects` happen where it arrives, in the caster's name, from it: Orianna's\n\t * ball flown to where she aims, Azir's soldiers sent. Nothing where it goes off from the caster\n\t *\n\t * @beta\n\t */\n\tsendProxy: Pick<EffectFields, 'speed' | 'effects'>\n\t/**\n\t * The caster's team sees each unit it reaches for `duration` seconds (4 when left out), wherever it goes: in the fog,\n\t * in a bush, invisible or camouflaged, in a game with the vision pack (`visionPack`). A unit, not a spot (`reveal`):\n\t * Rengar's Thrill of the Hunt on the champions about him, Pyke's Death from Below, a Dust of Appearance\n\t *\n\t * @beta\n\t */\n\trevealUnit: Pick<EffectFields, 'duration'>\n\t/**\n\t * One unit rides another, in a game with the moves pack (`movesPack`): the `rider` (the caster, or the unit it was\n\t * cast on) is out of the world (`World.setHidden`: not found, not hit, in nobody's way) and goes where its host goes,\n\t * until the host dies or leaves the world, `duration` seconds are up, or whoever cast it casts the ability again (on the\n\t * host, or with a point: the ability's cooldown starts then). Then it is back where its host is, and `onEnd` happens in\n\t * the rider's name, at the point the recast gave (where it is otherwise), the host its target: Yuumi's You and Me!,\n\t * Kalista's Fate's Call (the ally thrown where she aims)\n\t *\n\t * @beta\n\t */\n\tattach: Pick<EffectFields, 'rider' | 'duration' | 'onEnd'>\n\t/**\n\t * Drags what it reaches to the caster's edge (or to where it landed, `toPoint`) over `seconds`, after the caster as it\n\t * moves; `effects` happen to it as it arrives, in the caster's name. While dragged it does nothing of its own (its\n\t * orders wait, it casts nothing, uses nothing) and nothing else moves it (a knockback, a dash). Who is rushing\n\t * somewhere already, and structures, are not pulled\n\t *\n\t * @beta\n\t */\n\tpull: Pick<EffectFields, 'seconds' | 'toPoint' | 'effects'>\n\t/** An ability of the caster is ready again: `ability`, or the one the effect belongs to */\n\trefresh: Pick<EffectFields, 'ability'>\n\t/** A passive's: `effects` happen around whoever the carrier kills (by an attack, with `attack`; while it carries `whileBuff`) */\n\tonKill: Pick<EffectFields, 'attack' | 'whileBuff' | 'effects' | 'cooldown'>\n\t/** A passive's: `effects` happen to the carrier whenever it casts */\n\tonCast: Pick<EffectFields, 'effects' | 'cooldown'>\n\t/**\n\t * Gives what it reaches an ability (`ability`) at `atLevel` (the effect's level), for `duration` seconds or `uses`\n\t * casts, or for good, in a game with the ability changes pack (`abilityChangesPack`): allies when it says nothing\n\t *\n\t * @beta\n\t */\n\tgrantAbility: { ability: string } & Pick<EffectFields, 'atLevel' | 'duration' | 'uses'>\n\t/**\n\t * The caster's ability `from` (the one the effect belongs to) gives way to `ability` in its place on the card, at its\n\t * level (or `atLevel`), for `duration` seconds or `uses` casts, then back; for good with neither. In a game with the\n\t * ability changes pack: a stance, an awakened ability, a weapon of a set\n\t *\n\t * @beta\n\t */\n\tswapAbility: { ability: string } & Pick<EffectFields, 'from' | 'atLevel' | 'duration' | 'uses'>\n\t/**\n\t * Takes one of the abilities of the unit it was cast on (`pick`: its ultimate when left out) and puts it in the place\n\t * of the one the effect belongs to, at that one's level, for `uses` casts (one when left out) or `duration` seconds,\n\t * then back: Sylas's Hijack. In a game with the ability changes pack\n\t *\n\t * @beta\n\t */\n\tstealAbility: Pick<EffectFields, 'pick' | 'duration' | 'uses'>\n\t/**\n\t * What it reaches becomes the caster's owner's (`World.setOwner`), for `duration` seconds or for good: Charm,\n\t * Dominate. Heroes and structures are left as they are. In a game with the ability changes pack\n\t *\n\t * @beta\n\t */\n\tconvert: Pick<EffectFields, 'duration'>\n\t/**\n\t * A passive's: `effects` happen to whoever hurt the carrier (by an attack with `attack`, from up close with `melee`),\n\t * in the carrier's name, the damage it took in `EffectContext.damage` (`byDamage`): Thorns Aura, Frost Armor, Spiked\n\t * Carapace, Defensive Ball Curl. Not for damage a trigger's effects did: two of them never echo\n\t *\n\t * @beta\n\t */\n\tonDamaged: Pick<EffectFields, 'attack' | 'melee' | 'effects' | 'cooldown'>\n\t/**\n\t * A passive's: `effects` happen to an enemy an ability of the carrier hurt, each time one does (not its attacks, not\n\t * a trigger's effects), the damage in `EffectContext.damage`: Essence Theft, Phenomenal Evil\n\t *\n\t * @beta\n\t */\n\tonAbilityHit: Pick<EffectFields, 'effects' | 'cooldown'>\n\t/**\n\t * A passive's: `effects` happen to the carrier once its health falls below `below` of its max (as it falls past it),\n\t * once in `cooldown` seconds: Mana Barrier\n\t *\n\t * @beta\n\t */\n\tonLowHealth: Pick<EffectFields, 'below' | 'effects' | 'cooldown'>\n\t/**\n\t * A passive's: instead of dying of a blow or a kill, the carrier is left with `health` of its max (all of it when\n\t * left out) and `effects` happen to it, in its name, once in `cooldown` seconds: Reincarnation, Guardian Angel (an\n\t * item's), Anivia's Rebirth (a `morph` into the egg), Zilean's Chronoshift (a buff's)\n\t *\n\t * @beta\n\t */\n\tonFatal: Pick<EffectFields, 'health' | 'effects' | 'cooldown'>\n\t/**\n\t * Takes `buff` off what it reaches: `stacks` of it, or all of it (every one of it there is) when left out. A mark\n\t * popped, stacks spent\n\t *\n\t * @beta\n\t */\n\tremoveBuff: { buff: string } & Pick<EffectFields, 'stacks'>\n\t/**\n\t * Takes off what holds them up from what it reaches (allies when it says nothing): harmful stuns, roots, silences,\n\t * disarms, controls, grounds and slows, not a suppression nor being thrown up (`isCleansable`): Remove Scurvy\n\t *\n\t * @beta\n\t */\n\tcleanse: object\n\t/** `effects` when the ability went off charged, `otherwise` when it did not */\n\tcharged: Pick<EffectFields, 'effects' | 'otherwise'>\n\t/**\n\t * `effects` when what it asks holds, `otherwise` when it does not: of the `caster` and of the `target`\n\t * (`UnitCondition`: a buff, health below a share, a hero, tags, enemy or ally; or code) and by `chance`. On the unit it\n\t * was cast on, or, with a `radius` or `shape`, on each within it (as `affects` says, enemies when it says nothing),\n\t * each then the target of what it does. Execute below 20%, Holy Light on the undead, Bash's chance (`conditionHolds`)\n\t *\n\t * @beta\n\t */\n\tif: Pick<EffectFields, 'caster' | 'target' | 'effects' | 'otherwise'>\n\t/** `effects` happen at the spot, `delay` seconds from now */\n\tafter: Pick<EffectFields, 'delay' | 'effects' | 'impact'>\n\t/** For `duration` seconds `effects` happen to what is at the spot, over and over, and `onEnd` at the end */\n\tzone: Pick<EffectFields, 'duration' | 'effects' | 'onEnd' | 'follow' | 'onEnter' | 'onLeave' | 'edge'>\n\t/** Finds what is invisible around the spot: the caster's team sees it for `duration` seconds */\n\tdetect: Pick<EffectFields, 'duration'>\n\t/** Raises `count` of the corpses around the spot as units of `unit`, for `duration` seconds or for good */\n\traiseDead: { unit?: string } & Pick<EffectFields, 'duration' | 'count' | 'as'>\n\t/**\n\t * Brings back the corpses of the caster's side around the spot (within `radius`, 6) as what they were, their owners'\n\t * again and whole, `count` of them at most (all when left out): Resurrection\n\t *\n\t * @beta\n\t */\n\trevive: Pick<EffectFields, 'count'>\n\t/**\n\t * Makes `count` copies of the target, for `duration` seconds: they deal `dealt` of its damage (a third when left out)\n\t * and take `taken` times what they are dealt (twice when left out)\n\t */\n\tillusion: Pick<EffectFields, 'count' | 'duration'> & { dealt?: number; taken?: number }\n\t/**\n\t * Brings `count` (1) units of `unit` around where it landed, `spread` cells from it (1.5), for `lifetime` seconds (for\n\t * good when left out): the caster's summons (`summoned`). With nothing to attack they walk with the caster (`follow`,\n\t * true); `aggro` says whom they go for (`mastersAttacker` when left out: whoever hits the caster, then the nearest);\n\t * they die with the caster unless `diesWithMaster` is false\n\t *\n\t * @beta\n\t */\n\tsummon: { unit: string } & Pick<EffectFields, 'count'> & {\n\t\t\tlifetime?: Scaled\n\t\t\tspread?: number\n\t\t\tfollow?: boolean\n\t\t\taggro?: 'nearest' | 'mastersAttacker' | 'none'\n\t\t\tdiesWithMaster?: boolean\n\t\t}\n\t/** Takes the buffs off what it reaches, and hurts what is summoned by `amount` */\n\tdispel: Pick<EffectFields, 'amount'>\n\t/**\n\t * Turns the caster into another unit type where it stands (`into`), a form (`takeForm`): its level, experience,\n\t * items, buffs and the share of its health and mana kept, what it was told going on, and the form's abilities\n\t * learned at the levels its form says (`HeroDef.forms`). For `duration` seconds, or until cast again (`toggle`), or\n\t * both; `back` says what turns it back\n\t *\n\t * @beta\n\t */\n\tmorph: { into: string } & Pick<EffectFields, 'duration' | 'toggle' | 'back'>\n\t/**\n\t * Trades `amount` of a resource of the caster's owner (`sell`) for another (`buy`), `rate` of it for each one sold:\n\t * a marketplace's (`presetMarket`, `exchange` in code). Nothing of it with less than `amount` to sell\n\t */\n\texchange: { sell: string; buy: string; rate: number; amount: Scaled }\n\t/**\n\t * A tome's, in a game with the tomes pack (`tomesPack`): what it reaches gains `gain` for good (a point of strength),\n\t * a hero `xp` experience and `levels` levels\n\t */\n\ttome: { gain?: StatChange; xp?: number; levels?: number }\n\t/**\n\t * Mana burn, in a game with its pack (`manaBurnPack`): takes `amount` of the mana of what it reaches, and hurts it by\n\t * as much as it took, times `ratio` (1 when left out), magic damage unless `damageType` says\n\t */\n\tmanaBurn: Pick<EffectFields, 'amount' | 'scaling' | 'damageType'> & { ratio?: number }\n\t/**\n\t * A town portal, in a game with the portals pack (`portalsPack`): the caster and as many as `count` (12 when left out)\n\t * of its own units within `radius` (7) of it are at once at its side's home nearest where it was aimed (`homeOf`)\n\t */\n\ttownPortal: Pick<EffectFields, 'count'>\n\t/**\n\t * A passive's, in a game with the default items (`defaultItemsPack`): keeps `buff` on the allies within `radius` of\n\t * the carrier (itself too) while the carrier does not carry `spent`: Dawnmender's ward, whose `onFatal` spends it\n\t * (`wardSpent`)\n\t *\n\t * @beta\n\t */\n\tallyWard: { buff: string; spent: string }\n\t/**\n\t * Of a ward's trigger (`allyWard`), on the ally it saved: puts `spent` on whoever gave the ward for `duration`\n\t * seconds and takes the ward (`buff`) off everyone it gave it to: one save a while, for all of them\n\t *\n\t * @beta\n\t */\n\twardSpent: { buff: string; spent: string } & Pick<EffectFields, 'duration'>\n\t/**\n\t * The caster's abilities are ready again: the ones it learns (`HeroDef.learns`), not its ultimate unless `ultimate`,\n\t * not what its items do. Nightfang's kill. In a game with the default items\n\t *\n\t * @beta\n\t */\n\trefreshAbilities: { ultimate?: boolean }\n\t/**\n\t * A passive's: the caster's ability `spell` (by id, a hero spell's: `reap`) cools down `part` faster (0.5: half\n\t * again). Nothing for a caster without it. In a game with the default items\n\t *\n\t * @beta\n\t */\n\tquicken: { spell: string; part: number }\n\t/**\n\t * A passive's: `buff` on the carrier while it is out of fights, neither hurt nor attacking for `after` seconds (5\n\t * when left out): Shadow Cowl's, Wanderer's Boots' speed. In a game with the default items\n\t *\n\t * @beta\n\t */\n\toutOfFights: { buff: string; after?: number }\n\t/**\n\t * Gives the caster's owner `amount` of the game's currency: a kill near the Ring of the Old King. In a game with the\n\t * default items\n\t *\n\t * @beta\n\t */\n\treward: Pick<EffectFields, 'amount'>\n\t/**\n\t * A passive's: a `unit` of the carrier's at its side at night, its summon (`summoned`), gone by day: Wolfhide Charm.\n\t * In a game with the default items\n\t *\n\t * @beta\n\t */\n\tnightCompanion: { unit: string }\n}\n\n/**\n * One thing an ability does: its `type`, which picks the handler and says which fields it has (`EffectTypes`)\n *\n * @public\n */\nexport type EffectDef = { [K in keyof EffectTypes]: { type: K } & EffectCommon & EffectTypes[K] }[keyof EffectTypes]\n\n/**\n * An effect seen as any type may be, every field of the engine's by its name: for what reads effects of every type\n * alike (an ability's tooltip numbers, the rules' check of what they name). A handler reads its own type's\n * (`EffectOf`)\n *\n * @beta\n */\nexport type AnyEffect = { type: keyof EffectTypes } & EffectCommon & Partial<EffectFields>\n\n/**\n * An effect as any type may be (`AnyEffect`), its fields by name\n *\n * @beta\n */\nexport const anyEffect = (effect: EffectDef): AnyEffect => effect as AnyEffect\n\n/**\n * The effects inside an effect, whatever its type: what it does to what it hits (`effects`), when it is not charged\n * (`otherwise`), and at its end (`onEnd`)\n *\n * @internal\n */\nexport function innerEffects(effect: EffectDef): EffectDef[] {\n\tconst { effects, otherwise, onEnd } = anyEffect(effect)\n\treturn [...(effects ?? []), ...(otherwise ?? []), ...(onEnd ?? [])]\n}\n\n/** An effect of a chain as it is being lowered: what waits on it, by the list it goes into */\ninterface ChainLink {\n\teffect: EffectDef\n\t/** The effect as the list has it, before its `when` was taken off */\n\twritten: EffectDef\n\twaiting?: Partial<Record<'effects' | 'onEnd', ChainLink[]>>\n}\n\n/** The effects a chain made (`lowerChain`), each to the effect it was made from as the list has it: what the screen is told */\nconst loweredFrom = new WeakMap<EffectDef, EffectDef>()\n/** The lists a chain made, each to the effect whose it is as the list has it */\nconst loweredLists = new WeakMap<readonly EffectDef[], EffectDef>()\n\n/**\n * The effect a list a chain made is of (`lowerChain`), as its ability has it: none for a list as written\n *\n * @internal\n */\nexport const loweredListOf = (list: readonly EffectDef[]): EffectDef | undefined => loweredLists.get(list)\n\n/**\n * The effect as its ability has it, for one a chain made (`lowerChain` copies what waits, and what it waits on): the\n * effect itself otherwise\n *\n * @internal\n */\nexport const writtenEffect = (effect: EffectDef): EffectDef => loweredFrom.get(effect) ?? effect\n\n/**\n * A list of effects as it runs (`EffectCommon.when`): every effect that waits for a moment taken out of the list and\n * put at the end of the list of the nearest one before it that comes to that moment (a missile's `effects` for `hit`,\n * its `onEnd` for `end`), copied; what waits on what waits itself goes in there. The list itself when nothing in it\n * waits, so the nested shape (`{ type: 'missile', effects: [...] }`) and a chain are one thing by the time they run.\n * One with nothing to wait on is dropped, and `orphan` told of it by its index in the list\n *\n * @beta\n */\nexport function lowerChain(effects: readonly EffectDef[], orphan?: (index: number, effect: EffectDef) => void): EffectDef[] {\n\tif (!effects.some((effect) => effect.when)) return effects as EffectDef[]\n\tconst top: ChainLink[] = []\n\tconst seen: ChainLink[] = []\n\teffects.forEach((effect, index) => {\n\t\tconst link: ChainLink = { effect, written: effect }\n\t\tif (!effect.when) {\n\t\t\ttop.push(link)\n\t\t\tseen.push(link)\n\t\t\treturn\n\t\t}\n\t\tconst moment = Object.hasOwn(EFFECT_MOMENTS, effect.when) ? EFFECT_MOMENTS[effect.when] : undefined\n\t\tlet on: ChainLink | undefined\n\t\tfor (let i = seen.length - 1; i >= 0 && moment && !on; i--) if (moment.types.includes(seen[i].effect.type)) on = seen[i]\n\t\tif (!on || !moment) {\n\t\t\torphan?.(index, effect)\n\t\t\treturn\n\t\t}\n\t\tconst { when: _, ...now } = effect\n\t\tlink.effect = now as EffectDef\n\t\ton.waiting ??= {}\n\t\t;(on.waiting[moment.into] ??= []).push(link)\n\t\tseen.push(link)\n\t})\n\tconst made = (link: ChainLink): EffectDef => {\n\t\tif (link.effect !== link.written) loweredFrom.set(link.effect, link.written)\n\t\tif (!link.waiting) return link.effect\n\t\tconst copy = { ...anyEffect(link.effect) }\n\t\tfor (const [into, links] of Object.entries(link.waiting) as ['effects' | 'onEnd', ChainLink[]][])\n\t\t\tcopy[into] = [...(copy[into] ?? []), ...links.map(made)]\n\t\tloweredFrom.set(copy as EffectDef, link.written)\n\t\tfor (const into of Object.keys(link.waiting) as ('effects' | 'onEnd')[]) loweredLists.set(copy[into]!, link.written)\n\t\treturn copy as EffectDef\n\t}\n\treturn top.map(made)\n}\n\n/**\n * An effect of one type\n *\n * @beta\n */\nexport type EffectOf<K extends keyof EffectTypes> = { type: K } & EffectCommon & EffectTypes[K]\n\n/**\n * The ground an ability covers: what the player aims with, and what is shown when it goes off\n *\n * @beta\n */\nexport type AimShape =\n\t| { shape: 'circle'; radius: number }\n\t| { shape: 'line'; length: number; width: number }\n\t/** A fan from the caster: `angle` is how wide it opens, in radians */\n\t| { shape: 'cone'; length: number; angle: number }\n\t/** A ring at the spot: what is `radius` away and up to `width` closer, not what is in the middle */\n\t| { shape: 'ring'; radius: number; width: number }\n\t/** A stretch of a ring around the caster, `radius` away, `angle` wide (radians) and `width` thick, its middle the way it is aimed */\n\t| { shape: 'arc'; radius: number; angle: number; width: number }\n\t/** A rectangle around the spot, `length` long the way it is aimed and `width` out on either side */\n\t| { shape: 'rect'; length: number; width: number }\n\t/** An X at the spot: two bars `length` long and `width` out on either side, crossing square, each turned an eighth from the way it is aimed */\n\t| { shape: 'cross'; length: number; width: number }\n\n/**\n * The definition of an ability: how it is aimed, what it costs and the effects it has\n *\n * @public\n */\nexport interface AbilityDef {\n\t/** The ability's id, shared by every game: give it a prefix of the game's */\n\tid: string\n\t/** What the player sees the ability called */\n\tname: string\n\t/**\n\t * How what its damage kills dies, for the screen (`'burnt'`, `'frozen'`, `'blasted'`): the death's `how`, which the\n\t * view shows its way. A word, or one decided for each blow: by its level, its caster, what it hit. An effect's own\n\t * (`EffectDef.how`) goes over it; the `death` hook has the last say\n\t */\n\thow?: string | ((hit: { caster: Entity; target: Entity; level: number; amount: number }) => string | undefined)\n\t/**\n\t * The definition this one is a copy of, made from the data (`copyOf` in a `data.json`, the editor's Copy as new):\n\t * what it is drawn, heard and pictured as where the game gives it no look of its own\n\t */\n\tbasedOn?: string\n\t/**\n\t * What it does, in words: a template with values in braces, worked out for the caster as it is now (\"Deals {damage}\n\t * magic damage\" shows \"Deals 80 (50 + 60% ability power) magic damage\"). The values are its own (`values`), or found\n\t * in its effects: `damage`, `heal`, `shield`, `amount`, `duration`, `radius`, `chance` (in percent), `range`, `cooldown`, `charges`, `refill`,\n\t * `mana`, `count`, `distance` (see `abilityValues`)\n\t */\n\tdescription?: string\n\t/** Values of its own to put in its description, by name: an amount and what of the caster scales it, or worked out in code */\n\tvalues?: Record<string, AbilityValueDef>\n\t/** What it does, said in code instead of `description`: words with `{values}` in them, or words and values already put together */\n\tdescribe?: (context: AbilityTextContext) => string | TextSegment[]\n\t/** The key that casts it from the command card */\n\thotkey?: string\n\t/**\n\t * none: happens at once. unit, point: needs a target, and the caster walks into range of it.\n\t * direction: goes off from where the caster stands, towards where it was aimed. vector: two points, where it starts\n\t * (walked into range of, its effects' `origin`) and the way it goes from there (their `point`): Death Ray, Seismic\n\t * Shove. passive: always on, cannot be cast. Or a game's own (`defineTargeting`, `Rules.targetings`)\n\t */\n\ttarget: AbilityTarget\n\t/** What may be targeted, for abilities cast on a unit */\n\ttargets?: {\n\t\tallies?: boolean\n\t\tenemies?: boolean\n\t\tself?: boolean\n\t\tkinds?: EntityKind[]\n\t\tlayers?: Layer[]\n\t\t/** True: heroes alone; false: anything but a hero (a creep, a minion, a building: Reap). Heroes or not when left out */\n\t\theroes?: boolean\n\t\t/** Only what has one of these tags of its type (`UnitTypeDef.tags`): Death Coil on the undead @beta */\n\t\ttags?: string[]\n\t}\n\t/** Mana it costs per cast, by level */\n\tmanaCost?: Scaled\n\t/** Health it costs, as a part of all the caster can have. It cannot be cast with less than that left */\n\thealthCost?: Scaled\n\t/**\n\t * What it costs of the caster's pools (`UnitTypeDef.pools`), by pool, in a game with the resources pack\n\t * (`resourcesPack`): it is not ready with less, and pays as it goes off (Akali's energy, a shot of ammo)\n\t *\n\t * @beta\n\t */\n\tcost?: Record<string, Scaled>\n\t/**\n\t * What it gives the caster's pools as it goes off, by pool, in a game with the resources pack: Rumble's heat, a\n\t * fury's spender's opposite\n\t *\n\t * @beta\n\t */\n\tgain?: Record<string, Scaled>\n\t/**\n\t * Its costs (its mana and `cost`) grow with the stacks of a buff of the caster's, in a game with the resources pack:\n\t * times one and `per` for each stack (Kassadin's Riftwalk: `per: 1`, twice with one stack, three times with two)\n\t *\n\t * @beta\n\t */\n\tcostGrowth?: { buff: string; per: number }\n\t/** Seconds before it can be used again */\n\tcooldown?: Scaled\n\t/**\n\t * Uses it holds, for one used so many times before it waits: `count` of them at the most, one more back every\n\t * `refill` seconds while it holds fewer (shortened as the cooldown is). Each use spends one; with none left it is not\n\t * ready. Its `cooldown`, where it has one, is then the time between two uses. Full when it is learned\n\t */\n\tcharges?: { count: Scaled; refill: Scaled }\n\t/**\n\t * It may be cast again for a while after it is cast (`AbilityRecast`): Ahri's Spirit Rush thrice, Lee Sin's second\n\t * Sonic Wave to the one the first marked, Lux's Lucent Singularity set off\n\t *\n\t * @beta\n\t */\n\trecast?: AbilityRecast\n\t/** How far away the target may be */\n\trange?: Scaled\n\t/** The target may be as far away as the caster's attacks reach, and `range` farther */\n\tattackRange?: boolean\n\t/**\n\t * What kind of thing it is, for those who can keep out of its way: a buff that `avoids` one of these\n\t * lets nothing of the ability happen to who carries it. `ground` is for what comes out of the ground or along it\n\t */\n\ttags?: string[]\n\t/** Levels a hero can put into it. 3 when left out */\n\tmaxLevel?: number\n\t/** Hero level needed for the first level of the ability. 1 when left out, 6 for an `ultimate` */\n\trequiresLevel?: number\n\t/**\n\t * A hero's ultimate: first learned at level 6 (unless `requiresLevel` says otherwise), what the AI uses on a crowd\n\t * only (as it does what asks for a level), and what a game's own code can tell apart (what a possession of another\n\t * hero leaves the hero's own: `keeps`)\n\t */\n\tultimate?: boolean\n\t/** Hero levels between two levels of the ability. 2 when left out */\n\tlevelStep?: number\n\t/**\n\t * Seconds between starting to cast and the effect. The caster stands still for as long and cannot be\n\t * called away: what it is told to do in the meantime, it does right after. None when left out\n\t */\n\tcastTime?: number\n\t/** Gets through a unit's immunity to spells (see `UnitTypeDef.spellImmune`), as an ultimate may. Or for the targets its function says */\n\tpiercesImmunity?: boolean | ((world: World, target: Entity) => boolean)\n\t/** The ground it covers, when that is not what its effects say: see `aimOf` */\n\taim?:\n\t\t| { shape: 'circle'; radius: Scaled }\n\t\t| { shape: 'line'; length: Scaled; width: Scaled }\n\t\t| { shape: 'cone'; length: Scaled; angle: number }\n\t\t| { shape: 'ring'; radius: Scaled; width: Scaled }\n\t\t| { shape: 'arc'; radius: Scaled; angle: number; width: Scaled }\n\t\t| { shape: 'rect'; length: Scaled; width: Scaled }\n\t\t| { shape: 'cross'; length: Scaled; width: Scaled }\n\t/** Units use it on their own when they have nothing else to do. The player can switch this off */\n\tautocast?: boolean\n\t/**\n\t * A buff of the caster that charges the ability when it has as many stacks as it can: the ability shows it, its\n\t * `charged` effects do their other thing, and casting it takes the buff away\n\t */\n\tcharge?: string\n\t/** What it does, one effect after the other, when it is cast */\n\teffects: EffectDef[]\n\t/** What an ability that is cast does all the time besides, once it is learned: buffs, auras, `onHit` */\n\tpassive?: EffectDef[]\n\t/**\n\t * Autocast in code, for any kind of ability: where to use it now, or nothing. Asked when the unit has nothing to\n\t * do, the ability is switched to autocast, ready and paid for. Without it, only abilities cast on a unit autocast,\n\t * on the worst-off target their core effects would do good to\n\t */\n\tautoAim?: (world: World, caster: Entity, state: AbilityState) => { target?: number; point?: Vec2 } | null | undefined\n\t/**\n\t * How a computer player uses it, from what it sees (see `AiView`): where, or `null` for not now. What the engine\n\t * works out from its core effects when it gives nothing; an ability of the game's own effects has to say\n\t */\n\tai?: (view: AbilityAiView, caster: EntityState, level: number) => { point: Vec2; target?: number; to?: Vec2 } | null | undefined\n\t/** How far away the target may be, in code: the range on high ground, say. `range` is what the screen shows */\n\trangeOf?: (world: World, caster: Entity, level: number) => number\n\t/** Seconds of the wind-up, in code: shortened by haste, say. `castTime` when left out */\n\tcastTimeOf?: (world: World, caster: Entity, level: number) => number\n\t/**\n\t * Kept up once it went off: the caster stands, for `duration` seconds, doing it every `every` seconds (effects, or\n\t * code), until it is done or interrupted (another order, a stun), when `interrupted` runs. An ice storm\n\t */\n\tchannel?: {\n\t\tduration: number | ((world: World, caster: Entity, level: number) => number)\n\t\tevery?: number\n\t\teffects?: EffectDef[]\n\t\trun?: (world: World, caster: Entity, level: number, target: Entity | undefined, point: Vec2) => void\n\t\tinterrupted?: (world: World, caster: Entity, level: number) => void\n\t\t/** What it does once kept up to the end, and only then: a recall's teleport home */\n\t\tfinished?: EffectDef[]\n\t\t/** Broken off when the caster is hurt, as a recall is: any damage, from anyone */\n\t\tbreaksOnDamage?: boolean\n\t\t/**\n\t\t * A tether: broken off (`interrupted`) as the unit it was cast on gets farther than this from the caster's edge,\n\t\t * dies or hides: Siphon Mana, Life Drain, Morgana's Soul Shackles\n\t\t *\n\t\t * @beta\n\t\t */\n\t\tleash?: number\n\t\t/**\n\t\t * Aimed as it goes: where it goes off at (`point`) follows the player's `aim` commands, in a game with the holds\n\t\t * pack (`holdsPack`): Vel'Koz's ray, Jhin's Curtain Call, Starfall's sweep. The caster turns to it\n\t\t *\n\t\t * @beta\n\t\t */\n\t\taimed?: boolean\n\t\t/**\n\t\t * Kept up as the caster walks, in a game with the holds pack (`holdsPack`): not an order the caster stands in, so\n\t\t * it may be told to go elsewhere while it lasts; broken off by a stun, a silence, its death\n\t\t *\n\t\t * @beta\n\t\t */\n\t\twalks?: boolean\n\t}\n\t/**\n\t * What it may be made into for good, chosen once (`upgradeAbility`, the `upgradeAbility` command), in a game with the\n\t * ability changes pack (`abilityChangesPack`): Viktor's augments, Engineering Upgrade's better abilities. The new one\n\t * takes its place at its level and cooldown\n\t *\n\t * @beta\n\t */\n\tupgrades?: string[]\n\t/**\n\t * Held to charge and let go, in a game with the holds pack (`holdsPack`): the cast starts the hold where the caster\n\t * stands, going on with what it was doing, and the `release` command (the key let go, or a click) sets it off, as\n\t * full as it was held (`HoldDef`): farther, harder, or a tap's other effects. Paid as it is let go\n\t *\n\t * @beta\n\t */\n\thold?: HoldDef\n}\n\n/**\n * How an ability is held to charge and let go (`AbilityDef.hold`), in a game with the holds pack: Varus's Piercing Arrow,\n * Xerath's Arcanopulse, Pyke's Bone Skewer, Viego's Spectral Maw\n *\n * @beta\n */\nexport interface HoldDef {\n\t/** Seconds held for it to be full */\n\tmax: number\n\t/** Seconds held after which it goes off by itself, where it was last aimed: as it is full when left out */\n\tupTo?: number\n\t/** How far it reaches let go at once (`from`) and full (`to`): where it is let go at is brought that near */\n\trange?: { from: number; to: number }\n\t/** What its amounts come to full, times what they are let go at once (1.5: half again); what comes between is between */\n\tscale?: number\n\t/** Let go before `under` seconds: these effects in place of its own (Pyke's stab, not his hook) */\n\ttap?: { under: number; effects: EffectDef[] }\n\t/** A buff on the caster while it holds: a slow */\n\tbuff?: string\n}\n\n/**\n * What an ability does all the time: all of a passive one, and the passive part of the others\n *\n * @internal\n */\nexport const passiveEffects = (ability: AbilityDef): EffectDef[] => (ability.target === 'passive' ? ability.effects : (ability.passive ?? []))\n\n/**\n * What the stats of the caster add to an amount. `level` is for every level of a hero past the first,\n * `bonusAttackDamage` for the attack damage it has on top of what its type and its levels give it\n *\n * @beta\n */\nexport type Scaling = Partial<Record<StatKey | 'level' | 'bonusAttackDamage', Scaled>>\n\n/**\n * Something lasting on a unit that changes what it can do\n *\n * @public\n */\nexport interface BuffDef extends ScaledStatChange {\n\t/** The buff's id, shared by every game: give it a prefix of the game's */\n\tid: string\n\t/** What the player sees the buff called */\n\tname: string\n\t/**\n\t * The definition this one is a copy of, made from the data (`copyOf` in a `data.json`, the editor's Copy as new):\n\t * what it is drawn, heard and pictured as where the game gives it no look of its own\n\t */\n\tbasedOn?: string\n\t/** What the buff does, in words, shown when the pointer is over it */\n\tdescription?: string\n\t/** Seconds. Lasts until removed when left out */\n\tduration?: number\n\t/** A debuff: by default it goes on enemies */\n\tharmful?: boolean\n\t/**\n\t * Free words to find it by and to sort it with (`fire`, `slow`, `anti-heal`), as abilities and units have: what a\n\t * search matches, what a game's code asks (`buffsTagged`)\n\t *\n\t * @beta\n\t */\n\ttags?: string[]\n\t/** The unit cannot do anything. A function says so for one carrier, one moment */\n\tstun?: boolean | BuffCheck\n\t/** Thrown into the air for as long as it lasts. Comes with a stun, the rest is for the eye */\n\tairborne?: boolean\n\t/** Knocked down: it lies on the ground for as long as it lasts, and gets up at the end. For the eye, like `airborne` */\n\tdown?: boolean\n\t/** Brings what flies down: it counts as being on the ground, for whatever is aimed at it */\n\tgrounds?: boolean\n\t/**\n\t * Its carrier is invisible to enemies for as long as it lasts, unless they find it (`detect`): a Wind Walk. A function\n\t * says so for one carrier, one moment\n\t */\n\tinvisible?: boolean | BuffCheck\n\t/** The unit cannot move from the spot. It can still fight and cast. A function says so for one carrier, one moment */\n\troot?: boolean | BuffCheck\n\t/**\n\t * The unit cannot use its abilities. What it carries and the spells every hero has still work. A function says\n\t * which abilities it keeps it from (`(ability) => ability.tags?.includes('fire')`): the screen asks it too\n\t */\n\tsilence?: boolean | ((ability: AbilityDef) => boolean)\n\t/** Damage it takes in place of the unit, for as long as the buff lasts and there is something left of it */\n\tshield?: Scaled\n\t/** What the stats of whoever gave the shield add to it */\n\tshieldScaling?: Scaling\n\t/** The shield is as good as new once the unit has not been hurt for this many seconds */\n\trecharge?: number\n\t/** Tags of abilities that do nothing to who carries it, for as long as it does: `ground` for someone up in the air */\n\tavoids?: string[]\n\t/** Who carries it does not attack while it lasts: burrowed, or disarmed. Or while its function says */\n\tdisarm?: boolean | BuffCheck\n\t/** Who carries it is immune to spells while it lasts, as an avatar is (see `UnitTypeDef.spellImmune`). Or while its function says */\n\tspellImmune?: boolean | BuffCheck\n\t/**\n\t * Who carries it takes no damage while it lasts, and no enemy's ability may be cast on it (Divine Shield, Kayle's\n\t * Intervention, Zhonya's stasis with a `stun`). Effects other than damage still reach it. Or while its function says\n\t *\n\t * @beta\n\t */\n\tinvulnerable?: boolean | BuffCheck\n\t/**\n\t * Who carries it is out of reach while it lasts (Fizz's Playful, Zed's Death Mark dash, Vlad's pool): no ability may be\n\t * cast on it but by itself, no attack is aimed at it nor lands, and no effect of anyone else's reaches it (an area,\n\t * a missile, a chain), allies' too; it is still seen and still in the way. Or while its function says\n\t *\n\t * @beta\n\t */\n\tuntargetable?: boolean | BuffCheck\n\t/**\n\t * The least health damage leaves its carrier with while it lasts (Tryndamere's Undying Rage at 1, Kindred's Lamb's\n\t * Respite at a tenth of its max): a number, one per level, or code with the carrier. It is hurt down to it, never past\n\t * it. The highest of what it carries counts\n\t *\n\t * @beta\n\t */\n\tminHealth?: Scaled | ((world: World, carrier: Entity, instance: BuffInstance) => number)\n\t/**\n\t * Whether a dispel takes it off (see the effect `dispel`). Yes when left out: no for what nothing should end early.\n\t * Decided in code for each dispel: by who dispels it (`by`), its level\n\t */\n\tdispellable?: boolean | ((world: World, carrier: Entity, instance: BuffInstance, by: Entity) => boolean)\n\t/** How many of it one unit can carry at most. What puts it on says whether it adds one (`stack`) */\n\tmaxStacks?: number\n\t/** What happens around who carried it when its time is up, in the name of who put it there. Not when it is taken off */\n\tonEnd?: EffectDef[]\n\t/** Its stats count once for every stack it has (`stacks`), rather than once: \"each stack, -5% move speed\" */\n\tperStack?: boolean\n\t/**\n\t * Stats of its own, worked out in code, on top of what it declares: \"+2 armor for each ally near\". Asked when the\n\t * carrier's stats are added up, which is only when something they come from changed: what this depends on beyond\n\t * the buff (allies near, the time) calls `invalidateStats` when it changes\n\t */\n\tchange?: (world: World, carrier: Entity, instance: BuffInstance) => StatChange | undefined\n\t/**\n\t * What happens when it is put on a unit that has it already. `strongest` (the default): the higher level wins,\n\t * the longer among equals. `refresh`: the time starts over, the level the new one's. `perSource`: one of it for\n\t * every unit that puts it on, each of its own (two poisons from two casters). `independent`: a new one every time.\n\t * A function decides from the one there and the one coming: `replace` it, `renew` its time, `add` another, or `keep`\n\t */\n\tstacking?:\n\t\t'strongest' | 'refresh' | 'perSource' | 'independent' | ((existing: BuffInstance, incoming: IncomingBuff) => 'replace' | 'renew' | 'add' | 'keep')\n\t/** What happens as it is put on: effects in the name of who put it there (while they live), or code */\n\tonApply?: EffectDef[] | BuffHandler\n\t/** What happens every `every` seconds while it lasts: effects in the name of who put it there (while they live), or code, which runs whoever is left */\n\tonTick?: { every: number; effects?: EffectDef[]; run?: BuffHandler }\n\t/** Code run when it comes off, run out (`expired`) or taken off. Not for the buffs of something that dies */\n\tonRemove?: (world: World, carrier: Entity, instance: BuffInstance, expired: boolean) => void\n\t/**\n\t * It takes its carrier's orders while it lasts: what it was told waits (a channel is broken off), the player's and\n\t * anyone's new orders are refused, and it goes on with what it was told after, as from a stun. `fear`: it walks away\n\t * from who put it on; `charm`: it walks to them; `taunt`: it attacks them (walks to them where it cannot). Code\n\t * (`BuffControl`) steers it itself every tick. The last of them it carries is the one it does\n\t *\n\t * @beta\n\t */\n\tcontrol?: ControlKind | BuffControl\n\t/**\n\t * Held like a stun, and more: tenacity does not cut it short and a `cleanse` does not take it off (Malzahar's\n\t * Nether Grasp, Skarner's Impale)\n\t *\n\t * @beta\n\t */\n\tsuppress?: boolean\n\t/**\n\t * Its carrier cannot rush or jump anywhere of its own: an ability of its with a `dash` or a `blink` is refused\n\t * (\"Grounded\"), and such an effect of its does nothing (Singed's Mega Adhesive). Not `grounds`, which brings a flyer down\n\t *\n\t * @beta\n\t */\n\tgrounded?: boolean\n\t/**\n\t * What it takes of its carrier each second while it lasts, by pool (`UnitTypeDef.pools`) or `mana`, in a game with\n\t * the resources pack (`resourcesPack`): taken off when there is not enough for the next second's (Immolation, a\n\t * Glacial Storm kept up)\n\t *\n\t * @beta\n\t */\n\tdrain?: Record<string, number>\n\t/**\n\t * Nothing that holds a unit up does anything to its carrier while it lasts: harmful stuns, roots, silences, disarms,\n\t * controls, suppressions and grounds on it hold nothing, new ones do not take, and it is neither thrown nor pulled\n\t * (Olaf's Ragnarok, Malphite's Unstoppable Force). Slows still slow\n\t *\n\t * @beta\n\t */\n\tunstoppable?: boolean\n\t/**\n\t * Its carrier is seen by the team of whoever put it on while it lasts, wherever it stands: in the fog, in a bush,\n\t * invisible or camouflaged (the fog lit where it stands, as for what a `detect` found), in a game with the vision\n\t * pack (`visionPack`): Kindred's mark, a hunter's quarry\n\t *\n\t * @beta\n\t */\n\trevealed?: boolean\n\t/**\n\t * Its carrier is camouflaged while it lasts, in a game with the vision pack (`visionPack`): its enemies see it only\n\t * from within this far of it (a unit of theirs that near), unless something finds it (`trueSight`, `detect`,\n\t * `revealUnit`) or it attacked them a moment ago: Pyke's Ghostwater Dive, Rengar's Thrill of the Hunt, Viego's mist.\n\t * A function says how far for one carrier, one moment\n\t *\n\t * @beta\n\t */\n\tcamouflage?: number | ((world: World, carrier: Entity, instance: BuffInstance) => number)\n\t/**\n\t * Its carrier finds what of its enemies is invisible or camouflaged within this far of it, for its team, while it\n\t * lasts, in a game with the vision pack (`visionPack`): an Oracle Lens, a Magic Sentry on a tower\n\t *\n\t * @beta\n\t */\n\ttrueSight?: number\n\t/**\n\t * Its carrier walks through other units, and they through it, while it lasts: neither steers round nor pushes the\n\t * other (a Ghost, a Phantom Stride). Walls, cliffs, buildings and trees still stop it. A function says so for one\n\t * carrier, one moment\n\t *\n\t * @beta\n\t */\n\tphasing?: boolean | BuffCheck\n\t/**\n\t * Its carrier's blows from up close strike the enemies around their target too, a part of their damage each, as an\n\t * attack's own cleave (`AttackDef.cleave`): the larger part counts\n\t *\n\t * @beta\n\t */\n\tcleave?: Cleave\n\t/**\n\t * The healing past full health that its carrier gives (`given`, when left out) or gets (`taken`) becomes a shield on\n\t * whoever was healed: the buff `buff` (its own time, and a shield of its own where it says), holding `part` of what\n\t * spilled over (all of it when left out), up to `most` of the healed one's max health (a third when left out)\n\t *\n\t * @beta\n\t */\n\toverheal?: { buff: string; part?: Scaled; most?: number; of?: 'given' | 'taken' }\n\t/**\n\t * Its carrier pays for its abilities with health, not mana, while it carries it: this much health for each point of\n\t * mana they cost (1 for `true`). It cannot cast with no more health than that; items still cost nothing\n\t *\n\t * @beta\n\t */\n\tpaysWithHealth?: boolean | number\n\t/**\n\t * What its carrier's attacks, hurts, casts and kills set off while it carries it, as an ability's passive does\n\t * (`onHit`, `onKill`, `onCast`, `onDamaged`, `onAbilityHit`, `onLowHealth`), in the carrier's name: Frost Armor's\n\t * slow on who strikes it, a Thorns Aura's buff, the empowered next attack of a buff a cast put on\n\t *\n\t * @beta\n\t */\n\tpassive?: EffectDef[]\n\t/**\n\t * What takes it off before its time: `damage` (its carrier hurt: Sleep), `attack` (an attack of its carrier lands,\n\t * after what the attack sets off: Wind Walk), `cast` (its carrier casts an ability other than the one that put it on)\n\t *\n\t * @beta\n\t */\n\tbreaksOn?: BuffBreak[]\n\t/**\n\t * What happens where its carrier dies carrying it, in the name of who put it on (while they live): Doom's demon, Black\n\t * Arrow's skeleton, a mark that spreads\n\t *\n\t * @beta\n\t */\n\tonCarrierDeath?: EffectDef[]\n\t/**\n\t * What happens to its carrier as an effect (`stack`) brings it to `maxStacks`, in the name of who put it on: Gravity\n\t * Field's stun on the third, Hemorrhage's might on the fifth. A `removeBuff` among them spends the stacks\n\t *\n\t * @beta\n\t */\n\tonMaxStacks?: EffectDef[]\n}\n\n/**\n * The orders a buff gives its carrier (`BuffDef.control`): away from who put it on, to them, or at them\n *\n * @beta\n */\nexport type ControlKind = 'fear' | 'charm' | 'taunt'\n\n/**\n * A buff's own control (`BuffDef.control` in code): run every tick it holds its carrier, in place of the orders it\n * waits on, to steer it as it likes (with `moveTo`, `engage` and the like). `source` is who put it on, while it is there\n *\n * @beta\n */\nexport type BuffControl = (world: World, carrier: Entity, instance: BuffInstance, dt: number, source: Entity | undefined) => void\n\n/**\n * What takes a buff off before its time (`BuffDef.breaksOn`): its carrier hurt, an attack of its landing, a cast of its\n *\n * @beta\n */\nexport type BuffBreak = 'damage' | 'attack' | 'cast'\n\n/** Whether a buff does what it says (stuns, roots) to one carrier, at this moment */\nexport type BuffCheck = (world: World, carrier: Entity, instance: BuffInstance) => boolean\n\n/** Code a buff runs on its carrier: as it is put on, or every so often */\nexport type BuffHandler = (world: World, carrier: Entity, instance: BuffInstance) => void\n\n/** A buff about to be put on, as a `stacking` function sees it */\nexport interface IncomingBuff {\n\tlevel: number\n\t/** Seconds */\n\tduration: number\n\t/** Who puts it on, by id: 0 for nobody */\n\tsource: number\n}\n\n/**\n * Where an item is in a shop, and in its build tree: what is used up (`consumable`), what a hero starts with\n * (`starter`), the parts (`basic`), what they build (`intermediate`), what it all leads to (`legendary`), and what is\n * found, never sold (`relic`: loot of camps, bosses and quests). The client's tiers, or a game's own\n * (`GameView.hud.shopTiers`). `epic` is the old word for `intermediate`, still read as it (`itemTier`)\n *\n * @beta\n */\nexport type ItemTier = 'consumable' | 'starter' | 'basic' | 'intermediate' | 'legendary' | 'relic' | 'epic' | (string & {})\n\n/**\n * How an item's charges come back (`ItemDef.refill`): all of them at a shop of the carrier's side or an ally's\n * (`shop`), and one every `every` seconds. An item that refills is kept at no charges, waiting for them\n *\n * @beta\n */\nexport interface ItemRefill {\n\t/** Every charge back while its carrier stands at a shop it may trade with */\n\tshop?: boolean\n\t/** Seconds for one charge to come back, wherever it is carried. None when left out */\n\tevery?: number\n}\n\n/**\n * A tag of items (`ItemDef.tags`), named and given a look: what a shop shows of it and whether it is one of the shop's\n * filters. A tag no `TagDef` names still works, shown as its own word (`Rules.tags`)\n *\n * @beta\n */\nexport interface TagDef {\n\t/** The tag as items say it: `attack`, `lifesteal`, `anti-heal` */\n\tid: string\n\t/** What the player sees it called: its id when left out */\n\tname?: string\n\t/** A line about it, shown when the pointer is over it */\n\tdescription?: string\n\t/** An icon of its own, by path or by a name of the game's icons */\n\ticon?: string\n\t/** The colour it is shown in, as CSS has it (`#e0a030`) */\n\tcolor?: string\n\t/** One of the shop's filters, a chip to pick: not when left out */\n\tfilter?: boolean\n}\n\n/**\n * The definition of an item: what it costs, what it gives its carrier and how it is used\n *\n * @public\n */\nexport interface ItemDef {\n\t/** The item's id, shared by every game: give it a prefix of the game's */\n\tid: string\n\t/** What the player sees the item called */\n\tname: string\n\t/** How good it is, 1 and up (campaign plan GP3): what an item table draws by (`{ level: 3 }`) */\n\tlevel?: number\n\t/** Its kind of item, a word of the game's (`permanent`, `charged`, `powerup`): what an item table draws by too */\n\tclass?: string\n\t/**\n\t * The definition this one is a copy of, made from the data (`copyOf` in a `data.json`, the editor's Copy as new):\n\t * what it is drawn, heard and pictured as where the game gives it no look of its own\n\t */\n\tbasedOn?: string\n\t/** What the item does, in words, shown when the pointer is over it */\n\tdescription?: string\n\t/** What it costs in a shop, in resources */\n\tcost: Cost\n\t/** Uses before it is gone. Items without charges stay */\n\tcharges?: number\n\t/** Id of the ability the item gives: using the item casts it, without mana */\n\tability?: string\n\t/** Id of an ability whose passive part works for whoever carries the item */\n\tpassive?: string\n\t/** Items it is made of. Those the buyer carries are used up and taken off the price, which is for all of it */\n\tfrom?: string[]\n\t/**\n\t * Where it goes in a shop: consumable, starter, basic, intermediate, legendary, relic (`ItemTier`). `epic`, the old\n\t * word, is read as intermediate\n\t */\n\ttier?: ItemTier\n\t/**\n\t * The name of its passive (or the passive of items that share it): two carried, of it or of items sharing the name,\n\t * work once (the first carried). Its stats (`bonus`) always count. Every passive works when left out\n\t *\n\t * @beta\n\t */\n\tunique?: string\n\t/**\n\t * A group of items a hero carries only so many of (`boots`): `groupLimit`, or the game's limit of the group\n\t * (`ItemSettings.groups`), 1 when neither says. Buying, picking up or being handed one more is refused, saying why\n\t *\n\t * @beta\n\t */\n\tgroup?: string\n\t/** How many of its `group` one carrier may have: the game's limit of the group, or 1, when left out @beta */\n\tgroupLimit?: number\n\t/**\n\t * How many of it go in one slot: another bought, picked up or handed over goes into the slot of one carried, its\n\t * charges added, up to so many of it (a stack of potions). One a slot when left out\n\t *\n\t * @beta\n\t */\n\tstack?: number\n\t/** How its charges come back (`ItemRefill`): at a shop, over time. Used up for good when left out @beta */\n\trefill?: ItemRefill\n\t/** The part of its price a shop gives back for it, over the game's (`EconomySettings.sellPrice`) @beta */\n\tsellRate?: number\n\t/**\n\t * Free words of the game's for what it is (`attack`, `lifesteal`, `anti-heal`, `early`): its categories, what a\n\t * search finds it by (`#lifesteal`), what a shop filters by. A `TagDef` gives one a name and a look (`Rules.tags`)\n\t *\n\t * @beta\n\t */\n\ttags?: string[]\n\t/**\n\t * The callings of heroes it is meant for (`vanguard`, `ranger`…): what a shop suggests and filters by. Never a lock:\n\t * any hero may buy it\n\t *\n\t * @beta\n\t */\n\tsuits?: string[]\n\t/** Applies for as long as the item is carried */\n\tbonus?: StatChange\n\t/** How many a shop has at most, and the seconds it takes to get one back. As many as anyone wants when left out */\n\tstock?: { max: number; restock: number }\n\t/** The key that uses it from the command card */\n\thotkey?: string\n\t/**\n\t * Used as it is picked up, by walking over it or by the order, and never carried: a rune, a tome. Its ability is cast by\n\t * whoever picked it. In a game with the runes pack (`runesPack`, whose `powerUp` says it in code)\n\t */\n\tpowerUp?: boolean\n}\n\n/**\n * A big army is paid for with income: past a certain supply, less arrives of what workers gather of the resources with `upkeep`\n *\n * @beta\n */\nexport interface UpkeepTier {\n\t/** Applies when the player uses more supply than this */\n\tabove: number\n\t/** What the player sees the tier called */\n\tname: string\n\t/** Part of what is gathered that still arrives, 0..1 */\n\tincome: number\n}\n\n/**\n * What a level of research changes\n *\n * @beta\n */\nexport interface UpgradeEffect extends StatChange {\n\t/** Unit types that benefit, or a function of the type. Everything the player owns when left out */\n\tunits?: string[] | ((def: UnitTypeDef) => boolean)\n}\n\n/**\n * Research that improves a player's units for the rest of the game\n *\n * @public\n */\nexport interface UpgradeDef {\n\t/** The upgrade's id, shared by every game: give it a prefix of the game's */\n\tid: string\n\t/** What the player sees the upgrade called */\n\tname: string\n\t/**\n\t * The definition this one is a copy of, made from the data (`copyOf` in a `data.json`, the editor's Copy as new):\n\t * what it is drawn, heard and pictured as where the game gives it no look of its own\n\t */\n\tbasedOn?: string\n\t/** What the upgrade does, in words, shown when the pointer is over it */\n\tdescription?: string\n\t/** Paid for every level */\n\tcost: Cost\n\t/** Seconds per level */\n\tresearchTime: number\n\t/** The highest level that can be researched; 1 when left out */\n\tmaxLevel?: number\n\t/** Building types needed, one list per level. Levels past the end of the list need nothing */\n\trequires?: string[][]\n\t/** The race it is of (`Rules.races`): only its players may research it. Everyone's when left out */\n\trace?: string\n\t/** The key that researches it from the command card */\n\thotkey?: string\n\t/** What each level changes in the stats of the units it applies to */\n\teffects: UpgradeEffect[]\n\t/**\n\t * What it does besides stats, in code, to each unit of the player's: as a level is researched (to the units there\n\t * are), and as a unit comes into the world while the player has it. Gives an ability, lets a unit hit what flies.\n\t * Run again for every level: what it does is up to it to not do twice\n\t */\n\tapply?: (world: World, entity: Entity, level: number) => void\n}\n\n/**\n * The types a building can be upgraded into (`UnitTypeDef.upgradesTo`), as a list: one for most, none for one that\n * turns into nothing\n *\n * @beta\n */\nexport const upgradesOf = (def: Pick<UnitTypeDef, 'upgradesTo'>): readonly string[] =>\n\tdef.upgradesTo === undefined ? [] : typeof def.upgradesTo === 'string' ? [def.upgradesTo] : def.upgradesTo\n\n/**\n * Gives the footprint of a unit type: its own, or a square the width of its collision diameter, rounded up\n *\n * @beta\n */\nexport const footprintOf = (def: UnitTypeDef) => def.footprint ?? { w: Math.ceil(def.radius * 2), d: Math.ceil(def.radius * 2) }\n\n/**\n * Whether things of this type only stand there, like trees and gold mines: they never move, act or change by\n * themselves, so the systems that run every tick have nothing to do for them. A map can have thousands of\n * them and they cost nothing per tick. Only things that belong to nobody (the neutral player) are treated\n * as scenery, see `World.spawn`: a player's building counts for supply, sight and victory.\n *\n * @internal\n */\nexport function isScenery(def: UnitTypeDef): boolean {\n\treturn (\n\t\tdef.kind !== 'unit' &&\n\t\t!def.attacks?.length &&\n\t\t!def.hero &&\n\t\t!def.abilities?.length &&\n\t\t!def.inventory &&\n\t\t!def.sells?.length &&\n\t\t!def.trains?.length &&\n\t\t!def.researches?.length &&\n\t\t!upgradesOf(def).length &&\n\t\tdef.lifetime === undefined &&\n\t\t!def.invisible &&\n\t\tdef.recovers === undefined &&\n\t\t!def.stats.healthRegen &&\n\t\t!def.stats.manaRegen\n\t)\n}\n\n/** The one pool of supply there always is, in a supply said by pool (`UnitTypeDef.supply`) @beta */\nexport const MAIN_SUPPLY = 'supply'\n\n/** What a type takes of the one pool of supply there always is (`UnitTypeDef.supply`, a number or its `supply`) @beta */\nexport function supplyOf(def: Pick<UnitTypeDef, 'supply'>): number {\n\tconst { supply } = def\n\treturn typeof supply === 'number' ? supply : (supply?.[MAIN_SUPPLY] ?? 0)\n}\n\n/** What a type takes of the game's own pools of supply, by name (`UnitTypeDef.supply` said by pool, the one pool left out) @beta */\nexport function supplyPoolsOf(def: Pick<UnitTypeDef, 'supply'>): Record<string, number> {\n\treturn poolsIn(def.supply)\n}\n\n/** What a finished building of a type provides of the one pool of supply (`UnitTypeDef.supplyGiven`) @beta */\nexport function supplyGivenOf(def: Pick<UnitTypeDef, 'supplyGiven'>): number {\n\tconst { supplyGiven } = def\n\treturn typeof supplyGiven === 'number' ? supplyGiven : (supplyGiven?.[MAIN_SUPPLY] ?? 0)\n}\n\n/** What a finished building of a type provides of the game's own pools, by name (`UnitTypeDef.supplyGiven` said by pool) @beta */\nexport function supplyPoolsGivenOf(def: Pick<UnitTypeDef, 'supplyGiven'>): Record<string, number> {\n\treturn poolsIn(def.supplyGiven)\n}\n\nfunction poolsIn(said: number | Record<string, number> | undefined): Record<string, number> {\n\tif (!said || typeof said === 'number') return {}\n\tconst out: Record<string, number> = {}\n\tfor (const name in said) if (name !== MAIN_SUPPLY) out[name] = said[name]\n\treturn out\n}\n\n/**\n * What base stats are worked out under: the rules of a game, and what its own stats start at. A `Registry` is one\n *\n * @beta\n */\nexport interface StatSource {\n\t/** The rules of the game the stats are worked out under, as `RuleSettings` */\n\treadonly settings: Readonly<RuleSettings>\n\t/** Every stat of the game at 0, its own at their default */\n\treadonly statDefaults: Readonly<Stats>\n}\n\n/** Base stats worked out before, by the game they were worked out for (a unit type may be in more than one game) */\nconst cache = new WeakMap<StatSource, { days: WeakMap<UnitTypeDef, Readonly<Stats>>; nights: WeakMap<UnitTypeDef, Readonly<Stats>> }>()\n\n/**\n * The stats a unit type starts with, all of them, in a game: `world.registry`, or `session.registry` on a player's\n * screen. By day unless it says otherwise\n *\n * @beta\n */\nexport function baseStats(def: UnitTypeDef, game: StatSource, night = false): Readonly<Stats> {\n\tconst { settings: rules } = game\n\tlet cached = cache.get(game)\n\tif (!cached) cache.set(game, (cached = { days: new WeakMap(), nights: new WeakMap() }))\n\tconst bases = night ? cached.nights : cached.days\n\tlet stats = bases.get(def)\n\tif (!stats) {\n\t\tconst sight = night ? (def.sightNight ?? Math.round(def.sight * rules.fog.nightSight)) : def.sight\n\t\tstats = Object.freeze({ ...game.statDefaults, sight, ...def.stats, ...(def.uses ? { health: def.uses } : undefined) }) as Readonly<Stats>\n\t\tbases.set(def, stats)\n\t}\n\treturn stats\n}\n\n/**\n * The ground an ability covers at a level: a line for what it sends on its way, a circle for what hits an area.\n * Undefined for abilities that are about one unit, or about nothing in particular.\n *\n * @beta\n */\nexport function aimOf(ability: AbilityDef, level: number): AimShape | undefined {\n\tconst { aim } = ability\n\tif (aim) {\n\t\tif (aim.shape === 'circle') return { shape: 'circle', radius: at(aim.radius, level) }\n\t\tif (aim.shape === 'cone') return { shape: 'cone', length: at(aim.length, level), angle: aim.angle }\n\t\tif (aim.shape === 'ring') return { shape: 'ring', radius: at(aim.radius, level), width: at(aim.width, level) }\n\t\tif (aim.shape === 'arc') return { shape: 'arc', radius: at(aim.radius, level), angle: aim.angle, width: at(aim.width, level) }\n\t\treturn { shape: aim.shape, length: at(aim.length, level), width: at(aim.width, level) }\n\t}\n\tconst missile = ability.effects.find((effect) => effect.type === 'missile')\n\tif (missile) return { shape: 'line', length: at(missile.distance, level, 10), width: declaredAt(missile.radius, level, 1) }\n\t// the first effect with a shape, or one a zone or a delay of it holds (AB10): what it covers is what is aimed\n\tconst shapedAim = shapeAim(ability.effects, level)\n\tif (shapedAim) return shapedAim\n\tlet radius = 0\n\tfor (const effect of lowerChain(ability.effects)) if (effect.type !== 'aura') radius = Math.max(radius, declaredAt(effect.radius, level))\n\treturn radius > 0 ? { shape: 'circle', radius } : undefined\n}\n\n/** The ground of the first effect with a shape other than a circle, of a list or of a zone or delay in it, as an aim */\nfunction shapeAim(effects: readonly EffectDef[] | undefined, level: number): AimShape | undefined {\n\tfor (const each of lowerChain(effects ?? [])) {\n\t\tconst effect = anyEffect(each)\n\t\tconst { shape } = effect\n\t\tconst size = (value: EffectValue | undefined, fallback = 0) => declaredAt(value, level, fallback)\n\t\tconst width = size(effect.width, 1)\n\t\tswitch (shape) {\n\t\t\tcase 'cone':\n\t\t\t\treturn { shape, length: size(effect.length), angle: size(effect.angle) }\n\t\t\tcase 'line':\n\t\t\tcase 'rect':\n\t\t\tcase 'cross':\n\t\t\t\treturn { shape, length: size(effect.length), width }\n\t\t\tcase 'ring':\n\t\t\t\treturn { shape, radius: size(effect.radius), width }\n\t\t\tcase 'arc':\n\t\t\t\treturn { shape, radius: size(effect.radius), angle: size(effect.angle), width }\n\t\t}\n\t\tif (effect.type === 'zone' || effect.type === 'after') {\n\t\t\tconst inner = shapeAim(effect.effects, level)\n\t\t\tif (inner) return inner\n\t\t}\n\t}\n\treturn undefined\n}\n"],"mappings":";;;;;;AAqDA,SAAgB,GAAG,OAA2B,OAAe,WAAW,GAAW;CAClF,IAAI,UAAU,KAAA,GAAW,OAAO;CAChC,IAAI,OAAO,UAAU,UAAU,OAAO;CACtC,OAAO,MAAM,KAAK,IAAI,KAAK,IAAI,OAAO,CAAC,GAAG,MAAM,MAAM,IAAI,MAAM;AACjE;;;;;;;AAQA,SAAgB,WAAW,OAAgC,OAAe,WAAW,GAAW;CAC/F,OAAO,OAAO,UAAU,aAAa,WAAW,GAAG,OAAO,OAAO,QAAQ;AAC1E;;;;;;AA4GA,IAAa,iBAAgC;CAC5C;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACD;;;;;;AAOA,IAAa,iBAA4B;CACxC,cAAc;CACd,aAAa;CACb,aAAa;CACb,QAAQ;CACR,OAAO;CACP,aAAa;CACb,gBAAgB;CAChB,wBAAwB;CACxB,qBAAqB;CACrB,oBAAoB;CACpB,gBAAgB;CAChB,iBAAiB;CACjB,aAAa;CACb,MAAM;CACN,WAAW;CACX,WAAW;CACX,OAAO;AACR;;;;;;AAuBA,SAAgB,OAAO,KAAsB,SAAyB;CACrE,IAAI,CAAC,KAAK,OAAO;CACjB,QAAQ,IAAI,QAAS,UAAU,IAAI,SAAU,MAAM;AACpD;;;;;;AAOA,IAAa,WAAW,KAAsB,SAA0B,CAAC,CAAC,QAAQ,OAAO,IAAI,QAAQ,QAAQ,IAAI;;;;;;;AA+SjH,SAAgB,eAAe,KAAyF;CACvH,OAAO,IAAI,iBAAiB,IAAI,eAAe,SAAS;AACzD;;;;;;;AAirBA,IAAa,iBAA4H;CACxI,KAAK;EAAE,OAAO,CAAC,SAAS;EAAG,MAAM;CAAU;CAC3C,SAAS;EAAE,OAAO,CAAC,MAAM;EAAG,MAAM;CAAU;CAC5C,QAAQ;EAAE,OAAO,CAAC,MAAM;EAAG,MAAM;CAAU;CAC3C,KAAK;EAAE,OAAO,CAAC,WAAW,MAAM;EAAG,MAAM;CAAQ;AAClD;;;;;;AAwzBA,IAAa,aAAa,WAAiC;;;;;;;AAQ3D,SAAgB,aAAa,QAAgC;CAC5D,MAAM,EAAE,SAAS,WAAW,UAAU,UAAU,MAAM;CACtD,OAAO;EAAC,GAAI,WAAW,CAAC;EAAI,GAAI,aAAa,CAAC;EAAI,GAAI,SAAS,CAAC;CAAE;AACnE;;AAWA,IAAM,8BAAc,IAAI,QAA8B;;AAEtD,IAAM,+BAAe,IAAI,QAAyC;;;;;;AAOlE,IAAa,iBAAiB,SAAsD,aAAa,IAAI,IAAI;;;;;;;AAQzG,IAAa,iBAAiB,WAAiC,YAAY,IAAI,MAAM,KAAK;;;;;;;;;;AAW1F,SAAgB,WAAW,SAA+B,QAAkE;CAC3H,IAAI,CAAC,QAAQ,MAAM,WAAW,OAAO,IAAI,GAAG,OAAO;CACnD,MAAM,MAAmB,CAAC;CAC1B,MAAM,OAAoB,CAAC;CAC3B,QAAQ,SAAS,QAAQ,UAAU;EAClC,MAAM,OAAkB;GAAE;GAAQ,SAAS;EAAO;EAClD,IAAI,CAAC,OAAO,MAAM;GACjB,IAAI,KAAK,IAAI;GACb,KAAK,KAAK,IAAI;GACd;EACD;EACA,MAAM,SAAS,OAAO,OAAO,gBAAgB,OAAO,IAAI,IAAI,eAAe,OAAO,QAAQ,KAAA;EAC1F,IAAI;EACJ,KAAK,IAAI,IAAI,KAAK,SAAS,GAAG,KAAK,KAAK,UAAU,CAAC,IAAI,KAAK,IAAI,OAAO,MAAM,SAAS,KAAK,EAAE,CAAC,OAAO,IAAI,GAAG,KAAK,KAAK;EACtH,IAAI,CAAC,MAAM,CAAC,QAAQ;GACnB,SAAS,OAAO,MAAM;GACtB;EACD;EACA,MAAM,EAAE,MAAM,GAAG,GAAG,QAAQ;EAC5B,KAAK,SAAS;EACd,GAAG,YAAY,CAAC;EACf,CAAC,GAAG,QAAQ,OAAO,UAAU,CAAC,EAAA,CAAG,KAAK,IAAI;EAC3C,KAAK,KAAK,IAAI;CACf,CAAC;CACD,MAAM,QAAQ,SAA+B;EAC5C,IAAI,KAAK,WAAW,KAAK,SAAS,YAAY,IAAI,KAAK,QAAQ,KAAK,OAAO;EAC3E,IAAI,CAAC,KAAK,SAAS,OAAO,KAAK;EAC/B,MAAM,OAAO,EAAE,GAAG,UAAU,KAAK,MAAM,EAAE;EACzC,KAAK,MAAM,CAAC,MAAM,UAAU,OAAO,QAAQ,KAAK,OAAO,GACtD,KAAK,QAAQ,CAAC,GAAI,KAAK,SAAS,CAAC,GAAI,GAAG,MAAM,IAAI,IAAI,CAAC;EACxD,YAAY,IAAI,MAAmB,KAAK,OAAO;EAC/C,KAAK,MAAM,QAAQ,OAAO,KAAK,KAAK,OAAO,GAA8B,aAAa,IAAI,KAAK,OAAQ,KAAK,OAAO;EACnH,OAAO;CACR;CACA,OAAO,IAAI,IAAI,IAAI;AACpB;;;;;;AAwQA,IAAa,kBAAkB,YAAsC,QAAQ,WAAW,YAAY,QAAQ,UAAW,QAAQ,WAAW,CAAC;;;;;;;AAwe3I,IAAa,cAAc,QAC1B,IAAI,eAAe,KAAA,IAAY,CAAC,IAAI,OAAO,IAAI,eAAe,WAAW,CAAC,IAAI,UAAU,IAAI,IAAI;;;;;;AAOjG,IAAa,eAAe,QAAqB,IAAI,aAAa;CAAE,GAAG,KAAK,KAAK,IAAI,SAAS,CAAC;CAAG,GAAG,KAAK,KAAK,IAAI,SAAS,CAAC;AAAE;;;;;;;;;AAU/H,SAAgB,UAAU,KAA2B;CACpD,OACC,IAAI,SAAS,UACb,CAAC,IAAI,SAAS,UACd,CAAC,IAAI,QACL,CAAC,IAAI,WAAW,UAChB,CAAC,IAAI,aACL,CAAC,IAAI,OAAO,UACZ,CAAC,IAAI,QAAQ,UACb,CAAC,IAAI,YAAY,UACjB,CAAC,WAAW,GAAG,CAAC,CAAC,UACjB,IAAI,aAAa,KAAA,KACjB,CAAC,IAAI,aACL,IAAI,aAAa,KAAA,KACjB,CAAC,IAAI,MAAM,eACX,CAAC,IAAI,MAAM;AAEb;;AAGA,IAAa,cAAc;;AAG3B,SAAgB,SAAS,KAA0C;CAClE,MAAM,EAAE,WAAW;CACnB,OAAO,OAAO,WAAW,WAAW,SAAU,SAAA,aAAyB;AACxE;;AAGA,SAAgB,cAAc,KAA0D;CACvF,OAAO,QAAQ,IAAI,MAAM;AAC1B;;AAGA,SAAgB,cAAc,KAA+C;CAC5E,MAAM,EAAE,gBAAgB;CACxB,OAAO,OAAO,gBAAgB,WAAW,cAAe,cAAA,aAA8B;AACvF;;AAGA,SAAgB,mBAAmB,KAA+D;CACjG,OAAO,QAAQ,IAAI,WAAW;AAC/B;AAEA,SAAS,QAAQ,MAA2E;CAC3F,IAAI,CAAC,QAAQ,OAAO,SAAS,UAAU,OAAO,CAAC;CAC/C,MAAM,MAA8B,CAAC;CACrC,KAAK,MAAM,QAAQ,MAAM,IAAI,SAAA,UAAsB,IAAI,QAAQ,KAAK;CACpE,OAAO;AACR;;AAeA,IAAM,wBAAQ,IAAI,QAAoH;;;;;;;AAQtI,SAAgB,UAAU,KAAkB,MAAkB,QAAQ,OAAwB;CAC7F,MAAM,EAAE,UAAU,UAAU;CAC5B,IAAI,SAAS,MAAM,IAAI,IAAI;CAC3B,IAAI,CAAC,QAAQ,MAAM,IAAI,MAAO,SAAS;EAAE,sBAAM,IAAI,QAAQ;EAAG,wBAAQ,IAAI,QAAQ;CAAE,CAAE;CACtF,MAAM,QAAQ,QAAQ,OAAO,SAAS,OAAO;CAC7C,IAAI,QAAQ,MAAM,IAAI,GAAG;CACzB,IAAI,CAAC,OAAO;EACX,MAAM,QAAQ,QAAS,IAAI,cAAc,KAAK,MAAM,IAAI,QAAQ,MAAM,IAAI,UAAU,IAAK,IAAI;EAC7F,QAAQ,OAAO,OAAO;GAAE,GAAG,KAAK;GAAc;GAAO,GAAG,IAAI;GAAO,GAAI,IAAI,OAAO,EAAE,QAAQ,IAAI,KAAK,IAAI,KAAA;EAAW,CAAC;EACrH,MAAM,IAAI,KAAK,KAAK;CACrB;CACA,OAAO;AACR;;;;;;;AAQA,SAAgB,MAAM,SAAqB,OAAqC;CAC/E,MAAM,EAAE,QAAQ;CAChB,IAAI,KAAK;EACR,IAAI,IAAI,UAAU,UAAU,OAAO;GAAE,OAAO;GAAU,QAAQ,GAAG,IAAI,QAAQ,KAAK;EAAE;EACpF,IAAI,IAAI,UAAU,QAAQ,OAAO;GAAE,OAAO;GAAQ,QAAQ,GAAG,IAAI,QAAQ,KAAK;GAAG,OAAO,IAAI;EAAM;EAClG,IAAI,IAAI,UAAU,QAAQ,OAAO;GAAE,OAAO;GAAQ,QAAQ,GAAG,IAAI,QAAQ,KAAK;GAAG,OAAO,GAAG,IAAI,OAAO,KAAK;EAAE;EAC7G,IAAI,IAAI,UAAU,OAAO,OAAO;GAAE,OAAO;GAAO,QAAQ,GAAG,IAAI,QAAQ,KAAK;GAAG,OAAO,IAAI;GAAO,OAAO,GAAG,IAAI,OAAO,KAAK;EAAE;EAC7H,OAAO;GAAE,OAAO,IAAI;GAAO,QAAQ,GAAG,IAAI,QAAQ,KAAK;GAAG,OAAO,GAAG,IAAI,OAAO,KAAK;EAAE;CACvF;CACA,MAAM,UAAU,QAAQ,QAAQ,MAAM,WAAW,OAAO,SAAS,SAAS;CAC1E,IAAI,SAAS,OAAO;EAAE,OAAO;EAAQ,QAAQ,GAAG,QAAQ,UAAU,OAAO,EAAE;EAAG,OAAO,WAAW,QAAQ,QAAQ,OAAO,CAAC;CAAE;CAE1H,MAAM,YAAY,SAAS,QAAQ,SAAS,KAAK;CACjD,IAAI,WAAW,OAAO;CACtB,IAAI,SAAS;CACb,KAAK,MAAM,UAAU,WAAW,QAAQ,OAAO,GAAG,IAAI,OAAO,SAAS,QAAQ,SAAS,KAAK,IAAI,QAAQ,WAAW,OAAO,QAAQ,KAAK,CAAC;CACxI,OAAO,SAAS,IAAI;EAAE,OAAO;EAAU;CAAO,IAAI,KAAA;AACnD;;AAGA,SAAS,SAAS,SAA2C,OAAqC;CACjG,KAAK,MAAM,QAAQ,WAAW,WAAW,CAAC,CAAC,GAAG;EAC7C,MAAM,SAAS,UAAU,IAAI;EAC7B,MAAM,EAAE,UAAU;EAClB,MAAM,QAAQ,OAAgC,WAAW,MAAM,WAAW,OAAO,OAAO,QAAQ;EAChG,MAAM,QAAQ,KAAK,OAAO,OAAO,CAAC;EAClC,QAAQ,OAAR;GACC,KAAK,QACJ,OAAO;IAAE;IAAO,QAAQ,KAAK,OAAO,MAAM;IAAG,OAAO,KAAK,OAAO,KAAK;GAAE;GACxE,KAAK;GACL,KAAK;GACL,KAAK,SACJ,OAAO;IAAE;IAAO,QAAQ,KAAK,OAAO,MAAM;IAAG;GAAM;GACpD,KAAK,QACJ,OAAO;IAAE;IAAO,QAAQ,KAAK,OAAO,MAAM;IAAG;GAAM;GACpD,KAAK,OACJ,OAAO;IAAE;IAAO,QAAQ,KAAK,OAAO,MAAM;IAAG,OAAO,KAAK,OAAO,KAAK;IAAG;GAAM;EAChF;EACA,IAAI,OAAO,SAAS,UAAU,OAAO,SAAS,SAAS;GACtD,MAAM,QAAQ,SAAS,OAAO,SAAS,KAAK;GAC5C,IAAI,OAAO,OAAO;EACnB;CACD;AAED"}

package/dist/denying.d.ts

@@ -5,7 +5,7 @@ import type { World } from './world';
 /**
  * Denying, as in a MOBA (features-plan E): a player may tell their units to attack one of their own side's, which
  * they never do by themselves, once it is low enough on health that the other side would soon have it: the last hit
- * on it is theirs, not the enemy's. Hooks for `GameModule.hooks`:
+ * on it is theirs, not the enemy's. Hooks for `Rules.hooks`:
  *
  *     hooks: [...denying({ below: 0.5 })]
  *
@@ -37,7 +37,7 @@ export declare function mayDeny(world: World, attacker: Entity, target: Entity,
  */
 export declare function denying(options?: DenyOptions): HookDef[];
 /**
- * What a game counts of last hits and denies (`withLastHits`)
+ * What a game counts of last hits and denies (`lastHitsPack`)
  *
  * @beta
  */
@@ -62,7 +62,7 @@ export declare const counted: import("./components").Component<Record<string, {
 }>>;
 /**
  * A player's last hits (enemy units they gave the killing blow to) and denies (their own side's), as counted
- * (`withLastHits`)
+ * (`lastHitsPack`)
  *
  * @beta
  */
@@ -78,4 +78,4 @@ export declare function lastHitsOf(world: World, player: PlayerId): {
  *
  * @beta
  */
-export declare function withLastHits(options?: LastHitOptions): GamePack;
+export declare function lastHitsPack(options?: LastHitOptions): GamePack;

package/dist/denying.js

@@ -0,0 +1,106 @@
+import { distSq } from "./math.js";
+import { defineComponent } from "./components.js";
+import { grantXp, heroOf, heroState, maxLevelOf, xpWorth } from "./hero.js";
+import { defineHook } from "./hooks.js";
+import { attackReaches } from "./systems/combat.js";
+//#region src/denying.ts
+/** Units, not heroes nor structures: what the engine lets be denied */
+var units = (_world, _attacker, target) => target.isUnit && !target.def.hero;
+/**
+* Whether an attack on one's own side is a deny the rules allow (`DenyOptions`): told to, low enough, of what may be
+*
+* @beta
+*/
+function mayDeny(world, attacker, target, options = {}) {
+	if (world.areEnemies(attacker.owner, target.owner)) return false;
+	if (target.health >= target.maxHealth * (options.below ?? .5)) return false;
+	return attackReaches(world, attacker, target) && (options.denies ?? units)(world, attacker, target);
+}
+/**
+* The hooks of denying (see `DenyOptions`)
+*
+* @beta
+*/
+function denying(options = {}) {
+	return [defineHook({
+		hook: "canAttack",
+		id: options.id ?? "deny",
+		run(world, event) {
+			if (!event.cancelled || !event.ordered) return;
+			if (mayDeny(world, event.attacker, event.target, options)) event.cancelled = false;
+		}
+	})];
+}
+/** Every player's last hits and denies, by player id: saved with the game */
+var counted = defineComponent({
+	id: "lastHits",
+	default: () => ({})
+});
+/**
+* A player's last hits (enemy units they gave the killing blow to) and denies (their own side's), as counted
+* (`lastHitsPack`)
+*
+* @beta
+*/
+function lastHitsOf(world, player) {
+	return world.state(counted)[player] ?? {
+		lastHits: 0,
+		denies: 0
+	};
+}
+/** What the engine counts: units, not heroes nor structures */
+var countsUnits = (_world, dead) => dead.isUnit && !dead.def.hero;
+/**
+* A game where last hits and denies count, as in a MOBA: each player's are counted (`lastHitsOf`, saved), a unit
+* denied gives no bounty (as one killed by its own side never does) and only a part of its experience to the enemy
+* heroes near it, and its death says so to the screen (`how: 'denied'`, which the client shows over it). With the rule
+* of denying (`denying`) unless told otherwise
+*
+* @beta
+*/
+function lastHitsPack(options = {}) {
+	const counts = options.counts ?? countsUnits;
+	const part = options.experience ?? .5;
+	const count = defineHook({
+		hook: "death",
+		id: "lastHits",
+		run(world, event) {
+			const { entity, killer } = event;
+			if (!killer || killer === entity || !counts(world, entity)) return;
+			const all = world.state(counted);
+			const player = killer.owner;
+			const mine = all[player] ??= {
+				lastHits: 0,
+				denies: 0
+			};
+			if (world.areEnemies(player, entity.owner)) {
+				mine.lastHits++;
+				return;
+			}
+			if (!world.areAllies(player, entity.owner)) return;
+			mine.denies++;
+			event.how ??= "denied";
+			const worth = xpWorth(world, entity) * part;
+			if (worth <= 0) return;
+			const range = world.settings.heroes.xpRange;
+			const heroes = [];
+			for (const hero of world.index.with(heroState)) {
+				const state = heroOf(hero);
+				if (!state || !hero.alive || !world.areEnemies(hero.owner, entity.owner)) continue;
+				if (state.level >= maxLevelOf(world, hero)) continue;
+				if (distSq(hero.pos, entity.pos) <= range * range) heroes.push(hero);
+			}
+			for (const hero of heroes) grantXp(world, hero, worth / heroes.length, entity);
+		}
+	});
+	return {
+		id: "lastHits",
+		options,
+		components: [counted],
+		hooks: [...options.deny === false ? [] : denying(options.deny), count]
+	};
+}
+//#endregion
+export { counted, denying, lastHitsOf, lastHitsPack, mayDeny };
+
+//# sourceMappingURL=denying.js.map

package/dist/denying.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"denying.js","names":[],"sources":["../src/denying.ts"],"sourcesContent":["import { defineComponent } from './components'\nimport type { GamePack } from './packs/pack'\nimport { distSq } from './math'\nimport type { Entity, PlayerId } from './entity'\nimport { grantXp, heroOf, heroState, maxLevelOf, xpWorth } from './hero'\nimport { defineHook, type HookDef } from './hooks'\nimport { attackReaches } from './systems/combat'\nimport type { World } from './world'\n\n/**\n * Denying, as in a MOBA (features-plan E): a player may tell their units to attack one of their own side's, which\n * they never do by themselves, once it is low enough on health that the other side would soon have it: the last hit\n * on it is theirs, not the enemy's. Hooks for `Rules.hooks`:\n *\n *     hooks: [...denying({ below: 0.5 })]\n *\n * Only an attack a player orders (`CanAttack.ordered`): units never pick their own side to attack, nor fight back at it\n *\n * @beta\n */\nexport interface DenyOptions {\n\t/** How low on health, of its most, one of one's own side has to be to be attacked: below half when left out */\n\tbelow?: number\n\t/**\n\t * What of one's own side may be attacked, past `below`: units, not heroes nor structures, when left out. A game's own,\n\t * to let towers be denied, or only creeps\n\t */\n\tdenies?: (world: World, attacker: Entity, target: Entity) => boolean\n\t/** The id of the hook, to replace or leave out: `deny` when left out */\n\tid?: string\n}\n\n/** Units, not heroes nor structures: what the engine lets be denied */\nconst units = (_world: World, _attacker: Entity, target: Entity) => target.isUnit && !target.def.hero\n\n/**\n * Whether an attack on one's own side is a deny the rules allow (`DenyOptions`): told to, low enough, of what may be\n *\n * @beta\n */\nexport function mayDeny(world: World, attacker: Entity, target: Entity, options: DenyOptions = {}): boolean {\n\tif (world.areEnemies(attacker.owner, target.owner)) return false\n\tif (target.health >= target.maxHealth * (options.below ?? 0.5)) return false\n\treturn attackReaches(world, attacker, target) && (options.denies ?? units)(world, attacker, target)\n}\n\n/**\n * The hooks of denying (see `DenyOptions`)\n *\n * @beta\n */\nexport function denying(options: DenyOptions = {}): HookDef[] {\n\treturn [\n\t\tdefineHook({\n\t\t\thook: 'canAttack',\n\t\t\tid: options.id ?? 'deny',\n\t\t\trun(world, event) {\n\t\t\t\tif (!event.cancelled || !event.ordered) return\n\t\t\t\tif (mayDeny(world, event.attacker, event.target, options)) event.cancelled = false\n\t\t\t}\n\t\t})\n\t]\n}\n\n// ---- last hits and denies (features-plan E2)\n\n/**\n * What a game counts of last hits and denies (`lastHitsPack`)\n *\n * @beta\n */\nexport interface LastHitOptions {\n\t/** The rule of denying (`denying`), or `false` for a game that only counts last hits: the engine's when left out */\n\tdeny?: DenyOptions | false\n\t/**\n\t * The part of a unit's experience the enemy heroes near it still get when it is denied, shared as for a kill: a half\n\t * when left out (none for a kill by the enemy would be no deny at all; all of it, no point in denying)\n\t */\n\texperience?: number\n\t/** Which deaths count, as last hits or denies: units, not heroes nor structures, when left out */\n\tcounts?: (world: World, dead: Entity) => boolean\n}\n\n/** Every player's last hits and denies, by player id: saved with the game */\nexport const counted = defineComponent<Record<string, { lastHits: number; denies: number }>>({ id: 'lastHits', default: () => ({}) })\n\n/**\n * A player's last hits (enemy units they gave the killing blow to) and denies (their own side's), as counted\n * (`lastHitsPack`)\n *\n * @beta\n */\nexport function lastHitsOf(world: World, player: PlayerId): { lastHits: number; denies: number } {\n\tconst all = world.state(counted)\n\treturn all[player] ?? { lastHits: 0, denies: 0 }\n}\n\n/** What the engine counts: units, not heroes nor structures */\nconst countsUnits = (_world: World, dead: Entity) => dead.isUnit && !dead.def.hero\n\n/**\n * A game where last hits and denies count, as in a MOBA: each player's are counted (`lastHitsOf`, saved), a unit\n * denied gives no bounty (as one killed by its own side never does) and only a part of its experience to the enemy\n * heroes near it, and its death says so to the screen (`how: 'denied'`, which the client shows over it). With the rule\n * of denying (`denying`) unless told otherwise\n *\n * @beta\n */\nexport function lastHitsPack(options: LastHitOptions = {}): GamePack {\n\tconst counts = options.counts ?? countsUnits\n\tconst part = options.experience ?? 0.5\n\tconst count = defineHook({\n\t\thook: 'death',\n\t\tid: 'lastHits',\n\t\trun(world, event) {\n\t\t\tconst { entity, killer } = event\n\t\t\tif (!killer || killer === entity || !counts(world, entity)) return\n\t\t\tconst all = world.state(counted)\n\t\t\tconst player = killer.owner\n\t\t\tconst mine = (all[player] ??= { lastHits: 0, denies: 0 })\n\t\t\tif (world.areEnemies(player, entity.owner)) {\n\t\t\t\tmine.lastHits++\n\t\t\t\treturn\n\t\t\t}\n\t\t\tif (!world.areAllies(player, entity.owner)) return\n\t\t\tmine.denies++\n\t\t\tevent.how ??= 'denied'\n\t\t\t// the enemy's heroes near it get a part of what it was worth\n\t\t\tconst worth = xpWorth(world, entity) * part\n\t\t\tif (worth <= 0) return\n\t\t\tconst range = world.settings.heroes.xpRange\n\t\t\tconst heroes: Entity[] = []\n\t\t\t// the heroes alone, as the index files them (in the order of their ids, as a walk through every entity met them)\n\t\t\tfor (const hero of world.index.with(heroState)) {\n\t\t\t\tconst state = heroOf(hero)\n\t\t\t\tif (!state || !hero.alive || !world.areEnemies(hero.owner, entity.owner)) continue\n\t\t\t\tif (state.level >= maxLevelOf(world, hero)) continue\n\t\t\t\tif (distSq(hero.pos, entity.pos) <= range * range) heroes.push(hero)\n\t\t\t}\n\t\t\tfor (const hero of heroes) grantXp(world, hero, worth / heroes.length, entity)\n\t\t}\n\t})\n\treturn {\n\t\tid: 'lastHits',\n\t\toptions,\n\t\tcomponents: [counted],\n\t\thooks: [...(options.deny === false ? [] : denying(options.deny)), count]\n\t}\n}\n"],"mappings":";;;;;;;AAiCA,IAAM,SAAS,QAAe,WAAmB,WAAmB,OAAO,UAAU,CAAC,OAAO,IAAI;;;;;;AAOjG,SAAgB,QAAQ,OAAc,UAAkB,QAAgB,UAAuB,CAAC,GAAY;CAC3G,IAAI,MAAM,WAAW,SAAS,OAAO,OAAO,KAAK,GAAG,OAAO;CAC3D,IAAI,OAAO,UAAU,OAAO,aAAa,QAAQ,SAAS,KAAM,OAAO;CACvE,OAAO,cAAc,OAAO,UAAU,MAAM,MAAM,QAAQ,UAAU,MAAA,CAAO,OAAO,UAAU,MAAM;AACnG;;;;;;AAOA,SAAgB,QAAQ,UAAuB,CAAC,GAAc;CAC7D,OAAO,CACN,WAAW;EACV,MAAM;EACN,IAAI,QAAQ,MAAM;EAClB,IAAI,OAAO,OAAO;GACjB,IAAI,CAAC,MAAM,aAAa,CAAC,MAAM,SAAS;GACxC,IAAI,QAAQ,OAAO,MAAM,UAAU,MAAM,QAAQ,OAAO,GAAG,MAAM,YAAY;EAC9E;CACD,CAAC,CACF;AACD;;AAsBA,IAAa,UAAU,gBAAsE;CAAE,IAAI;CAAY,gBAAgB,CAAC;AAAG,CAAC;;;;;;;AAQpI,SAAgB,WAAW,OAAc,QAAwD;CAEhG,OADY,MAAM,MAAM,OACjB,CAAA,CAAI,WAAW;EAAE,UAAU;EAAG,QAAQ;CAAE;AAChD;;AAGA,IAAM,eAAe,QAAe,SAAiB,KAAK,UAAU,CAAC,KAAK,IAAI;;;;;;;;;AAU9E,SAAgB,aAAa,UAA0B,CAAC,GAAa;CACpE,MAAM,SAAS,QAAQ,UAAU;CACjC,MAAM,OAAO,QAAQ,cAAc;CACnC,MAAM,QAAQ,WAAW;EACxB,MAAM;EACN,IAAI;EACJ,IAAI,OAAO,OAAO;GACjB,MAAM,EAAE,QAAQ,WAAW;GAC3B,IAAI,CAAC,UAAU,WAAW,UAAU,CAAC,OAAO,OAAO,MAAM,GAAG;GAC5D,MAAM,MAAM,MAAM,MAAM,OAAO;GAC/B,MAAM,SAAS,OAAO;GACtB,MAAM,OAAQ,IAAI,YAAY;IAAE,UAAU;IAAG,QAAQ;GAAE;GACvD,IAAI,MAAM,WAAW,QAAQ,OAAO,KAAK,GAAG;IAC3C,KAAK;IACL;GACD;GACA,IAAI,CAAC,MAAM,UAAU,QAAQ,OAAO,KAAK,GAAG;GAC5C,KAAK;GACL,MAAM,QAAQ;GAEd,MAAM,QAAQ,QAAQ,OAAO,MAAM,IAAI;GACvC,IAAI,SAAS,GAAG;GAChB,MAAM,QAAQ,MAAM,SAAS,OAAO;GACpC,MAAM,SAAmB,CAAC;GAE1B,KAAK,MAAM,QAAQ,MAAM,MAAM,KAAK,SAAS,GAAG;IAC/C,MAAM,QAAQ,OAAO,IAAI;IACzB,IAAI,CAAC,SAAS,CAAC,KAAK,SAAS,CAAC,MAAM,WAAW,KAAK,OAAO,OAAO,KAAK,GAAG;IAC1E,IAAI,MAAM,SAAS,WAAW,OAAO,IAAI,GAAG;IAC5C,IAAI,OAAO,KAAK,KAAK,OAAO,GAAG,KAAK,QAAQ,OAAO,OAAO,KAAK,IAAI;GACpE;GACA,KAAK,MAAM,QAAQ,QAAQ,QAAQ,OAAO,MAAM,QAAQ,OAAO,QAAQ,MAAM;EAC9E;CACD,CAAC;CACD,OAAO;EACN,IAAI;EACJ;EACA,YAAY,CAAC,OAAO;EACpB,OAAO,CAAC,GAAI,QAAQ,SAAS,QAAQ,CAAC,IAAI,QAAQ,QAAQ,IAAI,GAAI,KAAK;CACxE;AACD"}

package/dist/destructibles.d.ts

@@ -8,7 +8,7 @@ import type { World } from './world';
  */
 export declare const DESTRUCTIBLES = "core.destructibles";
 /**
- * What the destructibles pack is made with (`withDestructibles`)
+ * What the destructibles pack is made with (`destructiblesPack`)
  *
  * @beta
  */
@@ -24,4 +24,4 @@ export interface DestructiblesOptions {
  *
  * @beta
  */
-export declare function withDestructibles(options?: DestructiblesOptions): GamePack;
+export declare function destructiblesPack(options?: DestructiblesOptions): GamePack;

package/dist/destructibles.js

@@ -0,0 +1,36 @@
+import { defineHook } from "./hooks.js";
+import { attackReaches } from "./systems/combat.js";
+//#region src/destructibles.ts
+/**
+* The destructibles pack's id
+*
+* @beta
+*/
+var DESTRUCTIBLES = "core.destructibles";
+/**
+* Destructibles, as in classic RTS games: what is `destructible` (`UnitTypeDef.destructible`, a building of the neutral player
+* placed on the map: rocks, a barricade, a gate to break down) stands in the way until it is brought down, and any unit
+* whose attack reaches it attacks it when told to (the attack command), never of its own accord, as trees are felled
+* by what fells them. A gate that opens and shuts is the map's (`setGate`); one that is broken down is a destructible
+*
+* @beta
+*/
+function destructiblesPack(options = {}) {
+	const destructible = options.destructible ?? ((_world, entity) => !!entity.def.destructible);
+	return {
+		id: DESTRUCTIBLES,
+		options,
+		hooks: [defineHook({
+			hook: "canAttack",
+			id: "destructibles",
+			run(world, event) {
+				if (!event.cancelled || !event.ordered) return;
+				if (destructible(world, event.target) && attackReaches(world, event.attacker, event.target)) event.cancelled = false;
+			}
+		})]
+	};
+}
+//#endregion
+export { DESTRUCTIBLES, destructiblesPack };
+
+//# sourceMappingURL=destructibles.js.map

package/dist/destructibles.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"destructibles.js","names":[],"sources":["../src/destructibles.ts"],"sourcesContent":["import type { Entity } from './entity'\nimport { defineHook } from './hooks'\nimport type { GamePack } from './packs/pack'\nimport { attackReaches } from './systems/combat'\nimport type { World } from './world'\n\n/*\n * Destructibles, an opt-in pack (review RV95): rocks, barricades and gates to break down, beyond the trees that are\n * felled. A thing of the map that stands in the way as a building does, and that a unit attacks when it is told to\n */\n\n/**\n * The destructibles pack's id\n *\n * @beta\n */\nexport const DESTRUCTIBLES = 'core.destructibles'\n\n/**\n * What the destructibles pack is made with (`destructiblesPack`)\n *\n * @beta\n */\nexport interface DestructiblesOptions {\n\t/** Whether something is brought down by being attacked when told to, in code: its type's `destructible` when left out */\n\tdestructible?: (world: World, entity: Entity) => boolean\n}\n\n/**\n * Destructibles, as in classic RTS games: what is `destructible` (`UnitTypeDef.destructible`, a building of the neutral player\n * placed on the map: rocks, a barricade, a gate to break down) stands in the way until it is brought down, and any unit\n * whose attack reaches it attacks it when told to (the attack command), never of its own accord, as trees are felled\n * by what fells them. A gate that opens and shuts is the map's (`setGate`); one that is broken down is a destructible\n *\n * @beta\n */\nexport function destructiblesPack(options: DestructiblesOptions = {}): GamePack {\n\tconst destructible = options.destructible ?? ((_world: World, entity: Entity) => !!entity.def.destructible)\n\tconst attacked = defineHook({\n\t\thook: 'canAttack',\n\t\tid: 'destructibles',\n\t\trun(world, event) {\n\t\t\tif (!event.cancelled || !event.ordered) return\n\t\t\tif (destructible(world, event.target) && attackReaches(world, event.attacker, event.target)) event.cancelled = false\n\t\t}\n\t})\n\treturn { id: DESTRUCTIBLES, options, hooks: [attacked] }\n}\n"],"mappings":";;;;;;;;AAgBA,IAAa,gBAAgB;;;;;;;;;AAoB7B,SAAgB,kBAAkB,UAAgC,CAAC,GAAa;CAC/E,MAAM,eAAe,QAAQ,kBAAkB,QAAe,WAAmB,CAAC,CAAC,OAAO,IAAI;CAS9F,OAAO;EAAE,IAAI;EAAe;EAAS,OAAO,CAR3B,WAAW;GAC3B,MAAM;GACN,IAAI;GACJ,IAAI,OAAO,OAAO;IACjB,IAAI,CAAC,MAAM,aAAa,CAAC,MAAM,SAAS;IACxC,IAAI,aAAa,OAAO,MAAM,MAAM,KAAK,cAAc,OAAO,MAAM,UAAU,MAAM,MAAM,GAAG,MAAM,YAAY;GAChH;EACD,CAC6C,CAAQ;CAAE;AACxD"}

package/dist/determinism.d.ts

@@ -3,7 +3,7 @@
  * that runs a world twice, and on from a save, and says the first tick and the first thing they differ at. What a
  * replay of commands, a save that goes on exactly and a game the same in every browser stand on
  */
-import { type GameModule } from './game';
+import { type Rules } from './game';
 import { type WorldSave } from './save';
 import type { Registry } from './registry';
 import type { World } from './world';
@@ -93,7 +93,7 @@ export interface DeterminismOptions {
      */
     from?: number;
     /** The game the save is loaded with, for `from` */
-    game?: GameModule;
+    rules?: Rules;
 }
 /**
  * What the check found: for each run, where it came apart from the first, or `null` for the same to the last tick
@@ -113,9 +113,9 @@ export interface DeterminismReport {
  * from the save, and the two run on side by side. Says, for each, the first tick and thing it differs at, or that it does not. A test of a game's
  * own systems: one that reads `Math.random`, the clock, or the order of something unordered is found here
  *
- *     const report = await checkDeterminism(() => makeMyGame(1), { ticks: 1800, from: 300, game: rules })
+ *     const report = await checkDeterminism(() => makeMyGame(1), { ticks: 1800, from: 300, rules })
  *     expect(report).toEqual({ twice: null, fromSave: null })
  *
- * @beta
+ * @public
  */
 export declare function checkDeterminism(make: () => World | Promise<World>, options: DeterminismOptions): Promise<DeterminismReport>;