@v12-engine/engine 0.0.0-stage → 0.1.1

package/dist/replication.d.ts

@@ -0,0 +1,103 @@
+/**
+ * What a player is told of a world, written with what it tells of (design review E7): an event of the world becomes an
+ * event on a player's screen by the rule beside the code that emits it (`replicateEvent`), and a part of the snapshot is
+ * captured by the feature it is of (`SnapshotPart`). A seat (`LocalSession`) runs what its game has of them
+ * (`Registry.replications`, `Registry.snapshotParts`: the engine's, then the packs'), for what its player may know
+ * (`SessionView`)
+ */
+import type { Entity, PlayerId } from './entity';
+import type { EventKey } from './events';
+import type { SessionEvent, SessionEvents, Snapshot } from './session/protocol';
+import type { World } from './world';
+import { type TeamMemory } from './session/memory';
+/**
+ * A seat's side of a world: whose it is, and what they may know of it now. What the rules that tell a player of the
+ * world ask (`replicateEvent`, `SnapshotPart`, an event of a game's own's `replicate`), and what a seat keeps for them
+ * (`keep`)
+ *
+ * @beta
+ */
+export declare class SessionView {
+    readonly world: World;
+    /** The seat's player: from whose side it sees, an observer's too */
+    readonly player: PlayerId;
+    /** Who only watches, and sees everything (`LocalSession.observer`) */
+    readonly observer: boolean;
+    /** Whether the seat is a computer player's, which is told only what a brain reads (`LocalSession.forComputer`) */
+    readonly forComputer: boolean;
+    /** How many effects of the rules are kept for their stop to be told (`LocalSession` options' `mostEffects`) */
+    readonly mostEffects: number;
+    /** What the seat was told since its last snapshot, for the next one */
+    events: SessionEvent[];
+    private readonly kept;
+    constructor(world: World, 
+    /** The seat's player: from whose side it sees, an observer's too */
+    player: PlayerId, options?: {
+        observer?: boolean;
+        forComputer?: boolean;
+        mostEffects?: number;
+    });
+    /** The player's team: theirs now, as the rules may move them to another (`setTeam`) */
+    get team(): number;
+    /** Whether an owner is the player or an ally of theirs: an observer's is everyone */
+    readonly isAlly: (owner: PlayerId) => boolean;
+    /** Whether the player's team sees a spot of the map right now: an observer sees all of it */
+    readonly sees: (x: number, z: number) => boolean;
+    /** Whether the player's team can see the entity right now: its side's always */
+    readonly knows: (entity: Entity) => boolean;
+    /** An observer's own memory: it sees everything, which is no team's to remember */
+    private readonly ownMemory;
+    /**
+     * What the player's team remembers of what it saw (`teamMemory`: the structures out of sight as last seen, the camps
+     * seen empty), or an observer's own. Looked up again each time: the player may have moved to another team since
+     */
+    get memory(): TeamMemory;
+    /** What the seat keeps under a key for what tells it things (the effects it was shown, the score last told): made the first time */
+    keep<S>(key: object, make: () => S): S;
+    /** Takes what the seat was told since the last snapshot */
+    takeEvents(): SessionEvent[];
+}
+/**
+ * The event on a screen of a kind
+ *
+ * @beta
+ */
+export type SessionEventOf<K extends keyof SessionEvents> = SessionEvents[K];
+/**
+ * How an event of the world is told to a player (`replicateEvent`): what the seat hears it as, and what it says of it
+ * to the player, if anything
+ *
+ * @beta
+ */
+export interface ReplicatedEvent {
+    /** The kind of event on the screen: a computer's seat hears only the kinds a brain reads (`COMPUTER_EVENTS`) */
+    readonly as: SessionEvent['type'];
+    /** The world's event it tells of: one of the engine's (`engineEvents`) or a game's own (`defineEvent`) */
+    readonly event: EventKey<unknown>;
+    /** What the player is told of it: nothing for what they may not know */
+    tell(payload: unknown, view: SessionView): SessionEvent | undefined;
+}
+/**
+ * How an event of the world is told to a player, written beside what emits it: `replicateEvent(healed, 'heal', (heal,
+ * view) => view.knows(heal.target) ? { type: 'heal', ... } : undefined)`. Listed by the engine for its own, by a pack in
+ * `GamePack.replications`
+ *
+ * @beta
+ */
+export declare function replicateEvent<T, A extends keyof SessionEvents>(event: EventKey<T>, as: A, tell: (payload: T, view: SessionView) => SessionEventOf<A> | undefined): ReplicatedEvent;
+/**
+ * A part of the snapshot a player is sent, captured by the feature it is of: the projectiles, the items on the
+ * ground, the score. Before the entities (`head`) or after the players; left out of the snapshot where it gives
+ * nothing (`undefined`). Listed by the engine for its own, by a pack in `GamePack.snapshotParts` (a key of its own
+ * added to `Snapshot` by declaration merging)
+ *
+ * @beta
+ */
+export interface SnapshotPart<K extends keyof Snapshot = keyof Snapshot> {
+    readonly key: K;
+    /** Before the entities and the players, where the tick's own facts are (the hour, the outcome) */
+    readonly head?: boolean;
+    capture(view: SessionView): Snapshot[K] | undefined;
+}
+/** What the seat was told since its last snapshot (`Snapshot.events`) */
+export declare const eventsPart: SnapshotPart<keyof Snapshot>;

