@v12-engine/engine 0.0.0-stage → 0.1.0

package/dist/capture.d.ts

@@ -0,0 +1,131 @@
+import type { GamePack } from './packs/pack';
+import type { PlayerId } from './entity';
+import type { MapFieldDef } from './mapFields';
+import type { Vec2 } from './math';
+import type { World } from './world';
+/**
+ * What a point does while two sides stand in it: nothing moves (`pause`), what was gained is lost (`reset`), or the
+ * larger side takes it as if alone (`majority`; a tie pauses)
+ *
+ * @beta
+ */
+export type Contested = 'pause' | 'reset' | 'majority';
+/**
+ * A capture point given in code (`withCapture`'s `points`); one placed on the map says the same with its fields
+ *
+ * @beta
+ */
+export interface CapturePoint {
+    /** Unique among the game's points: what the events name it by, and `capturePoint` */
+    id: string;
+    name?: string;
+    at: Vec2;
+    /** How far around its middle counts, in cells: 4 when left out */
+    radius?: number;
+    /** Seconds a side alone in it takes to make it its own: 10 when left out */
+    time?: number;
+    /** What it does while two sides stand in it: `pause` when left out */
+    contested?: Contested;
+    /** Whose it is as the game starts: nobody's when left out */
+    owner?: PlayerId;
+}
+/**
+ * A capture point as the world keeps it: where it is, how it is taken, whose it is, and who is taking it now (a team)
+ * and how far they have got (0 to 1)
+ *
+ * @beta
+ */
+export interface CaptureState {
+    id: string;
+    name?: string;
+    x: number;
+    z: number;
+    radius: number;
+    time: number;
+    contested: Contested;
+    owner: PlayerId | null;
+    by: number | null;
+    progress: number;
+}
+/**
+ * The kind of thing on the map a capture point is placed as (the editor's `captureKind`)
+ *
+ * @beta
+ */
+export declare const CAPTURE_KIND = "capture";
+/**
+ * The fields of a capture point on the map, as the editor's kind offers them and the rules read them: its reach, its
+ * time, what it does contested, and whose it is at the start
+ *
+ * @beta
+ */
+export declare const CAPTURE_FIELDS: readonly Omit<MapFieldDef, 'for'>[];
+/**
+ * The capture points of the world, by id: whose each is and who is taking it. Kept in a save; in the game's report
+ * as `captures` (a list), for the HUD and the computer
+ *
+ * @beta
+ */
+export declare const captures: import("./components").Component<Record<string, CaptureState>, Record<string, CaptureState>>;
+/** Whether the points were set up from the code's list and the map: once a world, kept in a save */
+export declare const ready: import("./components").Component<boolean, boolean>;
+/**
+ * A point changed hands: whose it is now (nobody's for one let go by code), and whose it was
+ *
+ * @beta
+ */
+export declare const captured: import("./events").EventKey<{
+    id: string;
+    owner: PlayerId | null;
+    from: PlayerId | null;
+}>;
+/**
+ * A side (a team) began taking a point, or none is any more
+ *
+ * @beta
+ */
+export declare const capturing: import("./events").EventKey<{
+    id: string;
+    by: number | null;
+}>;
+/**
+ * The capture points of a world, as they stand
+ *
+ * @beta
+ */
+export declare const capturesOf: (world: World) => CaptureState[];
+/**
+ * A point by id, or nothing for an id the world has not got
+ *
+ * @beta
+ */
+export declare const captureOf: (world: World, id: string) => CaptureState | undefined;
+/**
+ * Gives a point to a player, or to nobody, from the rules: its progress forgotten, and `captured` said
+ *
+ * @beta
+ */
+export declare function capturePoint(world: World, id: string, owner: PlayerId | null): boolean;
+/**
+ * What a game turns capture points on with (`withCapture`)
+ *
+ * @beta
+ */
+export interface CaptureOptions {
+    /** Points given in code, beside what the map places */
+    points?: readonly CapturePoint[];
+    /** Ticks between two counts of who stands where: 3 when left out */
+    every?: number;
+    /** The kind of thing on the map a point is placed as: `capture` when left out */
+    kind?: string;
+}
+/**
+ * A game with capture points: the points of `options.points` and of the map (things of the `capture` kind, which the
+ * editor places with the client's `captureKind`), each an area, counted every few ticks; whose each is and who is
+ * taking it in the world (`captures`, `capturesOf`) and in the game's report (`captures`); `captured` and
+ * `capturing` as they change; `capturePoint` for the rules' own say. Units count, alive and in sight of nobody in
+ * particular; buildings, scenery and the neutral player's do not
+ *
+ * @beta
+ */
+export declare function withCapture(options?: CaptureOptions): GamePack;

