@v12-engine/engine 0.0.0-stage → 0.1.0

package/dist/world.d.ts

@@ -0,0 +1,1118 @@
+import { Life } from './life';
+import { Sight } from './sight';
+import { Sides } from './sides';
+import { Clock } from './clock';
+import { Spawning } from './spawning';
+import { type IssuedCommand } from './commands';
+import type { Camp } from './camps';
+import type { ChatAudience, PingKind } from './talk';
+import { type DebugChecks } from './debug';
+import { type AbilityDef, type AttackDef, type Cost, type DamageType, type EffectDef, type EffectOf, type ResourceKind } from './defs';
+import { Entity, type EntityId, type ItemInstance, type PlayerId } from './entity';
+import { EntityIndex } from './entityIndex';
+import { type ErrorPolicy, type ErrorSite, type RejectedKind, type WorldFailure } from './errors';
+import { Emitter } from './events';
+import { Logger, type LogLevel } from './log';
+import { type HookDef, Hooks } from './hooks';
+import { FogOfWar } from './fog';
+import { BuildGrid } from './grid';
+import type { Vec2 } from './math';
+import type { SidePaths } from './navigation/sidePaths';
+import type { Navigation } from './navigation/navigation';
+import { Player, type PlayerInit, type SpentOn } from './player';
+import type { Registry, System } from './registry';
+import type { GameRules } from './rules';
+import { Scheduler } from './scheduler';
+import { Score } from './score';
+import { Computers } from './computers';
+import { type Component, StateStore } from './components';
+import { type Message, type MessageRef } from './messages';
+import { Rng } from './rng';
+import { type DataKind, type DataValues } from './gameData';
+import { SpatialIndex } from './spatial';
+import { type GroundItem } from './items';
+import type { Terrain } from './terrain';
+import { type GroundBase, type TerrainPatch } from './ground';
+import { type AreaDef, type AreaShape, Areas } from './areas';
+import { Dialog, type SaidLine } from './dialog';
+import { Objectives, type ObjectiveState, type ObjectiveStatus } from './objectives';
+import { type SequenceDef, Sequences } from './sequences';
+import { type TimerDef, Timers } from './timers';
+import type { ListenerDef } from './events';
+import type { Trace } from './inspect';
+import type { CinematicChoice, CinematicCue, CinematicCueSent, CinematicEnded } from './cinematics';
+import { type EffectCue, type EffectOptions } from './effects';
+import { WorldMap } from './names';
+import type { MapEnvironment } from './map';
+import { type PrefabDef, type SpawnedPrefab, type SpawnPrefabOptions } from './prefabs';
+/**
+ * What two players are to each other, when set apart from their teams (`World.setRelation`)
+ *
+ * @beta
+ */
+export type PlayerRelation = 'ally' | 'enemy' | 'neutral';
+/** @beta */
+export interface Projectile {
+    id: number;
+    source: EntityId;
+    owner: PlayerId;
+    target: EntityId;
+    x: number;
+    z: number;
+    prevX: number;
+    prevZ: number;
+    /** Where it is heading. Follows the target while it lives */
+    tx: number;
+    tz: number;
+    speed: number;
+    damage: number;
+    type: DamageType;
+    crit: boolean;
+    /** Fired uphill and going to miss: it flies all the way and does nothing when it comes down */
+    miss: boolean;
+    /** Where it was fired from */
+    sx: number;
+    sz: number;
+    /** Set for shots that hit an area instead of a target */
+    splash?: {
+        radius: number;
+        fells: boolean;
+        targets?: AttackDef['targets'];
+    };
+    /** What it looks like, when the rules say: a look of the shooter's visual, for the screen (a flaming arrow) */
+    look?: string;
+    /** The type of what shot it: the screen draws it so, even once the shooter is gone or out of sight */
+    kind: string;
+    /** Words of the game's own about it, which its damage carries (see `BeforeAttack.tags`) */
+    tags?: string[];
+    /** How what it kills dies, for the screen (see `AttackDef.how`) */
+    how?: string;
+    /** Which of its shooter's attacks it is of, by place (`UnitTypeDef.attacks`): the first when left out */
+    weapon?: number;
+}
+/**
+ * What an ability sent on its way: it travels in a line and does something to everything it passes through
+ *
+ * @beta
+ */
+export interface Missile {
+    id: number;
+    owner: PlayerId;
+    source: EntityId;
+    ability: string;
+    level: number;
+    x: number;
+    z: number;
+    prevX: number;
+    prevZ: number;
+    /** Direction, of length 1 */
+    dx: number;
+    dz: number;
+    speed: number;
+    /** How far it still goes */
+    left: number;
+    /** Seconds until it sets off, and how long that took in all */
+    delay: number;
+    forms: number;
+    radius: number;
+    effect: EffectOf<'missile'>;
+    /** Whom it has passed through already. Missiles sent together share it: what one of them hit the others pass by */
+    hit: Set<EntityId>;
+    /** The unit it flies after, for the ones that do */
+    target: EntityId;
+    /** How far it has come */
+    travelled: number;
+    /** How far it has come since it set off, or sprang on last (`EffectFields.bounce`): how far along its arc it is */
+    leg: number;
+    /** How high above the ground its arc carries it now, for whoever draws it: 0 for what is not thrown in an arc */
+    height: number;
+    /** How many times it has sprung on to another */
+    bounces: number;
+    /** Something got in its way: what happens where it ends does not */
+    stopped: boolean;
+}
+/**
+ * Something an ability does a while after it was cast
+ *
+ * @beta
+ */
+export interface Delayed {
+    left: number;
+    caster: Entity;
+    ability: AbilityDef;
+    level: number;
+    point: Vec2;
+    effects: EffectDef[];
+    /** What its arrival goes by, when not the ability */
+    impact?: string;
+}
+/**
+ * Ground an ability goes on working on for a while
+ *
+ * @beta
+ */
+export interface Zone {
+    id: number;
+    caster: Entity;
+    ability: AbilityDef;
+    level: number;
+    x: number;
+    z: number;
+    left: number;
+    /** Seconds until what is inside is next seen to */
+    next: number;
+    effect: EffectOf<'zone'>;
+}
+/** @beta */
+export type MessageKind = 'error' | 'info' | 'hint';
+/** @beta */
+export interface WorldEvents {
+    entitySpawned: Entity;
+    entityRemoved: Entity;
+    /**
+     * `cause`: the blow, for what died of damage. `how`: what the rules made of the death in the `death` hook, for the
+     * screen to show (`'exploded'`, `'burned'`)
+     */
+    entityDied: {
+        entity: Entity;
+        killer?: Entity;
+        attack: boolean;
+        cause?: DeathCause;
+        how?: string;
+        reason: DeathReason;
+    };
+    /** A buff was put on, or put on again (`renewed`, with the level it had before: `previousLevel`) */
+    buffApplied: {
+        target: Entity;
+        buff: string;
+        level: number;
+        source?: Entity;
+        renewed: boolean;
+        previousLevel?: number;
+    };
+    /** A buff came off: it ran out (`expired`), or was taken off. Not for the buffs of something that dies */
+    buffRemoved: {
+        entity: Entity;
+        buff: string;
+        expired: boolean;
+    };
+    damaged: {
+        target: Entity;
+        source?: Entity;
+        amount: number;
+        type: DamageType;
+        crit: boolean;
+        attack: boolean;
+        ability?: string;
+        tags?: string[];
+    };
+    /** An attack went wide. Where it would have landed, and whom it was for */
+    missed: {
+        x: number;
+        z: number;
+        source?: Entity;
+        target?: Entity;
+    };
+    healed: {
+        target: Entity;
+        source?: Entity;
+        amount: number;
+    };
+    /** `weapon`: which of its attacks swings, by place (`UnitTypeDef.attacks`) */
+    attackStarted: {
+        attacker: Entity;
+        target?: Entity;
+        weapon: number;
+    };
+    projectileSpawned: Projectile;
+    projectileRemoved: Projectile;
+    /** An attack that hits an area came down */
+    impact: {
+        x: number;
+        z: number;
+        radius: number;
+        owner: PlayerId;
+    };
+    constructionStarted: Entity;
+    constructionFinished: Entity;
+    /** A construction was called off by its owner: it dies next, with the reason `cancelled` */
+    constructionCancelled: Entity;
+    /** A building started to turn into another type (`UnitTypeDef.upgradesTo`), over `time` seconds */
+    morphStarted: {
+        entity: Entity;
+        into: string;
+        time: number;
+    };
+    /** That was called off, or the building died before it was done */
+    morphCancelled: {
+        entity: Entity;
+        into: string;
+    };
+    unitTrained: {
+        building: Entity;
+        unit: Entity;
+    };
+    /** An entity became another type: `from`, what it was */
+    entityMorphed: {
+        entity: Entity;
+        from: string;
+    };
+    playerDefeated: Player;
+    /** A player gave up (see `surrender`): `playerDefeated` follows */
+    playerSurrendered: {
+        player: PlayerId;
+    };
+    /** A player asked for a pause, and the rules let them (see `askPause`): whoever runs the world pauses it, for `seconds` at most */
+    pauseAsked: {
+        player: PlayerId;
+        seconds: number;
+        left: number;
+    };
+    gameOver: {
+        winner: number;
+    };
+    /** The game ended on an error in its rules (`world.failure`): it is not stepped again */
+    worldFailed: WorldFailure;
+    /** A unit got into a transport (`UnitTypeDef.transport`), or out of one */
+    boarded: {
+        passenger: Entity;
+        transport: Entity;
+    };
+    /** A unit was hired at a place that hires (`UnitTypeDef.hires`) */
+    unitHired: {
+        shop: Entity;
+        unit: Entity;
+        player: PlayerId;
+    };
+    unloaded: {
+        passenger: Entity;
+        transport: Entity;
+    };
+    heroLevelUp: {
+        hero: Entity;
+        level: number;
+    };
+    /** A hero earned experience (`grantXp`): how much, after `beforeXp`, and the level it is at after it */
+    xpGained: {
+        hero: Entity;
+        amount: number;
+        level: number;
+        from?: Entity;
+    };
+    /**
+     * A unit's mana changed by something it did or was given: spent on a cast (`amount` below 0, `ability` the one cast)
+     * or given by an effect (above 0). Not its regeneration, which would be every tick
+     */
+    manaChanged: {
+        entity: Entity;
+        amount: number;
+        ability?: string;
+        source?: Entity;
+    };
+    /**
+     * A pool of a game's own on a unit (rage, energy, charges) changed: emitted by the game's rules
+     * (`world.events.emit(resourceChanged, …)`), heard by the screens of the unit's owner and allies (`resource`)
+     */
+    resourceChanged: {
+        entity: Entity;
+        kind: string;
+        amount: number;
+        reason?: string;
+    };
+    heroRevived: Entity;
+    /** `duration`: seconds of the wind-up */
+    castStarted: {
+        caster: Entity;
+        ability: AbilityDef;
+        point?: Vec2;
+        duration: number;
+    };
+    /** A channelled ability started to be kept up, or ended: done, or `interrupted` */
+    channelStarted: {
+        caster: Entity;
+        ability: AbilityDef;
+        duration: number;
+    };
+    channelEnded: {
+        caster: Entity;
+        ability: AbilityDef;
+        interrupted: boolean;
+    };
+    missileSpawned: Missile;
+    missileHit: {
+        missile: Missile;
+        target: Entity;
+    };
+    missileRemoved: Missile;
+    abilityCast: {
+        caster: Entity;
+        ability: AbilityDef;
+        level: number;
+        target?: Entity;
+        point: Vec2;
+        charged?: boolean;
+    };
+    /** What an ability set off arrived: a missile hit, a rush ended, the time was up */
+    abilityImpact: {
+        caster: Entity;
+        ability: AbilityDef;
+        level: number;
+        target?: Entity;
+        point: Vec2;
+        radius: number;
+        impact?: string;
+    };
+    researchFinished: {
+        building: Entity;
+        upgrade: string;
+        level: number;
+    };
+    itemDropped: GroundItem;
+    itemPicked: {
+        entity: Entity;
+        item: ItemInstance;
+    };
+    /** Every creep of a camp is gone. It comes back after a while, when it says so (see `Camp.respawn`) */
+    campCleared: {
+        camp: Camp;
+    };
+    /** A camp cleared came back, its creeps where they stood (see `respawnCamp`) */
+    campReturned: {
+        camp: Camp;
+    };
+    /** A player marked a spot for their allies, or for everyone (see `ping`) */
+    pinged: {
+        player: PlayerId;
+        point: Vec2;
+        kind: PingKind;
+        to: ChatAudience;
+        by?: string;
+    };
+    /** A player gave an ally resources (see `give`): how much went, and how much came after the tax */
+    traded: {
+        from: PlayerId;
+        to: PlayerId;
+        resource: string;
+        sent: number;
+        received: number;
+    };
+    /** A player traded one resource for another at a rate (see `exchange`): how much of what went, and how much of what came */
+    exchanged: {
+        player: PlayerId;
+        sold: string;
+        sent: number;
+        bought: string;
+        received: number;
+    };
+    /** A player said a line (see `chat`): to their side, or to everyone */
+    chatted: {
+        player: PlayerId;
+        text: string;
+        to: ChatAudience;
+        by?: string;
+    };
+    /** What a unit carries changed: an item given, taken, bought, sold, used up, or a hero carried in with theirs */
+    inventoryChanged: {
+        entity: Entity;
+    };
+    bounty: {
+        entity: Entity;
+        player: PlayerId;
+        amount: number;
+    };
+    /** A worker struck what it is mending */
+    worked: {
+        worker: Entity;
+        target: Entity;
+    };
+    /** A worker struck the tree it is working on */
+    chopped: {
+        worker: Entity;
+        source: Entity;
+    };
+    /** A worker handed in what it carried: `amount` as it went into the purse, `upkeep` what upkeep took of it at the door */
+    resourcesDeposited: {
+        entity: Entity;
+        player: PlayerId;
+        kind: ResourceKind;
+        amount: number;
+        upkeep?: number;
+    };
+    /**
+     * A player paid for something (`spend`), or was given back what they paid (`refund`, `giveBack`): `on` what (`unit`,
+     * `upgrade`, `structure`, `item`, `hire`, `repair`... or a game's own word), and its id
+     */
+    resourcesSpent: {
+        player: PlayerId;
+        cost: Cost;
+        on: SpentOn;
+        id?: string;
+        refund: boolean;
+    };
+    /**
+     * A command, or a part of one, that a player's own client never sends: not what it says it is (an unknown type, a
+     * field missing or of the wrong kind), or naming another player's unit, or a unit there never was. What a race makes
+     * (an order to a unit that has just died) is not one. A server counts these against whoever sent them (`onCheat`);
+     * a game's own commands may emit it too
+     */
+    /**
+     * A command turned away (`RejectedKind`: why, for what counts them, as a server's cheat counter does), with the
+     * reason in words for the log
+     */
+    commandRejected: {
+        player?: PlayerId;
+        type?: string;
+        kind: RejectedKind;
+        reason: string;
+    };
+    /** A command that came with a number of its sender's (`seq`) was carried out: refused with the first error the player was told, or not */
+    commandHandled: {
+        player: PlayerId;
+        seq: number;
+        refusal?: Message;
+    };
+    /** Feedback for a player, like "Not enough gold": what the client finds the words for */
+    messageSent: {
+        player: PlayerId;
+        message: Message;
+        kind: MessageKind;
+        seconds?: number;
+    };
+    /** A unit walked into an area of the game (`GameModule.areas`) */
+    enteredArea: {
+        area: string;
+        entity: Entity;
+    };
+    /** A unit walked out of one. What dies in an area is not said to leave it */
+    leftArea: {
+        area: string;
+        entity: Entity;
+    };
+    /** An objective of a player was given (`was` undefined), got further along, was done or failed */
+    objectiveChanged: {
+        player: PlayerId;
+        objective: ObjectiveState;
+        was?: ObjectiveStatus;
+    };
+    /** Someone said a line, to some players or everyone (see `world.dialog`) */
+    lineSaid: SaidLine;
+    /** A line was skipped by whom it was said to: it ends early for them */
+    lineEnded: {
+        id: number;
+        to: PlayerId[];
+    };
+    /** A player went over to another team (`setTeam`) */
+    teamChanged: {
+        player: PlayerId;
+        from: number;
+        to: number;
+    };
+    /** The rules marked a moment to start again from, like the start of a wave: a session keeps a save of it */
+    checkpoint: {
+        label: Message;
+    };
+    /** The rules play one of the view's cinematics on the screens of some players, or everyone's (see `playCinematic`) */
+    cinematicCue: CinematicCue;
+    /** The rules cue the cinematic playing on some screens, or everyone's (see `cueCinematic`) */
+    cinematicCued: CinematicCueSent;
+    /** A cinematic the rules played is over on a player's screen, as their screen said (see `cinematic`'s `wait`) */
+    cinematicEnded: CinematicEnded;
+    /** A player picked an answer of a cinematic's choice, as their screen said (see `cinematicChose`) */
+    cinematicChoice: CinematicChoice;
+    /** The rules play one of the view's effects at a place or on an entity, for everyone who sees it (see `world.effect`) */
+    effectStarted: EffectCue;
+    /** The rules stop an effect they played (see `world.stopEffect`) */
+    effectStopped: {
+        id: number;
+        fade?: number;
+    };
+    /**
+     * One hidden in a layer of cells moved in it, or stepped into it (`ConcealmentOptions.rustle`): told to the teams
+     * it names that do not see it (all of them, where none are named), where they see the ground, as a shake of what the
+     * layer draws there
+     */
+    rustled: {
+        layer: string;
+        entity: Entity;
+        x: number;
+        z: number;
+        entered: boolean;
+        teams?: number[];
+    };
+    /**
+     * Cells of a layer (`Terrain.cells`) were set to a value (`setCells`): told to the players who see them, the others
+     * as they come into sight (`cellsSeen`)
+     */
+    cellsChanged: {
+        layer: string;
+        cells: number[];
+        value: number;
+    };
+    /**
+     * Cells of a layer that changed out of a team's sight came into it (`TeamMemory.cells`): told to that team's players,
+     * the cells at `value` now
+     */
+    cellsSeen: {
+        team: number;
+        layer: string;
+        cells: number[];
+        value: number;
+    };
+    /** A part of the ground was reshaped (`reshapeGround`): as it is now, told to every player */
+    groundReshaped: {
+        patch: TerrainPatch;
+    };
+    /** What the map looks like beyond its ground changed (`setEnvironment`): as it is now, told to every player */
+    /** `over`: the seconds the screens ease into it over, where the rules said */
+    environmentChanged: {
+        environment: MapEnvironment;
+        over?: number;
+    };
+}
+/**
+ * What a world checks of itself and of its game as it runs, over the process's: for tests, development, a server that
+ * runs games of its own
+ *
+ * @beta
+ */
+export interface WorldChecks {
+    /** The engine's checks on itself (`DebugChecks`): all on or off, some of them; the process's (`setDebugChecks`) when left out */
+    checks?: boolean | Partial<DebugChecks>;
+}
+/**
+ * What a world is made of (`new World`): its ground and ways, its game, its players, its systems and hooks, and what it
+ * checks of itself
+ *
+ * @beta
+ */
+export interface WorldOptions extends WorldChecks {
+    terrain: Terrain;
+    navigation: Navigation;
+    /** Where boats go (`UnitTypeDef.naval`): the deep water. None for a map without, and boats go on the ground */
+    waterNavigation?: Navigation;
+    /** The navigations the sides plan their routes on, of what each knows (`GameModule.paths: 'seen'`). None when left out */
+    sidePaths?: SidePaths;
+    registry: Registry;
+    players: PlayerInit[];
+    /** The races one is drawn from for a player given `random`: all of the game's when left out */
+    randomRaces?: readonly string[];
+    /** Makes the systems of the world, once it is made: what keeps state of its own keeps it for this world */
+    systems: (world: World) => System[];
+    /** Hook handlers. The engine's own (`coreHooks`) when left out */
+    hooks?: HookDef[];
+    /** How the game reacts to events, subscribed in this order once the world is made */
+    listeners?: ListenerDef[];
+    /** Parts of the map the rules watch */
+    areas?: AreaDef[];
+    /** What the game can set to go off later, by id */
+    timers?: TimerDef[];
+    /** Scripts of steps the game can start, by id */
+    sequences?: SequenceDef[];
+    seed?: number;
+    /** Simulation steps per second */
+    tickRate?: number;
+    /** The logger the world's own is made under (`world.log`): the root one when left out */
+    log?: Logger;
+    /** The least an entry of the world's log must matter to be said (`GameModule.log`) */
+    logLevel?: LogLevel;
+    /** What becomes of a part of the game that throws (`GameModule.onError`): it throws on, when left out */
+    onError?: ErrorPolicy;
+}
+/** @beta */
+export interface DamageOptions {
+    /** Physical when left out */
+    damageType?: DamageType;
+    /** A basic attack: life steal works on it */
+    attack?: boolean;
+    /** It struck critically. The amount is what it is, this is for whoever is watching */
+    crit?: boolean;
+    /** The ability that dealt it, by id: for "immune to Ice Storm", or a kill feed. Left out for a basic attack */
+    ability?: string;
+    /** Words of the game's own about it (`'fire'`, `'explosive'`), for hooks and the screen to decide on */
+    tags?: string[];
+    /** How what this blow kills dies, for the screen (`'burnt'`): the death's `how` (`AttackDef.how`, `AbilityDef.how`) */
+    how?: string;
+    /** The attack's type by the game's damage table (`GameRules.combat.damageTable`): an ability's say, where a basic attack has its `AttackDef.attackType` */
+    attackType?: string;
+}
+/**
+ * What killed something that died of damage: the blow that did it
+ *
+ * @beta
+ */
+export interface DeathCause {
+    type: DamageType;
+    /** What the blow took off */
+    amount: number;
+    /** How much more it was than there was health left */
+    overkill: number;
+    crit: boolean;
+    ability?: string;
+    tags?: string[];
+    /** How the blow says what it kills dies (`DamageOptions.how`) */
+    how?: string;
+}
+/**
+ * Why something died, when it was not of damage: killed by the rules (`killed`, `world.kill`), its building called
+ * off (`cancelled`), its time out (`expired`), a resource used up (`depleted`), brought down by a blast (`felled`), taken
+ * away with what it stood on or by the debug tools (`removed`), or the game's own word (`sold`, `sacrificed`). `damage`
+ * for one that ran out of health
+ *
+ * @beta
+ */
+export type DeathReason = 'damage' | 'killed' | 'cancelled' | 'expired' | 'depleted' | 'felled' | 'removed' | (string & {});
+/**
+ * A spot a team sees for a while, with nothing standing there
+ *
+ * @beta
+ */
+export interface Reveal {
+    id: number;
+    team: number;
+    x: number;
+    z: number;
+    radius: number;
+    /** Seconds it goes on */
+    left: number;
+    /** Shown, and nothing drawn for it: what the rules show a player, as a cinematic looks at it. A spell's, when left out */
+    quiet?: boolean;
+}
+/** @beta */
+export interface SpawnOptions {
+    facing?: number;
+    /** How big it is drawn */
+    scale?: number;
+    /** Which of the models of its type it is drawn with, for things that come in kinds like trees */
+    look?: string;
+    /** A name of its own, for the rules to find it by: `world.named('gate')` */
+    name?: string;
+    /** Seconds it lasts, when that is not what its type says */
+    lifetime?: number;
+    /** Structures only: start as a construction site, with its build time and what was paid when they are not its type's */
+    underConstruction?: boolean | {
+        buildTime?: number;
+        paid?: Cost;
+    };
+}
+/** See `World.internals` */
+export interface WorldInternals {
+    nextEntityId: number;
+    nextId: number;
+    clockShift: number;
+    /** The hour the clock stands at, when it does not move */
+    stillHour?: number;
+    commands: IssuedCommand[];
+    /** Who died and has not been taken out of the world yet: at the end of the tick that comes */
+    dead?: EntityId[];
+}
+/**
+ * What watches a world from outside (`World.watch`): told of each command a player gives it, each save taken of it,
+ * and each tick it ran
+ *
+ * @beta
+ */
+export interface WorldWatcher {
+    /** A command given from outside a tick, before the tick it is applied at runs */
+    command?(command: IssuedCommand): void;
+    /** A save was taken, which put the world's crowd back as a load puts it */
+    saved?(): void;
+    /** A tick ran */
+    stepped?(): void;
+}
+/** @beta */
+export declare class World {
+    /** Obstacles the navigation had no room for (`RecastNavigationOptions.maxObstacles`): what is put down past it does not block the way */
+    obstaclesRefused: number;
+    readonly terrain: Terrain;
+    /** The ground it started on, where it was made from a map (S36): what a save keeps only the changes of */
+    ground?: GroundBase;
+    /** The ground and the air. Agents find their own layer, everything else is about the ground */
+    readonly nav: Navigation;
+    /**
+     * The navigations the sides plan their routes on, of the buildings each knows (`GameModule.paths: 'seen'`): routes
+     * of ground units are planned on their side's, and walked on `nav`. None where routes know everything
+     *
+     * @beta
+     */
+    readonly sidePaths?: SidePaths;
+    /** The ground, the air and the water, to find where a kind of unit can be */
+    private readonly layers;
+    navFor(entity: Entity): Navigation;
+    /** The air alone */
+    readonly air: Navigation;
+    readonly registry: Registry;
+    readonly grid: BuildGrid;
+    readonly fog: FogOfWar;
+    readonly spatial: SpatialIndex;
+    /** What happened, for whoever watches: sessions, tests. Sent out at the end of each tick. Rules use `hooks` */
+    readonly events: Emitter;
+    /**
+     * What this world says about what it does: `world.log.warn('waves', 'nothing to send', { wave })`. Each entry says
+     * the game and the tick it is from, and goes to whoever asked (`world.log.to(sink)`) and to the logger the world
+     * was made under. It changes nothing in the world, and is not in a save
+     */
+    readonly log: Logger;
+    /**
+     * The engine's checks on itself this world runs (`DebugChecks`): what it was made with (`CreateWorldOptions.checks`),
+     * the process's (`setDebugChecks`) when it says nothing. Slow: tests and development
+     */
+    checks: DebugChecks;
+    /** Moved on by `invalidateStats` without an entity: every entity's stats are added up again when next asked for */
+    statsVersion: number;
+    /** What the debug tools follow of the rules as they run: hooks and listeners. Null when nobody asks, see `EventLog` */
+    trace: Trace | null;
+    /** Where game modules and mods take part in damage, deaths, orders and the like, see `HookEvents` */
+    readonly hooks: Hooks;
+    /** The areas of the game, and who is in them */
+    readonly areas: Areas;
+    /** What is set to go off later: `world.timers.after(30, waveComes)` */
+    readonly timers: Timers;
+    /** Scripts of steps that run over time: `world.sequences.start(briefing)` */
+    readonly sequences: Sequences;
+    /** What each player is set to do, in a mission */
+    readonly objectives: Objectives;
+    /**
+     * What the game counts of its players (`GameRules.score`): `world.score.add(player, 'towersLost')`, `get`, `team`.
+     * Counts nothing in a game that does not ask
+     *
+     * @beta
+     */
+    readonly score: Score;
+    /** What is said, by whom, to whom: `world.dialog.say(player, line)`, or `talk` in a sequence */
+    readonly dialog: Dialog;
+    readonly rng: Rng;
+    readonly players: Map<number, Player>;
+    /** Everything in the world, by id. Fallen heroes stay in here while they wait to be brought back */
+    readonly entities: Map<number, Entity>;
+    /**
+     * The entities that are not scenery: the ones that move, act or change by themselves. Systems that run
+     * every tick go through these instead of `entities`, which on a big map is mostly trees.
+     */
+    readonly actors: Map<number, Entity>;
+    /**
+     * The scenery each team sees right now, by team. Kept by the fog system whenever it works out what everyone sees:
+     * scenery never moves, so this only changes then. Lets a session describe what is in sight without testing every tree
+     */
+    readonly sceneryInSight: Map<number, Set<Entity>>;
+    /** Entities by owner, heroes by owner, shops. For questions that would otherwise go through every entity */
+    readonly index: EntityIndex;
+    readonly projectiles: Projectile[];
+    readonly missiles: Missile[];
+    readonly delayed: Delayed[];
+    readonly zones: Zone[];
+    /** Switches for trying things out. A game that is played for real leaves them off */
+    readonly cheats: {
+        /** Abilities and what is carried can be used again at once */
+        noCooldowns: boolean;
+        /** Abilities cost no mana, and are cast with none left */
+        noManaCosts: boolean;
+        /** What the players allowed the debug tools own (`debugPlayers`) takes no harm, and so does not die of it */
+        invulnerable: boolean;
+        /** How fast the game goes, 1 as it should, 0 paused: whoever runs it (a session in the page, a server) goes by it */
+        speed: number;
+    };
+    /**
+     * Players who may use the debug commands (`debug.*`, see `debugCommands.ts`): who a session lets, a seat in the page
+     * that asked, a server started to. Not in a save: whoever loads it says again
+     */
+    readonly debugPlayers: Set<number>;
+    /**
+     * The entity each object of the map became, by the object's id (`MapObject.id`): what the map put down as the world
+     * was made of it (`createWorldFromMap`), and what the editor's Play here put down since (`debug.mapObject`), for the
+     * editor to find again what it moves and takes away (EQ10). Kept in a save
+     */
+    readonly mapEntities: Map<number, number>;
+    /** Spots a team sees for a while without anything there to see them */
+    readonly reveals: Reveal[];
+    /** State of game modules and mods for the whole game, see `state` */
+    readonly states: StateStore;
+    /** Items lying on the ground */
+    readonly items: GroundItem[];
+    /** Runs the systems, in order, each as often as it asks */
+    readonly scheduler: Scheduler;
+    /** The computer players: who is seated, kept in a save and seated again by a load (`world.computers.seat`) */
+    readonly computers: Computers;
+    /** What the world's numbers started from (`rng`): 1 when none was given. A computer player's own numbers start from it and its player */
+    readonly seed: number;
+    readonly tickRate: number;
+    /** Seconds per tick */
+    readonly dt: number;
+    tick: number;
+    /** How things are hurt, healed and die (`Life`) */
+    readonly life: Life;
+    /** What each team sees of the entities (`Sight`): the fog, what is invisible, the game's say */
+    readonly sight: Sight;
+    /** Who is on whose side (`Sides`): teams, relations, shared vision and control */
+    readonly sides: Sides;
+    /** How entities come into the world and are moved about in it (`Spawning`) */
+    readonly spawning: Spawning;
+    /** The time of day (`Clock`): the hour, night, turned forward or stopped */
+    readonly clock: Clock;
+    /** Team that won, once the game is decided */
+    winner: number | null;
+    /**
+     * What becomes of a part of the game that throws: a hook's handler, a listener, a system, a timer, an order, a
+     * command (`ErrorPolicy`). The game's own (`GameModule.onError`), or whoever runs the world's; with neither it
+     * throws, as it always did. A server and a launched game end the game where nothing is said (`??= 'end'`)
+     */
+    errorPolicy?: ErrorPolicy;
+    /** Why the game ended on an error, once it has (`end`): the world is not stepped again */
+    failure: WorldFailure | null;
+    /** The parts switched off for having thrown (`disable`), by name (`siteKey`): kept in a save, and off again when it is loaded */
+    readonly disabled: Map<string, ErrorSite>;
+    /** True through a tick: an error then can end the game; outside one it is whoever called's */
+    private stepping;
+    private toldFailure;
+    /** Errors already answered `throw` further in: not asked about again on their way out */
+    private readonly thrown;
+    private nextEntityId;
+    private nextId;
+    private commands;
+    /** Commands each player gave since the last tick, from outside one: what `commandLimit` counts */
+    private readonly given;
+    /** Commands let go since the last tick, by player: told of at the next (`commandRejected`) */
+    private readonly overLimit;
+    /** Those of them the sender numbered: each answered at the next tick, refused (`commandHandled`), for a screen that waits on it */
+    private readonly overLimitSeqs;
+    /**
+     * Commands a player may give between two ticks, at most (`issue`, from outside a tick): those past it are let go,
+     * and the tick says so once (`commandRejected`, reason `tooManyCommands`), and answers each the sender numbered,
+     * refused (`commandHandled`). A server's rate limit keeps far under it; this bounds what has none (a worker, a
+     * page's own host, a script gone wrong). The computer and scripts, which give theirs in a tick, are not counted.
+     * 100 when left out; `Infinity` for none
+     *
+     * @beta
+     */
+    commandLimit: number;
+    constructor(options: WorldOptions);
+    /** The systems, in the order they run */
+    get systems(): readonly System[];
+    /** Adds a system to the running world, like a computer player. It takes its place by its phase, `before` and `after` */
+    addSystem(system: System): void;
+    /** What systems kept in themselves when the game was saved, for those not added yet */
+    private readonly savedSystems;
+    /** Gives the systems what they kept in a save (see `System.save`): those there now, and those added later */
+    restoreSystems(saved: Record<string, unknown>): void;
+    /** Takes a system out by name. False when there is none of that name */
+    removeSystem(name: string): boolean;
+    get time(): number;
+    /** A number of the rules as it is tuned now (`TunableDef`): what it was set to while playing, or its default */
+    tunable(id: string): number;
+    /** Tunes a number of the rules, within its bounds, and says so (`tunableChanged`) */
+    setTunable(id: string, value: number): void;
+    /**
+     * Changes a definition while the game runs (S61): a unit type's health, an ability's cooldown, as the editor's Data
+     * panel tries them. What is made of it from then on is made of the new one; a unit type's units already in the world
+     * take it at once, with as much of their health lost as before. Kept with the world and in its save, and said
+     * (`definitionChanged`). False for a definition the game does not have
+     */
+    redefine(kind: DataKind, id: string, values: DataValues): boolean;
+    /** State of a game module or a mod for the whole game: made from the component's default when first asked for */
+    state<T>(key: Component<T, unknown>): T;
+    setState<T>(key: Component<T, unknown>, value: T): void;
+    /** The game's numbers that are not about any one unit, like the supply cap (`GameModule.rules`) */
+    get rules(): Readonly<GameRules>;
+    /** Hour of the day, 0..24. Noon in a game without days (`clock.hour`) */
+    get hour(): number;
+    /** Whether the sun is down (`clock.night`): asked for every unit's sight and stats, many times a tick */
+    get night(): boolean;
+    /** Unique id for orders, order groups and projectiles */
+    newId(): number;
+    player(id: PlayerId): Player;
+    /** Whether an entity of this id was ever made here: one that died was, one of a number not yet given out never was */
+    made(id: EntityId): boolean;
+    /** Living entity with this id */
+    get(id: EntityId | undefined): Entity | undefined;
+    /**
+     * The entity of this name, while it lives: one named on the map in the editor, or in code. Nothing once it is
+     * dead, or when there never was one. A game can say which names there are: `world.named<RoadNames>('gate')`
+     */
+    named<Name extends string = string>(name: Name): Entity | undefined;
+    /** The name an entity was given, if any */
+    nameOf(entity: Entity): string | undefined;
+    /**
+     * Names an entity, for the rules to find it by (`named`), or takes its name away with none. It has one name, and a
+     * name is one entity's: taking that of another that still lives throws. The name of the dead is free
+     */
+    setName(entity: Entity, name: string | undefined): void;
+    /**
+     * What the map this world was made from says that is not an entity: its name, and what the game kept with it
+     * (`GameMap.data`). Kept in the world, so a save has it. Empty for a world made without a map
+     */
+    get map(): WorldMap;
+    /** Whether two players fight each other (`sides.enemies`): asked of every target, every tick */
+    areEnemies(a: PlayerId, b: PlayerId): boolean;
+    /** Whether two players are on one side (`sides.allies`) */
+    areAllies(a: PlayerId, b: PlayerId): boolean;
+    /** Whether a player may command an entity (`sides.mayCommand`): what every command is checked against */
+    mayCommand(player: PlayerId, entity: Entity): boolean;
+    /** Whether a team currently sees the entity (`sight.sees`): asked of every entity, team and snapshot */
+    isVisibleTo(entity: Entity, team: number): boolean;
+    /**
+     * Creates an entity. Structures are centered on the grid cells closest to `position`;
+     * the caller is responsible for checking `grid.canPlace` when that matters.
+     */
+    /**
+     * A prefab put down as one: its objects spawned for the owner given, its camps and areas with them, turned and sized
+     * around its middle (`spawnPrefab`)
+     *
+     * @beta
+     */
+    spawnPrefab(prefab: PrefabDef | string, options: SpawnPrefabOptions): SpawnedPrefab;
+    spawn(typeId: string, owner: PlayerId, position: Vec2, options?: SpawnOptions): Entity;
+    /**
+     * Turns scenery into an actor, for good: something gave it a reason to be looked at every tick, like a buff
+     * that has to run out. Whatever does that to an entity calls this; the debug checks catch what forgets to.
+     */
+    wake(entity: Entity): void;
+    /**
+     * Sets cells of one of the game's layers (`Terrain.cells`, `CellLayerDef`) to a value: by their indices, or those in
+     * a shape. A bush burnt, grass grown. The players who see a cell are told at once (a `cells` event), the others as it
+     * comes into their sight (`TeamMemory.cells`), and saves keep it. Returns the cells that changed
+     */
+    /**
+     * Changes what the map looks like beyond its ground, as the game goes: a storm rolling in (`weather`), night mist
+     * (`fog`), the sky going red. Over what it was, field by field; a field given as undefined goes back to none. Every
+     * player sees it (an `environment` event), a save keeps it, and a player who joins later is told it as it is.
+     *
+     * `over` (seconds) has the screens ease into it, from what they show: the rain comes on, the wind gets up, the mist
+     * thickens. The world has the new look at once: a save or a player who joins sees it as it ends
+     */
+    setEnvironment(change: Partial<MapEnvironment>, options?: {
+        over?: number;
+    }): void;
+    /**
+     * Plays one of the view's effects (`GameView.fx.defs`) on the screens of the players who see where it is, or those it is
+     * for (`to`): at a place (`at`), or on an entity (`on`, at a `point` of its model), with knobs (`params`). Its random
+     * parts go by a seed, the same on every screen. Nothing it does decides anything: it is not in the world's state, a
+     * save, or what a player who joins later is told. What it gives back stops it (`stopEffect`)
+     *
+     * @beta
+     */
+    effect(effect: string, options?: EffectOptions): number;
+    /**
+     * Stops an effect the rules played (`effect`) on every screen, as its own `stop` says, over `fade` seconds
+     *
+     * @beta
+     */
+    stopEffect(id: number, options?: {
+        fade?: number;
+    }): void;
+    setCells(layer: string, cells: readonly number[] | AreaShape, value: number): number[];
+    /**
+     * Reshapes a part of the ground as the game goes (`TerrainPatch`): its heights, cliffs, water, paint, what is kept
+     * off it and the game's layers of cells, all at once, as the editor's Play here pushes the map's ground into the game
+     * played (`debug.ground`, EQ10). What the rules go by follows: who sees whom from the levels, where can be built, and
+     * the ways, cut again of the ground as it is now (`Navigation.reshape`: on this thread, every machine the same, and
+     * not for nothing on a big map). What stands on it stays where it is. Every player is told (a `ground` event), and
+     * saves keep it. Throws where the patch does not fit the ground (`terrainPatchProblem`)
+     *
+     * @beta
+     */
+    reshapeGround(patch: TerrainPatch): void;
+    /** Lets a team see a spot for a while, with nothing standing there */
+    reveal(team: number, point: Vec2, radius: number, seconds: number, options?: {
+        quiet?: boolean;
+    }): Reveal;
+    /** Puts a unit somewhere else, where it stands: the way through is not its concern. Structures stay where they were built */
+    place(entity: Entity, point: Vec2): void;
+    /**
+     * Gives an entity to another player, from now on in everything: whose it is, whom it fights, what it counts for.
+     * What it was doing is called off, and what it was making is given back to the one it belonged to
+     */
+    setOwner(entity: Entity, owner: PlayerId): void;
+    /**
+     * Takes a unit out of the world for a while, or puts it back: a worker inside a gold mine, a unit carried in
+     * something. While hidden it is not found, not seen and in nobody's way, and its orders wait. It comes back at
+     * `at`, or where it went in, on the nearest ground it can stand on. Structures cannot hide
+     */
+    setHidden(entity: Entity, hidden: boolean, at?: Vec2): void;
+    /** Gives an entity a time after which it is gone by itself, like a ward, or takes it away with `null` */
+    setLifetime(entity: Entity, seconds: number | null): void;
+    /** Deals damage (`life.damage`): the hooks, armor and shields, health, death */
+    damage(target: Entity, amount: number, source?: Entity, options?: DamageOptions): void;
+    /** Heals (`life.heal`): how much it healed */
+    heal(target: Entity, amount: number, source?: Entity): number;
+    /** Kills (`life.kill`) */
+    kill(entity: Entity, killer?: Entity, attack?: boolean, reason?: DeathReason): void;
+    /**
+     * Tells a player something, like why what they asked for cannot be done. The world says which message,
+     * and the player's screen finds the words for it (see `Message`). A bare string is a key without params
+     */
+    message(player: PlayerId, message: MessageRef, kind?: MessageKind): void;
+    /**
+     * Gives a player a hint (campaign plan CP5): a message of the kind `hint`, shown for `seconds` (the screen's own
+     * time when left out), which a player who turned hints off in the settings does not see
+     */
+    hint(player: PlayerId, message: MessageRef, options?: {
+        seconds?: number;
+    }): void;
+    /** The command being carried out, to find out whether it was refused: see `executeCommand` */
+    handling?: {
+        player: PlayerId;
+        refusal: Message | undefined;
+    };
+    /**
+     * What a save needs that is the world's own business: id counters, the clock and the commands waiting for
+     * the next tick. For `saveWorld` and `loadWorld` only
+     */
+    internals(): WorldInternals;
+    /** Puts back what `internals` gave, for `loadWorld` only */
+    restoreInternals(internals: WorldInternals): void;
+    /** Puts back who died and waits to be taken out (`WorldInternals.dead`), once the entities are back. For `loadWorld` only */
+    restoreDead(ids: readonly EntityId[]): void;
+    /**
+     * Queues a player command. It is applied at the start of the next tick; talk (a command whose def says
+     * `outsideTick`: chat, a ping) given between ticks is carried out at once, a paused game's too (RV14)
+     */
+    issue(command: IssuedCommand): void;
+    /** What watches the world from outside (`watch`) */
+    private readonly watchers;
+    /**
+     * Watches the world from outside, for what records it (a replay of commands, `recordGame`): each command a player
+     * gives it, each save taken of it, each tick. Changes nothing. Gives what stops watching
+     *
+     * @beta
+     */
+    watch(watcher: WorldWatcher): () => void;
+    /** A save of the world was taken, which put its crowd back (`saveWorld`): told to what watches it. The engine's */
+    saved(): void;
+    /** Advances the simulation by one fixed tick */
+    /**
+     * The entities that are all of what is asked, for scripts: whose they are, of which type, in which area. Only the
+     * living, unless asked. A new list: for what runs every tick, go through `index` or `areas` instead
+     */
+    find(filter?: {
+        owner?: PlayerId;
+        type?: string;
+        area?: string;
+        dead?: boolean;
+    }): Entity[];
+    /**
+     * Marks a moment to start again from, like the start of a wave, with what the player is told it is ("Wave 6").
+     * A session keeps a save of the world as it is at the end of this tick, for "Retry from wave 6"
+     */
+    checkpoint(label: MessageRef): void;
+    step(): void;
+    /**
+     * What a part of the game that threw comes to, by what the world says of errors (`errorPolicy`). It returns when
+     * the part is to be switched off or let go (`disable`): the caller does that, and goes on. It throws otherwise: the
+     * error itself (`throw`), or what leaves the tick of a game that ends there (`end`)
+     */
+    caught(error: unknown, where: ErrorSite): void;
+    /** Switches off the parts a save says were (`world.disabled`): the same game goes on as the one that was saved */
+    disable(sites: Iterable<ErrorSite>): void;
+    private advance;
+    /** Throws when scenery has something that only actors get looked after for. See `debugChecks` */
+    private checkScenery;
+    /** Whether it was disposed: its navigation is freed, and it is not to be stepped again */
+    get disposed(): boolean;
+    private wasDisposed;
+    /**
+     * Frees what the world holds outside of JavaScript's memory: its navigation (a navmesh, its tiles and its crowd, in
+     * WebAssembly, which is never collected by itself). Whoever made the world disposes it once done with it: the
+     * session that owns it (`LocalSession`'s `ownsWorld`), the host (`SessionHost`'s), a test. Once is enough: again does
+     * nothing
+     */
+    dispose(): void;
+}