package/dist/rng.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Small seeded PRNG (mulberry32). The simulation never touches Math.random so runs are reproducible.
+ *
+ * @beta
+ */
+export declare class Rng {
+    private state;
+    constructor(seed: number);
+    /** Float in [0, 1) */
+    next(): number;
+    /** Where it is in its sequence, for a save. `restore` with it carries on with the very same numbers */
+    save(): number;
+    restore(state: number): void;
+    range(min: number, max: number): number;
+    /** Integer in [min, max] */
+    int(min: number, max: number): number;
+}

package/dist/rules.d.ts

@@ -0,0 +1,395 @@
+import type { DamageType, Stats, UnitTypeDef } from './defs';
+import type { Registry } from './registry';
+import type { Entity, PlayerId } from './entity';
+import { type Upkeep } from './upkeep';
+import type { World } from './world';
+import type { OrderInit } from './registry';
+import type { GameModule } from './game';
+import type { ScoreRules } from './score';
+import { type HeroRules } from './hero';
+/**
+ * A rule of `HudSharing`: one value for every unit, or a function deciding it for each (only heroes', only a boss's)
+ *
+ * @beta
+ */
+export type HudShareRule<T> = T | ((world: World, entity: Entity) => T);
+/**
+ * What of a unit the players who see it are told beyond what they always are (`GameRules.hud`), each for the plates
+ * over it to show. What is not shared never reaches a player, so no screen can show it. A game's own data goes in a
+ * component with `replicate` (the client's `hudData` reads it)
+ *
+ * @beta
+ */
+export interface HudSharing {
+    /**
+     * The seconds left of its buffs (`EntityState.buffTimes`): to everyone who sees it (`true`), to its owner and their
+     * allies (`'allies'`), or to no one (`false`, when left out)
+     */
+    shareBuffTimes?: HudShareRule<boolean | 'allies'>;
+    /**
+     * Its abilities (`EntityState.abilities`) to everyone who sees it, its side's or not: those it has learned and
+     * their levels (`'icons'`), with how much of their cooldowns is left too (`'cooldowns'`), or none (`'none'`, when
+     * left out: its side has them in `own` all the same)
+     */
+    shareAbilities?: HudShareRule<'none' | 'icons' | 'cooldowns'>;
+    /** A hero's experience (`HeroSent.xp`) to everyone who sees it. Its side's alone when left out */
+    shareXp?: HudShareRule<boolean>;
+}
+/**
+ * A unit in a queue, not made yet, as the supply it will take is asked of it (`GameRules.supply.of`)
+ *
+ * @beta
+ */
+export interface QueuedUnit {
+    readonly def: UnitTypeDef;
+    readonly owner: PlayerId;
+    readonly queued: true;
+}
+/**
+ * How the fog of war keeps what was seen (`GameRules.fog`)
+ *
+ * @beta
+ */
+export interface FogRules {
+    /** Part of its sight a unit has at night, for types that do not say (`UnitTypeDef.sightNight`) */
+    nightSight: number;
+    /**
+     * What is kept of what was seen once: `remembered`, ground drawn dim and buildings as they were last seen (when left
+     * out); `nothing`, out of sight is as never seen (ground black again, buildings forgotten; building there is still
+     * allowed)
+     */
+    explored?: 'remembered' | 'nothing';
+    /**
+     * The whole map explored from the start, the fog over it all the same (as classic RTS melee maps are): the ground drawn
+     * dim, and what stands on it and belongs to no player (trees, mines, rocks, neutral buildings: shops, taverns, the
+     * creeps' own) seen from the first moment, as it stood then; units, and players' buildings, only once in sight. A map
+     * says otherwise (`MapDef.explored`). No when left out
+     */
+    startExplored?: boolean;
+    /** How ground never seen is drawn: `black` (when left out), or `dim` as explored ground is */
+    mask?: 'black' | 'dim';
+}
+/**
+ * The numbers and formulas of a kind of game that are not about any one unit: the supply cap, what selling gives
+ * back, how a hit is mitigated. In groups, each about one thing: supply, production, the economy, combat, movement,
+ * the fog, talk, the camps, heroes, what the HUD is told, the score. A game module changes the ones it wants
+ * (`GameModule.rules`: any of a group, the rest of it the engine's) and a pack the ones it brings (`GamePack.rules`).
+ *
+ * Read them from `world.rules` in the simulation, and from `session.registry.rules` on a player's screen.
+ *
+ * @beta
+ */
+export interface GameRules {
+    /** What armies cost in supply, and how much a player may have (`SupplyRules`) */
+    supply: SupplyRules;
+    /** What buildings make and how they go up (`ProductionRules`) */
+    production: ProductionRules;
+    /** What is paid back, paid for and given away (`EconomyRules`) */
+    economy: EconomyRules;
+    /** How a hit lands and how much of it is felt, and who fights whom (`CombatRules`) */
+    combat: CombatRules;
+    /** How units find their way among each other (`MovementRules`) */
+    movement: MovementRules;
+    /** What is seen and kept of what was (`FogRules`) */
+    fog: FogRules;
+    /** Pings, chat and pauses (`TalkRules`) */
+    talk: TalkRules;
+    /**
+     * Creeps' camps (`camps.ts`): how far creeps chase away from their camp (`leash`), whether they sleep at home at night
+     * until attacked (`sleep`), and the seconds after a camp is cleared that it comes back, for every camp (`respawn`, see
+     * `Camp.respawn`; never when left out). What makes creeps keep to them, sleep and come back is the heroes pack's
+     * (`withHeroes`)
+     */
+    camps: CampRules;
+    /**
+     * Heroes' numbers (`HeroRules`): how many a player may have, the experience a level takes, what bringing one back
+     * costs. The heroes pack's to change (`withHeroes(rules)`); the classic RTS numbers when left out
+     */
+    heroes: HeroRules;
+    /**
+     * What of a unit the players who see it are told beyond what they always are (its health, mana, level, buffs and
+     * their stacks), for the plates over it to show (indicators-plan U3): the seconds left of its buffs, its abilities,
+     * a hero's experience. Nothing more than that when left out
+     *
+     * @beta
+     */
+    hud: HudSharing;
+    /**
+     * What the game counts of its players for its score (a classic RTS score screen): kills, losses, damage, healing,
+     * resources, its own (`ScoreRules`, `presetScore()`, `defineStat`). Counted by the rules as the game goes, kept in
+     * saves, told to the players as it says. Nothing is counted when left out
+     *
+     * @beta
+     */
+    score?: ScoreRules;
+    /**
+     * Whether a player may command an entity: its owner, and whoever the owner shares control with
+     * (`world.sides.shareControl`, a force's `sharedControl`), when left out. What every command is checked against, and
+     * what decides whose units a player is told the own state of (orders, the queue, the bag)
+     */
+    mayCommand(world: World, player: PlayerId, entity: Entity): boolean;
+}
+/**
+ * Supply (`GameRules.supply`)
+ *
+ * @beta
+ */
+export interface SupplyRules {
+    /** Supply no player can go past, however much they build to provide it */
+    max: number;
+    /**
+     * Pools of supply besides the one there always is (`supply`, food), by name, each with what it is called and its
+     * most: a cap on commanders, on vehicles. A unit takes of one with `supplies`, a building provides with
+     * `suppliesProvided`. None when left out
+     */
+    pools?: Record<string, {
+        name: string;
+        max: number;
+    }>;
+    /**
+     * Supply a unit takes: summons taking none, an aura that lowers it. Its type's `supply`, when left out. Asked of the
+     * units there are, and of those in a queue, which are not yet (`QueuedUnit`: their type and owner)
+     */
+    of(world: World, unit: Entity | QueuedUnit): number;
+}
+/**
+ * Production and construction (`GameRules.production`)
+ *
+ * @beta
+ */
+export interface ProductionRules {
+    /** Things a building can have waiting to be made */
+    queue: number;
+    /** Part of what a structure cost that comes back when it is called off while being built */
+    cancelRefund: number;
+    /** Part of its health a structure starts being built with */
+    constructionHealth: number;
+    /** How fast a structure goes up with so many builders at it, as a part of its build time a second: the first builder all of it, every other half, when left out */
+    buildRate(world: World, structure: Entity, builders: number): number;
+}
+/**
+ * Selling, repairing, giving and upkeep (`GameRules.economy`)
+ *
+ * @beta
+ */
+export interface EconomyRules {
+    /** Part of an item's price a shop pays for it */
+    sellPrice: number;
+    /** Part of what a building cost that mending all of its health costs */
+    repairCost: number;
+    /** The part of what a player gives an ally that is lost on the way, 0..1 (see `give`). Nothing when left out */
+    tradeTax: number;
+    /** What a player's army costs them in income. The game's upkeep tiers by supply used, when left out */
+    upkeep(world: World, player: PlayerId): Upkeep;
+}
+/**
+ * Fighting (`GameRules.combat`)
+ *
+ * @beta
+ */
+export interface CombatRules {
+    /**
+     * Whether a basic attack of `attacker` strikes critically, and what it multiplies the damage by then: a number for a
+     * critical strike, nothing for none. Asked as the attack goes off, before whether it misses. None when left out (a
+     * game's crits: `withMobaStats`, or its own)
+     */
+    critical(world: World, attacker: Entity, stats: Readonly<Stats>): number | undefined;
+    /**
+     * What is left of damage once the defences of the target had their say, as a part of it. `source` is the stats
+     * of whoever deals it, when someone does. Armor and magic resist, with penetration, when left out
+     */
+    mitigation(type: DamageType, target: Readonly<Stats>, source?: Readonly<Stats>): number;
+    /**
+     * Keeps stats within what the game allows, once everything that changes them was added up. Changes them in place.
+     * The default keeps attack speed within its limits (below)
+     */
+    clampStats(stats: Stats, rules: Readonly<GameRules>): void;
+    /** Seconds an ability takes to be ready again, for a unit with these stats. Its cooldown as it is, when left out */
+    cooldown(seconds: number, stats: Readonly<Stats>): number;
+    /**
+     * How much of a slow a unit with these stats takes: `slow` is what slows it, added up, below 0 (-0.3 for 30% slower).
+     * All of it, when left out
+     */
+    slowTaken(stats: Readonly<Stats>, slow: number): number;
+    /** What the heals and shields `source` gives are multiplied by. 1, when left out */
+    healPower(world: World, source: Entity): number;
+    /** Nobody attacks slower or faster than this, whatever they carry: [lowest, highest] attack speed */
+    attackSpeedLimits: [number, number];
+    /** Seconds a corpse lies where a unit of flesh died, for spells to use (see `raiseDead`). None at all for 0 */
+    corpseTime: number;
+    /** The chance, 0..1, that an attack of `attacker` at `target` goes wide. A quarter up a cliff, when left out */
+    missChance(world: World, attacker: Entity, target: Entity): number;
+    /**
+     * What part of an attack that hits an area an entity standing there gets, 0..1: 0 spares it. `source` is who fired
+     * it, `distance` how far from the middle the entity is. Everyone there but whoever fired it, all of it in the inner
+     * half and half outside, when left out
+     */
+    splash(world: World, source: Entity | undefined, other: Entity, distance: number, radius: number): number;
+    /** How far a unit looks for enemies by itself, and chases them. The farthest `acquisitionRange` of its attacks, when left out */
+    acquisitionRange(world: World, entity: Entity): number;
+    /**
+     * Which of its attacks (`UnitTypeDef.attacks`, by place) an attacker uses against a target, or -1 for none: it cannot
+     * attack it. The first whose `targets` reach the target where it is, when left out (`defaultPickAttack`): a siege
+     * weapon for what is on the ground, a second for the air. Asked for every target looked at: keep it cheap
+     */
+    pickAttack(world: World, attacker: Entity, target: Entity): number;
+    /**
+     * What a hit is multiplied by for the attack's type against the target's armour type, as classic RTS games have it
+     * (pierce against light, siege against fortified), before armour and shields: none when left out. Attacks name
+     * their type (`AttackDef.attackType`), abilities as they deal damage (`DamageOptions.attackType`), unit types their
+     * armour (`UnitTypeDef.armourType`); a type the table has not got is refused as the game is made
+     */
+    damageTable?: DamageTable;
+    /**
+     * The layer an attacker fights from, around a target: room is counted apart for each (see `engageRoom`). The air
+     * for what flies, the water for boats, the ground for the rest, when left out; any name of the game's own besides
+     */
+    engageLayer(world: World, attacker: Entity): string;
+    /**
+     * How many attackers like this one (of its layer, reaching as far) may fight a target at once. A full target is
+     * picked last, and the melee spread around it on as many spots. As many as stand side by side around it, out where
+     * they reach, when left out: few for swords around a footman, all of them for long guns
+     */
+    engageRoom(world: World, target: Entity, attacker: Entity): number;
+    /**
+     * Seconds a unit that picked a target by itself closes in on it without getting closer before it lets it go and
+     * fights something else (blocked by its own in a pass, say). A target it was told to attack it never lets go. One,
+     * when left out; Infinity never
+     */
+    giveUpChase(world: World, attacker: Entity, target: Entity): number;
+}
+/**
+ * How units move among each other (`GameRules.movement`)
+ *
+ * @beta
+ */
+export interface MovementRules {
+    /**
+     * Whether an ally standing in the way of a unit on its way steps aside when asked (see `makeWay`). Those standing
+     * about with nothing to do, or waiting by a fight for a spot in it, when left out: not those fighting, walking or
+     * with orders of their own
+     */
+    makesWay(world: World, mover: Entity, other: Entity): boolean;
+    /**
+     * How far ahead, in ground units, a unit on its way looks for others standing in it, to go round them
+     * (`goesAround`) or, where it cannot, ask them to step aside (`makesWay`) before it reaches them. 0 looks no
+     * further than its nose: it then goes round nothing, and asks only once it is held up. 3 when left out
+     */
+    lookAhead(world: World, mover: Entity): number;
+    /**
+     * Whether a unit goes round the units standing in its way (`around`), where the way round is `longer` ground units
+     * more than the `straight` way to the next corner of its path, rather than through them, which slows it until they
+     * step aside or it has pushed past. Yes for up to a unit and a half more, and a quarter of the straight way, when
+     * left out. Where the way round is found is the `detour` hook's
+     */
+    goesAround(world: World, mover: Entity, around: readonly Entity[], longer: number, straight: number): boolean;
+    /**
+     * Whether a group sent somewhere with a right-click moves at the pace of its slowest (`OrderParams.together`), so
+     * that it arrives together: no when left out, each at its own speed. Attack-moves are each at their own always
+     */
+    together?: boolean;
+    /**
+     * The formation units ordered to a point together take, by id (`FormationDef`), where the order names none
+     * (`OrderInit.formation`): `rows` when left out, which keeps a tight group's shape and lines a scattered one up
+     */
+    formation(world: World, units: readonly Entity[], init: OrderInit): string;
+    /**
+     * How fast a unit goes where it is, from its `moveSpeed`: slower in shallow water, faster on roads. Asked every
+     * tick for every unit that moves: keep it cheap. Its speed as it is, when left out
+     */
+    moveSpeed(world: World, entity: Entity, speed: number): number;
+}
+/**
+ * Pings, chat and pauses (`GameRules.talk`)
+ *
+ * @beta
+ */
+export interface TalkRules {
+    /**
+     * Pings (see `ping`): how many a player may send `within` so many seconds, the kinds there are (a hero arena game's
+     * when left out; a game adds its own), and what each kind asks of a computer ally (indicators-plan P4): a request on
+     * its team's board (`help`, which computers answer by sending fighters; `attack`, `defend` and `rally`, put on the
+     * board for the brains that read them), or nothing. A kind not named is heard and not acted on. `kinds` may be
+     * worked out from the registry as the game plays (`(registry) => …`): from a file of the game's (`registry.file`),
+     * one the editor writes, so a kind added there is let go at once (see `pingKinds`)
+     */
+    pings: {
+        most: number;
+        within: number;
+        kinds: readonly string[] | ((registry: Registry) => readonly string[]);
+        meanings: Readonly<Record<string, 'help' | 'attack' | 'defend' | 'rally' | 'ignore'>>;
+    };
+    /** Lines of chat: how many a player may send `within` so many seconds, and how long one may be */
+    lines: {
+        most: number;
+        within: number;
+        length: number;
+    };
+    /** Pauses in a game on a server (see `askPause`): how many each player may ask for (none at 0), and how many seconds one lasts at most */
+    pauses: {
+        each: number;
+        seconds: number;
+    };
+}
+/**
+ * A damage table: what a hit of each attack type is multiplied by against each armour type (`GameRules.combat.damageTable`).
+ * `table[attack][armour]`, the rows the attacks in their order, the columns the armours in theirs
+ *
+ * @beta
+ */
+export interface DamageTable {
+    attacks: readonly string[];
+    armours: readonly string[];
+    table: readonly (readonly number[])[];
+}
+/**
+ * What a hit is multiplied by, by a damage table: 1 for no table, no attack type, no armour type, or one the table
+ * has not got
+ *
+ * @beta
+ */
+export declare function damageMultiplier(table: DamageTable | undefined, attackType: string | undefined, armourType: string | undefined): number;
+/**
+ * Refuses a damage table that is not one, and a unit type whose attack or armour names a type the table has not got:
+ * as the game is made, so that a misspelling fails then and not in a fight. A game without a table is checked for
+ * nothing
+ *
+ * @beta
+ */
+export declare function checkDamageTable(game: GameModule): void;
+/**
+ * The engine's rules: those of a classic RTS melee game
+ *
+ * @beta
+ */
+export declare const defaultRules: Readonly<GameRules>;
+/**
+ * Creeps' camps' rules (`GameRules.camps`)
+ *
+ * @beta
+ */
+export interface CampRules {
+    /** How far creeps chase away from their camp */
+    leash: number;
+    /** Whether creeps sleep at home at night, until attacked */
+    sleep: boolean;
+    /** Seconds after a camp is cleared that it comes back, for every camp (see `Camp.respawn`). Never when left out */
+    respawn?: number;
+}
+/** What is said of a group of the rules: any of it, a group in it in part as well. A function, a list and a table whole */
+export type RulesPart<T> = T extends (...args: never[]) => unknown ? T : T extends readonly unknown[] ? T : T extends object ? {
+    [K in keyof T]?: RulesPart<T[K]>;
+} : T;
+/**
+ * What a game says of its rules (`GameModule.rules`), or a pack (`GamePack.rules`): any of them, a group in part
+ * (`{ supply: { max: 200 } }`), the engine's for the rest. The damage table, the score and the HUD's sharing are
+ * given whole
+ *
+ * @beta
+ */
+export type RulesInit = {
+    [K in Exclude<keyof GameRules, 'score' | 'hud'>]?: RulesPart<GameRules[K]>;
+} & {
+    score?: ScoreRules;
+    hud?: HudSharing;
+};