package/dist/cellLayers.d.ts

@@ -0,0 +1,75 @@
+import { type AreaShape } from './areas';
+import type { Terrain } from './terrain';
+import type { World } from './world';
+/**
+ * A layer of cells a game paints its maps with, for its rules to read: where the bushes are, what burns, where a
+ * lane runs. A value per cell (0 to 255, 0 being none), kept with the map (`GameMap.cells`), in the world's ground
+ * (`Terrain.cells`, read with `terrain.cellAt`), its saves and what each player is sent. The rules change it while
+ * the game runs with `world.setCells`: the players who see a cell are told at once, the others as it comes into their
+ * sight (`TeamMemory.cells`), so a change in the dark is not given away. The editor paints the layers a game lists
+ * (`GameModule.cellLayers`), with the values it names
+ *
+ * @beta
+ */
+export interface CellLayerDef {
+    /** Its key in `Terrain.cells` and in the map's file */
+    id: string;
+    /** What the editor calls it */
+    name: string;
+    /** What it is for, for the editor's tooltip */
+    description?: string;
+    /** The colour the editor shows it in, 0 to 1 each */
+    color?: [number, number, number];
+    /**
+     * The values the editor paints with, named: `[{ value: 1, name: 'Bush' }]`. One value, 1, named after the layer when
+     * left out: a layer of cells that are or are not
+     */
+    values?: {
+        value: number;
+        name: string;
+        color?: [number, number, number];
+    }[];
+    /**
+     * How fast one on foot goes over a cell of the layer that is not 0, as a multiplier of its speed: a swamp at 0.5. 1
+     * when left out; a cell of several such layers is slowed by each (`groundSpeedOfCell`)
+     */
+    speed?: number;
+}
+/**
+ * Typed help for writing a layer of cells
+ *
+ * @beta
+ */
+export declare const defineCellLayer: (def: CellLayerDef) => CellLayerDef;
+/**
+ * The values a layer is painted with, as the editor offers them: its own, or 1, named after the layer
+ *
+ * @beta
+ */
+export declare const cellLayerValues: (def: CellLayerDef) => NonNullable<CellLayerDef['values']>;
+/**
+ * The cells of a terrain in a shape, as indices into its layers: the cells whose middle is in it
+ *
+ * @beta
+ */
+export declare function cellsIn(terrain: Pick<Terrain, 'width' | 'depth'>, shape: AreaShape): number[];
+/**
+ * Cells of a layer the rules set (`world.setCells`), each with what it was: what each team that does not see a cell
+ * keeps of it as it last knew it (`TeamMemory.cells`), to be told when it comes into sight. A cell set back to what the
+ * team knows is nothing to tell; one the team sees is told now
+ */
+export declare function rememberUnseenCells(world: World, layer: string, cells: readonly number[], was: readonly number[], value: number): void;
+/**
+ * The cells changed out of a team's sight that are in it now (`TeamMemory.cells`), told to the team as they are now
+ * (`cellsSeen`) and forgotten: after the fog is worked out again (`fogSystem`)
+ */
+export declare function tellCellsInSight(world: World): void;
+/**
+ * The world's ground as a team knows it: its layers' cells as the team last saw those changed out of its sight
+ * (`TeamMemory.cells`). The ground itself where the team knows all of it, or for an observer (no team)
+ */
+export declare function groundKnownTo(world: World, team: number | undefined): Terrain;
+/** A layer's cells changed (`world.setCells`): to those who see them. The others are told as they come into sight (`toldCellsSeen`) */
+export declare const toldCells: import("./replication").ReplicatedEvent;
+/** Cells changed out of a team's sight came into it (`tellCellsInSight`): to the team, as they are now. An observer was told already */
+export declare const toldCellsSeen: import("./replication").ReplicatedEvent;