package/dist/rulesCheck.d.ts

@@ -0,0 +1,37 @@
+import { type DataKind } from './gameData';
+import type { GameModule } from './game';
+/**
+ * What of a game's rules does not fit together (`checkRules`): an id that names nothing (an ability's buff, a unit's
+ * `trains`, an upgrade's `requires`, a shop's items), an effect of a type nobody handles, requirements that wait on
+ * each other, and, as warnings, what nothing makes, abilities nothing has, and numbers that do not do what they are
+ * there for (an `arc` or a `bounce` not of a missile, or of nothing, `charges` of none). Ids are text to the compiler, so a slip
+ * in one shows only when the game runs into it ("Unknown unit type") or never (a button that is not there)
+ *
+ * @beta
+ */
+export interface RulesProblem {
+    /** `error`: the game will throw or misbehave when it gets there; `warning`: likely a slip, possibly meant */
+    level: 'error' | 'warning';
+    /** Where in the rules: `units.footman.trains`, `abilities.holy-light.effects[0].buff` */
+    where: string;
+    /** The id that is wrong, or the definition the warning is about */
+    id: string;
+    message: string;
+    /**
+     * The definition it is in and the field, as the editor's Data panel names them (`{ kind: 'abilities', id:
+     * 'holy-light', path: 'effects.0.buff' }`), where it is in one
+     */
+    at?: {
+        kind: DataKind;
+        id: string;
+        path: string;
+    };
+}
+/**
+ * Checks a game's rules against themselves (`RulesProblem`): run by `defineGame` with the view's checks, and in a
+ * game's tests (`expect(checkRules(rules).filter((p) => p.level === 'error')).toEqual([])`). Nothing is thrown
+ *
+ * @beta
+ */
+export declare function checkRules(rules: GameModule): RulesProblem[];
+export { editDistance } from './nearest';