package/dist/cinematics.d.ts

@@ -0,0 +1,194 @@
+import type { Audience } from './dialog';
+import type { PlayerId } from './entity';
+import { type Step } from './sequences';
+import type { World } from './world';
+/**
+ * Cinematics are the screen's: the camera, the HUD making way, the player's hands off. What they are is in a game's
+ * view, by id (`GameView.cinematics.defs`). The rules say when one plays, so that it comes at the moment of the game it is
+ * about (the start of the mission, a boss coming, the last wave beaten), the same moment for everyone, and a save
+ * knows it was played: `playCinematic` now, or `cinematic` as a step of a sequence.
+ *
+ * The rules and the screen talk both ways. The rules cue a cinematic playing (`cueCinematic`: the gate is open, go on)
+ * and a script or the data waits for the cue (`cut.untilCue`, a hook `cue:<name>`). The screen tells the rules when one
+ * they played is over, and how (the `cinematic` command, as the player who saw it): the engine says so as
+ * `cinematicEnded`, which a sequence waits for (`waitFor(cinematicEndedEvent)`, or `cinematic(id, { wait: 'ended' })`).
+ * Being a command, it is in a replay, so what a story does after a cinematic is the same on every screen and every
+ * time; the screen's cinematic is not in a replay, as screens are not
+ */
+/**
+ * A cinematic the rules play, as the engine's `cinematic` event carries it to the screens
+ *
+ * @beta
+ */
+export interface CinematicCue {
+    /** Which of the view's cinematics */
+    id: string;
+    /** Who sees it. Everyone when left out */
+    to?: PlayerId[];
+    /**
+     * The game waits while it plays. Only where the simulation runs on the player's machine (single player): a screen
+     * whose game runs elsewhere plays it with the game going on, as a server does not stop for one player
+     */
+    hold: boolean;
+    /** The player may skip it */
+    skippable: boolean;
+    /** What the rules hand the cinematic: the road of this map to fly down. Plain data, as it goes to every screen */
+    params?: Record<string, unknown>;
+}
+/**
+ * How a cinematic the rules played ended on a player's screen: played to its end, skipped, stopped (the game left, code
+ * stopped it), made way for another, or never played (one already playing would not make way)
+ *
+ * @beta
+ */
+export type CinematicOutcome = 'ended' | 'skipped' | 'stopped' | 'replaced' | 'ignored';
+/** The outcomes a screen may report, for the command's check */
+export declare const CINEMATIC_OUTCOMES: readonly ['ended', 'skipped', 'stopped', 'replaced', 'ignored'];
+/**
+ * A cue the rules send to the cinematic playing on some screens (`cueCinematic`), as the engine's `cinematicCued` event
+ * carries it
+ *
+ * @beta
+ */
+export interface CinematicCueSent {
+    /** Its name, as the cinematic waits for it (`cut.untilCue('gate')`, a hook `cue:gate`) */
+    cue: string;
+    /** Who it goes to. Everyone when left out */
+    to?: PlayerId[];
+    /** What it carries to the cinematic. Plain data */
+    params?: Record<string, unknown>;
+}
+/**
+ * A cinematic the rules played is over on a player's screen (the engine's `cinematicEnded` event), as that player's
+ * screen said with the `cinematic` command
+ *
+ * @beta
+ */
+export interface CinematicEnded {
+    /** Whose screen it ended on */
+    player: PlayerId;
+    /** Which of the view's cinematics */
+    cinematic: string;
+    /** How it ended there */
+    outcome: CinematicOutcome;
+}
+/** @beta */
+export interface CinematicOptions {
+    /** Who sees it: a player, some, or everyone. Everyone when left out */
+    to?: Audience;
+    /** The game waits while it plays, in single player. False when left out */
+    hold?: boolean;
+    /** The player may skip it. True when left out */
+    skippable?: boolean;
+    /**
+     * What the cinematic is handed (`Cinematic` is given it): what the rules know and the screen does not, like the
+     * road of the map being played. Plain data
+     */
+    params?: Record<string, unknown>;
+}
+/**
+ * Plays one of the view's cinematics on the screens of the players it is for, now
+ *
+ * @beta
+ */
+export declare function playCinematic(world: World, id: string, options?: CinematicOptions): void;
+/**
+ * Cues the cinematic playing on the screens of the players it is for (everyone when left out): one waiting for it
+ * (`cut.untilCue(name)`) goes on, and the view's hooks of it (`cue:<name>`) run. Nothing happens where none plays, or
+ * the one playing does not listen for it. `params` is plain data the cue carries
+ *
+ * @beta
+ */
+export declare function cueCinematic(world: World, cue: string, options?: {
+    to?: Audience;
+    params?: Record<string, unknown>;
+}): void;
+/**
+ * A step of a sequence that cues the cinematic playing (see `cueCinematic`): `[wait(4), cinematicCue('gateOpen')]`
+ *
+ * @beta
+ */
+export declare const cinematicCue: <D = undefined>(cue: string, options?: {
+    to?: Audience;
+    params?: Record<string, unknown>;
+}) => Step<D>;
+/**
+ * What a sequence waits for after a cinematic it played: its end for the player it was for (`ended`), the first of the
+ * players' ends (`any`), or every player's (`all`). `ended` for a cinematic of several players is `all`
+ *
+ * @beta
+ */
+export type CinematicWait = 'ended' | 'any' | 'all';
+/** The sequences waiting for a cinematic to end on players' screens: in the world, so that a save keeps the count */
+export declare const waits: import("./components").Component<{
+    list: {
+        run: number;
+        cinematic: string;
+        waiting: PlayerId[];
+        any: boolean;
+    }[];
+}, {
+    list: {
+        run: number;
+        cinematic: string;
+        waiting: PlayerId[];
+        any: boolean;
+    }[];
+}>;
+/**
+ * A player's screen says a cinematic the rules played is over (the `cinematic` command): the engine says so to the rules
+ * (`cinematicEnded`), and a sequence that waits for it counts it
+ */
+export declare function cinematicEnded(world: World, player: PlayerId, cinematic: string, outcome: CinematicOutcome): void;
+/**
+ * A player picked an answer of a choice of a cinematic on their screen (the engine's `cinematicChoice` event), as their
+ * screen said with the `cinematicChoice` command: the rules branch on it (`waitFor(cinematicChoiceEvent, ...)`), so that
+ * the story's branch is the same on every screen and in a replay
+ *
+ * @beta
+ */
+export interface CinematicChoice {
+    /** Whose screen it was picked on */
+    player: PlayerId;
+    /** Which of the view's cinematics */
+    cinematic: string;
+    /** The choice's name in the cinematic (`choice` when it gave none), and the answer's id */
+    question: string;
+    choice: string;
+    /** Whether nobody picked and the time ran out on its default */
+    timedOut: boolean;
+}
+/** A player's pick of a choice of a cinematic, as their screen said: heard by the rules as `cinematicChoice` */
+export declare function cinematicChose(world: World, choice: CinematicChoice): void;
+/**
+ * A step of a sequence that plays one of the view's cinematics: `defineSequence('td.start', [cinematic('td.intro', {
+ * hold: true }), ...talk(...)])`. It does not wait for it (with `hold`, the game, and the sequence with it, waits),
+ * unless told to: `wait: 'ended'` goes on once the player it was for has seen it end (or skipped it), `any` once one
+ * of the players it went to has, `all` once every one of them has. Only players with a screen are waited for (not the
+ * computer's); one who left a game of several never says, so a sequence for many waits for `any` where that matters.
+ * With a wait it is two steps, which `defineSequence` takes as they are
+ *
+ * @beta
+ */
+export declare function cinematic<D = undefined>(id: string, options?: CinematicOptions & {
+    wait?: undefined;
+}): Step<D>;
+/**
+ * With `wait`: the cinematic played, then a wait for its end (see the other form), as two steps
+ *
+ * @beta
+ */
+export declare function cinematic<D = undefined>(id: string, options: CinematicOptions & {
+    wait: CinematicWait;
+}): Step<D>[];
+/** A cinematic played, to whom it is for: everyone when it names nobody */
+export declare const toldCinematic: import("./replication").ReplicatedEvent;
+/** A cue of the rules to a cinematic playing, to whom it is for */
+export declare const toldCinematicCue: import("./replication").ReplicatedEvent;
+/**
+ * A region of the map with a cinematic (`MapRegion.cinematic`, ED4) plays it for everyone, once, the first time a unit
+ * of a player (not the neutral, nor a building) walks in, unless the game plays it its own way (`play: 'code'`)
+ *
+ * @beta
+ */
+export declare const regionCinematic: import("./events").ListenerDef;

package/dist/clock.d.ts

@@ -0,0 +1,32 @@
+import type { World } from './world';
+/**
+ * The time of day of a world: what its day (`GameModule.day`) and the time played make of it, turned forward or stopped
+ * by a map or a script. Kept in a save (`WorldInternals.clockShift`, `stillHour`)
+ *
+ * @beta
+ */
+export declare class Clock {
+    private readonly world;
+    /** Seconds the time of day is ahead of the time played */
+    shift: number;
+    /** The hour, when the clock does not move (`stop`) */
+    still: number | undefined;
+    /** Whether it was night, and when that was worked out: asked many times a tick, worked out once */
+    private readonly seen;
+    constructor(world: World);
+    /** Hour of the day, 0..24. Noon in a game without days */
+    get hour(): number;
+    /** Turns the clock forward to an hour, for a map that wants to start at night or a debug tool */
+    setHour(hour: number): void;
+    /** Stops the clock at the hour it is, for a map that is always night; `false` lets it go on from there */
+    stop(still?: boolean): void;
+    /** Whether the clock stands still (`stop`) */
+    get stopped(): boolean;
+    /**
+     * Whether the sun is down. Asked for every unit's sight and stats, many times a tick: kept for the moment it was
+     * worked out at (the day, the time, the clock's shift, an hour that stands still), so it is worked out once a tick
+     */
+    get night(): boolean;
+}
+/** The hour of the day, in a game with one (`Snapshot.hour`) */
+export declare const hourPart: import("./replication").SnapshotPart<keyof import(".").Snapshot>;