package/dist/runes.d.ts

@@ -0,0 +1,41 @@
+import type { ItemDef } from './defs';
+import type { Entity } from './entity';
+import { type GroundItem } from './items';
+import type { GamePack } from './packs/pack';
+import type { World } from './world';
+/**
+ * The runes pack's id
+ *
+ * @beta
+ */
+export declare const RUNES = "core.runes";
+/**
+ * What the runes pack is made with (`withRunes`)
+ *
+ * @beta
+ */
+export interface RunesOptions {
+    /** Whether an item is used as it is picked up, in code: its `powerUp` when left out */
+    powerUp?: (item: ItemDef) => boolean;
+    /** Who picks one up by walking over it: any unit of a player's, not hidden, when left out */
+    takes?: (world: World, entity: Entity, item: GroundItem) => boolean;
+    /** How many ticks apart the ground is looked over for who walked onto a rune: 3 when left out */
+    every?: number;
+}
+/**
+ * Uses an item on the ground as a rune is used: whoever picked it casts its ability (where it stands, no mana), and it
+ * is gone from the ground, told as an item picked (`itemPicked`). What the runes pack does as a unit walks over one;
+ * false for an item not on the ground
+ *
+ * @beta
+ */
+export declare function usePowerUp(world: World, entity: Entity, groundId: number): boolean;
+/**
+ * Runes, as in classic RTS games: an item that is a power-up (`ItemDef.powerUp`, `RunesOptions.powerUp` in code) is used as
+ * it is picked up, by a unit that walks over it (`RunesOptions.takes`) or is told to pick it up, and never carried:
+ * whoever picked it casts its ability where it stands. A rune of healing is an item whose ability heals around; a tome
+ * one whose ability has the tomes pack's `tome` effect. `usePowerUp` does it in code
+ *
+ * @beta
+ */
+export declare function withRunes(options?: RunesOptions): GamePack;