package/dist/commands.d.ts

@@ -0,0 +1,235 @@
+import type { PlayerId } from './entity';
+import { type Checked, type Fields } from './fields';
+import { type Vec2 } from './math';
+import type { World } from './world';
+/**
+ * Commands are everything a player can ask for: plain data, and the only way input reaches the simulation,
+ * which keeps the door open for replays, the AI and multiplayer.
+ *
+ * A command type is a `CommandDef`: the fields it carries, and what it does. What arrives is checked against the
+ * fields before anything happens, because on a server it is whatever anyone sends. The engine's own commands are
+ * defined the same way as a game module's (`GameModule.commands`).
+ *
+ * @beta
+ */
+export interface CommandDef<F extends Fields = Fields> {
+    type: string;
+    /** What it carries, besides its type and the player who sent it. See `fields.ts` for the checkers */
+    fields: F;
+    /** Carries it out, for `player`. Whether the player owns or can see what it names is for this to check */
+    execute(world: World, player: PlayerId, command: Checked<F>): void;
+    /**
+     * Carried out at once when given between two ticks, a paused game's too, not at the start of the next (`World.issue`):
+     * talk, a line of chat or a ping, which a game that waits is still to hear. Counted by the talk's own rate, not the
+     * commands a tick may have; a replay keeps it where it was given (RV14)
+     */
+    outsideTick?: boolean;
+}
+declare const modCommandBrand: unique symbol;
+/**
+ * A command of a game module, as its definition's `make` puts it together. Sessions send it like the engine's own
+ *
+ * @beta
+ */
+export type ModCommand = {
+    readonly type: string;
+    readonly [modCommandBrand]: true;
+};
+/**
+ * A command type, with `make` to put one together for a session to send
+ *
+ * @beta
+ */
+export type DefinedCommand<T extends string, F extends Fields> = CommandDef<F> & {
+    type: T;
+    make(fields: Checked<F>): ModCommand;
+};
+/**
+ * Defines a command type, for a game module's `commands`: its type, its fields (see `fields.ts`), and what it does.
+ * `command` is typed by the fields.
+ *
+ * ```ts
+ * const sellTower = defineCommand('sellTower', { tower: id }, (world, player, command) => { ... })
+ * session.send(sellTower.make({ tower: 12 }))
+ * ```
+ *
+ * @beta
+ */
+export declare function defineCommand<const T extends string, F extends Fields>(type: T, fields: F, execute: (world: World, player: PlayerId, command: Checked<F>) => void, options?: {
+    outsideTick?: boolean;
+}): DefinedCommand<T, F>;
+/** What a command looks like on its way in: its type, who sent it, and its fields */
+type CommandOf<D> = D extends DefinedCommand<infer T, infer F> ? {
+    type: T;
+    player: PlayerId;
+} & Checked<F> : never;
+/**
+ * Stops what units are doing, as the classic Stop does: a plain interrupt. They fight what comes near again at once; a
+ * unit that is to stand down and take no fights is put in a stance (`stanceCommand`, `withStances`)
+ *
+ * @beta
+ */
+export declare const stopCommand: DefinedCommand<"stop", {
+    entities: import("./fields").Check<number[]>;
+}>;
+/** The player skips the line of dialog they hear: a conversation goes on to its next line. See `world.dialog` */
+export declare const skipLineCommand: DefinedCommand<"skipLine", {}>;
+/** A player marks a spot of the map for their allies: `look`, `danger`, `assist` or `onMyWay` (see `ping`) */
+export declare const pingCommand: DefinedCommand<"ping", {
+    point: import("./fields").Check<Vec2>;
+    kind: import("./fields").Check<string | undefined>;
+    to: import("./fields").Check<string | undefined>;
+    by: import("./fields").Check<string | undefined>;
+}>;
+/** A player says a line of chat: to `allies` (when left out), or to `all` (see `chat`) */
+export declare const chatCommand: DefinedCommand<"chat", {
+    text: import("./fields").Check<string>;
+    to: import("./fields").Check<string | undefined>;
+    by: import("./fields").Check<string | undefined>;
+}>;
+/** A player gives an ally some of a resource they have (see `give`) */
+export declare const giveCommand: DefinedCommand<"give", {
+    to: import("./fields").Check<number>;
+    resource: import("./fields").Check<string>;
+    amount: import("./fields").Check<number>;
+}>;
+/** A player shares control of their units, or their team's sight, with an ally, or no longer (see `shareWith`) */
+export declare const shareCommand: DefinedCommand<"share", {
+    with: import("./fields").Check<number>;
+    vision: import("./fields").Check<boolean | undefined>;
+    control: import("./fields").Check<boolean | undefined>;
+}>;
+/**
+ * The commands the engine knows, which every game has
+ *
+ * @beta
+ */
+export declare const coreCommands: readonly [DefinedCommand<"order", {
+    entities: import("./fields").Check<number[]>;
+    order: import("./fields").Check<Checked<{
+        type: import("./fields").Check<string>;
+        target: import("./fields").Check<number | undefined>;
+        point: import("./fields").Check<Vec2 | undefined>;
+        unitType: import("./fields").Check<string | undefined>;
+        ability: import("./fields").Check<string | undefined>;
+        item: import("./fields").Check<number | undefined>;
+        facing: import("./fields").Check<number | undefined>;
+        path: import("./fields").Check<string | undefined>;
+        towards: import("./fields").Check<"first" | "last" | undefined>;
+        formation: import("./fields").Check<string | undefined>;
+        together: import("./fields").Check<boolean | undefined>;
+    }>>;
+    queue: import("./fields").Check<boolean | undefined>;
+}>, DefinedCommand<"smart", {
+    entities: import("./fields").Check<number[]>;
+    point: import("./fields").Check<Vec2>;
+    target: import("./fields").Check<number | undefined>;
+    queue: import("./fields").Check<boolean | undefined>;
+    formation: import("./fields").Check<string | undefined>;
+}>, DefinedCommand<"attack", {
+    entities: import("./fields").Check<number[]>;
+    point: import("./fields").Check<Vec2>;
+    target: import("./fields").Check<number | undefined>;
+    queue: import("./fields").Check<boolean | undefined>;
+    formation: import("./fields").Check<string | undefined>;
+}>, DefinedCommand<"cast", {
+    entities: import("./fields").Check<number[]>;
+    ability: import("./fields").Check<string>;
+    point: import("./fields").Check<Vec2 | undefined>;
+    target: import("./fields").Check<number | undefined>;
+    queue: import("./fields").Check<boolean | undefined>;
+}>, DefinedCommand<"autocast", {
+    entities: import("./fields").Check<number[]>;
+    ability: import("./fields").Check<string>;
+    enabled: import("./fields").Check<boolean>;
+}>, DefinedCommand<"stop", {
+    entities: import("./fields").Check<number[]>;
+}>, DefinedCommand<"train", {
+    building: import("./fields").Check<number | undefined>;
+    buildings: import("./fields").Check<number[] | undefined>;
+    unitType: import("./fields").Check<string>;
+}>, DefinedCommand<"research", {
+    building: import("./fields").Check<number | undefined>;
+    buildings: import("./fields").Check<number[] | undefined>;
+    upgrade: import("./fields").Check<string>;
+}>, DefinedCommand<"upgradeBuilding", {
+    building: import("./fields").Check<number>;
+    into: import("./fields").Check<string | undefined>;
+}>, DefinedCommand<"cancelTrain", {
+    building: import("./fields").Check<number>;
+    index: import("./fields").Check<number>;
+}>, DefinedCommand<"rally", {
+    buildings: import("./fields").Check<number[]>;
+    point: import("./fields").Check<Vec2>;
+    target: import("./fields").Check<number | undefined>;
+}>, DefinedCommand<"cancelConstruction", {
+    building: import("./fields").Check<number>;
+}>, DefinedCommand<"skipLine", {}>, DefinedCommand<"ping", {
+    point: import("./fields").Check<Vec2>;
+    kind: import("./fields").Check<string | undefined>;
+    to: import("./fields").Check<string | undefined>;
+    by: import("./fields").Check<string | undefined>;
+}>, DefinedCommand<"chat", {
+    text: import("./fields").Check<string>;
+    to: import("./fields").Check<string | undefined>;
+    by: import("./fields").Check<string | undefined>;
+}>, DefinedCommand<"give", {
+    to: import("./fields").Check<number>;
+    resource: import("./fields").Check<string>;
+    amount: import("./fields").Check<number>;
+}>, DefinedCommand<"share", {
+    with: import("./fields").Check<number>;
+    vision: import("./fields").Check<boolean | undefined>;
+    control: import("./fields").Check<boolean | undefined>;
+}>, DefinedCommand<"surrender", {}>, DefinedCommand<"pause", {}>, DefinedCommand<"cinematic", {
+    cinematic: import("./fields").Check<string>;
+    outcome: import("./fields").Check<"ended" | "ignored" | "replaced" | "skipped" | "stopped">;
+}>, DefinedCommand<"cinematicChoice", {
+    cinematic: import("./fields").Check<string>;
+    question: import("./fields").Check<string>;
+    choice: import("./fields").Check<string>;
+    timedOut: import("./fields").Check<boolean | undefined>;
+}>];
+/**
+ * The commands a world takes, by who defines them: the engine's (`core`), and each pack's, which adds its own by
+ * declaration merging, as the heroes pack does:
+ *
+ * ```ts
+ * declare module '@v12-engine/engine' {
+ * 	interface Commands {
+ * 		mypack: (typeof myPackCommands)[number]
+ * 	}
+ * }
+ * ```
+ *
+ * @beta
+ */
+export interface Commands {
+    core: (typeof coreCommands)[number];
+}
+/**
+ * A command a world takes, as it comes in: its type, who sent it, and its fields. The engine's, and its packs'
+ * (`Commands`)
+ *
+ * @beta
+ */
+export type Command = CommandOf<Commands[keyof Commands]>;
+/**
+ * Any command on its way in: the engine's own, or a game module's
+ *
+ * @beta
+ */
+export type IssuedCommand = (Command | (ModCommand & {
+    player: PlayerId;
+})) & {
+    /** The sender's own number for it, told back with how it went (`commandHandled`): what a screen waits on */
+    seq?: number;
+};
+/**
+ * Checks a command and carries it out. A command that is not what it says it is (an unknown type, a field missing
+ * or of the wrong kind, a player that is not in the game) is turned away with `commandRejected`, and changes nothing
+ */
+export declare function executeCommand(world: World, raw: unknown): void;
+/** What became of a command: to whoever sent it */
+export declare const toldCommand: import("./replication").ReplicatedEvent;
+export {};