@v12-engine/engine 0.0.0-stage → 0.1.0

package/dist/engineEvents.d.ts

@@ -0,0 +1,710 @@
+/**
+ * Something was made in the world: a unit trained or spawned, a building put down, a tree of the map
+ *
+ * @beta
+ */
+export declare const entitySpawned: import("./events").EventKey<import("./entity").Entity>;
+/**
+ * Something left the world for good: a corpse gone, a building taken down, a unit removed by the rules
+ *
+ * @beta
+ */
+export declare const entityRemoved: import("./events").EventKey<import("./entity").Entity>;
+/**
+ * Something died: what killed it, and how. `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'`)
+ *
+ * @beta
+ */
+export declare const entityDied: import("./events").EventKey<{
+    entity: import("./entity").Entity;
+    killer?: import("./entity").Entity;
+    attack: boolean;
+    cause?: import("./world").DeathCause;
+    how?: string;
+    reason: import("./world").DeathReason;
+}>;
+/**
+ * A buff was put on, or put on again (`renewed`, with the level it had before: `previousLevel`)
+ *
+ * @beta
+ */
+export declare const buffApplied: import("./events").EventKey<{
+    target: import("./entity").Entity;
+    buff: string;
+    level: number;
+    source?: import("./entity").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
+ *
+ * @beta
+ */
+export declare const buffRemoved: import("./events").EventKey<{
+    entity: import("./entity").Entity;
+    buff: string;
+    expired: boolean;
+}>;
+/**
+ * Something took damage: who dealt it, how much, of which type, whether a critical strike, and by an attack or an ability
+ *
+ * @beta
+ */
+export declare const damaged: import("./events").EventKey<{
+    target: import("./entity").Entity;
+    source?: import("./entity").Entity;
+    amount: number;
+    type: import("./defs").DamageType;
+    crit: boolean;
+    attack: boolean;
+    ability?: string;
+    tags?: string[];
+}>;
+/**
+ * An attack went wide. Where it would have landed, and whom it was for
+ *
+ * @beta
+ */
+export declare const missed: import("./events").EventKey<{
+    x: number;
+    z: number;
+    source?: import("./entity").Entity;
+    target?: import("./entity").Entity;
+}>;
+/**
+ * Something was given health back, and by whom
+ *
+ * @beta
+ */
+export declare const healed: import("./events").EventKey<{
+    target: import("./entity").Entity;
+    source?: import("./entity").Entity;
+    amount: number;
+}>;
+/**
+ * A unit began an attack: its swing, at its target where it has one
+ *
+ * @beta
+ */
+export declare const attackStarted: import("./events").EventKey<{
+    attacker: import("./entity").Entity;
+    target?: import("./entity").Entity;
+    weapon: number;
+}>;
+/**
+ * An attack's projectile set off
+ *
+ * @beta
+ */
+export declare const projectileSpawned: import("./events").EventKey<import("./world").Projectile>;
+/**
+ * An attack's projectile landed or was taken away
+ *
+ * @beta
+ */
+export declare const projectileRemoved: import("./events").EventKey<import("./world").Projectile>;
+/**
+ * An attack that hits an area came down
+ *
+ * @beta
+ */
+export declare const impact: import("./events").EventKey<{
+    x: number;
+    z: number;
+    radius: number;
+    owner: import("./entity").PlayerId;
+}>;
+/**
+ * A building's site was put down: what it will be, while it goes up
+ *
+ * @beta
+ */
+export declare const constructionStarted: import("./events").EventKey<import("./entity").Entity>;
+/**
+ * A building went up whole and works
+ *
+ * @beta
+ */
+export declare const constructionFinished: import("./events").EventKey<import("./entity").Entity>;
+/**
+ * A construction was called off by its owner: it dies next, with the reason `cancelled`
+ *
+ * @beta
+ */
+export declare const constructionCancelled: import("./events").EventKey<import("./entity").Entity>;
+/**
+ * A building started to turn into another type (`UnitTypeDef.upgradesTo`), over `time` seconds
+ *
+ * @beta
+ */
+export declare const morphStarted: import("./events").EventKey<{
+    entity: import("./entity").Entity;
+    into: string;
+    time: number;
+}>;
+/**
+ * That was called off, or the building died before it was done
+ *
+ * @beta
+ */
+export declare const morphCancelled: import("./events").EventKey<{
+    entity: import("./entity").Entity;
+    into: string;
+}>;
+/**
+ * A building trained a unit: the building, and the unit made
+ *
+ * @beta
+ */
+export declare const unitTrained: import("./events").EventKey<{
+    building: import("./entity").Entity;
+    unit: import("./entity").Entity;
+}>;
+/**
+ * An entity became another type: `from`, what it was
+ *
+ * @beta
+ */
+export declare const entityMorphed: import("./events").EventKey<{
+    entity: import("./entity").Entity;
+    from: string;
+}>;
+/**
+ * A player lost: their units and buildings are gone, or the rules said so
+ *
+ * @beta
+ */
+export declare const playerDefeated: import("./events").EventKey<import("./player").Player>;
+/**
+ * A player gave up (see `surrender`): `playerDefeated` follows
+ *
+ * @beta
+ */
+export declare const playerSurrendered: import("./events").EventKey<{
+    player: import("./entity").PlayerId;
+}>;
+/**
+ * A player asked for a pause, and the rules let them (see `askPause`): whoever runs the world pauses it, for `seconds` at most
+ *
+ * @beta
+ */
+export declare const pauseAsked: import("./events").EventKey<{
+    player: import("./entity").PlayerId;
+    seconds: number;
+    left: number;
+}>;
+/**
+ * The game ended, with the winning team (`0` for none)
+ *
+ * @beta
+ */
+export declare const gameOver: import("./events").EventKey<{
+    winner: number;
+}>;
+/**
+ * The game ended on an error in its rules (`world.failure`): it is not stepped again
+ *
+ * @beta
+ */
+export declare const worldFailed: import("./events").EventKey<import("./errors").WorldFailure>;
+/**
+ * A unit got into a transport (`UnitTypeDef.transport`), or out of one
+ *
+ * @beta
+ */
+export declare const boarded: import("./events").EventKey<{
+    passenger: import("./entity").Entity;
+    transport: import("./entity").Entity;
+}>;
+/**
+ * A unit was hired at a place that hires (`UnitTypeDef.hires`)
+ *
+ * @beta
+ */
+export declare const unitHired: import("./events").EventKey<{
+    shop: import("./entity").Entity;
+    unit: import("./entity").Entity;
+    player: import("./entity").PlayerId;
+}>;
+/**
+ * A passenger left its transport
+ *
+ * @beta
+ */
+export declare const unloaded: import("./events").EventKey<{
+    passenger: import("./entity").Entity;
+    transport: import("./entity").Entity;
+}>;
+/**
+ * A hero went up a level
+ *
+ * @beta
+ */
+export declare const heroLevelUp: import("./events").EventKey<{
+    hero: import("./entity").Entity;
+    level: number;
+}>;
+/**
+ * A hero earned experience (`grantXp`): how much, after `beforeXp`, and the level it is at after it
+ *
+ * @beta
+ */
+export declare const xpGained: import("./events").EventKey<{
+    hero: import("./entity").Entity;
+    amount: number;
+    level: number;
+    from?: import("./entity").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
+ *
+ * @beta
+ */
+export declare const manaChanged: import("./events").EventKey<{
+    entity: import("./entity").Entity;
+    amount: number;
+    ability?: string;
+    source?: import("./entity").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`)
+ *
+ * @beta
+ */
+export declare const resourceChanged: import("./events").EventKey<{
+    entity: import("./entity").Entity;
+    kind: string;
+    amount: number;
+    reason?: string;
+}>;
+/**
+ * A hero came back to life (at an altar, or by the rules)
+ *
+ * @beta
+ */
+export declare const heroRevived: import("./events").EventKey<import("./entity").Entity>;
+/**
+ * A unit began casting an ability, at a point where it has one. `duration`: seconds of the wind-up
+ *
+ * @beta
+ */
+export declare const castStarted: import("./events").EventKey<{
+    caster: import("./entity").Entity;
+    ability: import("./defs").AbilityDef;
+    point?: import("./math").Vec2;
+    duration: number;
+}>;
+/**
+ * A channelled ability started to be kept up, or ended: done, or `interrupted`
+ *
+ * @beta
+ */
+export declare const channelStarted: import("./events").EventKey<{
+    caster: import("./entity").Entity;
+    ability: import("./defs").AbilityDef;
+    duration: number;
+}>;
+/**
+ * A channelled ability stopped: run to its end, or broken off (`interrupted`)
+ *
+ * @beta
+ */
+export declare const channelEnded: import("./events").EventKey<{
+    caster: import("./entity").Entity;
+    ability: import("./defs").AbilityDef;
+    interrupted: boolean;
+}>;
+/**
+ * An ability's missile set off
+ *
+ * @beta
+ */
+export declare const missileSpawned: import("./events").EventKey<import("./world").Missile>;
+/**
+ * An ability's missile reached what it was sent at
+ *
+ * @beta
+ */
+export declare const missileHit: import("./events").EventKey<{
+    missile: import("./world").Missile;
+    target: import("./entity").Entity;
+}>;
+/**
+ * An ability's missile is gone: it hit, or ran out
+ *
+ * @beta
+ */
+export declare const missileRemoved: import("./events").EventKey<import("./world").Missile>;
+/**
+ * An ability went off: who cast it, at what level, at whom or where
+ *
+ * @beta
+ */
+export declare const abilityCast: import("./events").EventKey<{
+    caster: import("./entity").Entity;
+    ability: import("./defs").AbilityDef;
+    level: number;
+    target?: import("./entity").Entity;
+    point: import("./math").Vec2;
+    charged?: boolean;
+}>;
+/**
+ * What an ability set off arrived: a missile hit, a rush ended, the time was up
+ *
+ * @beta
+ */
+export declare const abilityImpact: import("./events").EventKey<{
+    caster: import("./entity").Entity;
+    ability: import("./defs").AbilityDef;
+    level: number;
+    target?: import("./entity").Entity;
+    point: import("./math").Vec2;
+    radius: number;
+    impact?: string;
+}>;
+/**
+ * A building finished researching an upgrade: which, and its level now
+ *
+ * @beta
+ */
+export declare const researchFinished: import("./events").EventKey<{
+    building: import("./entity").Entity;
+    upgrade: string;
+    level: number;
+}>;
+/**
+ * An item was put on the ground
+ *
+ * @beta
+ */
+export declare const itemDropped: import("./events").EventKey<import("./items").GroundItem>;
+/**
+ * An item was picked up from the ground
+ *
+ * @beta
+ */
+export declare const itemPicked: import("./events").EventKey<{
+    entity: import("./entity").Entity;
+    item: import("./entity").ItemInstance;
+}>;
+/**
+ * Every creep of a camp is gone. It comes back after a while, when it says so (see `Camp.respawn`)
+ *
+ * @beta
+ */
+export declare const campCleared: import("./events").EventKey<{
+    camp: import("./camps").Camp;
+}>;
+/**
+ * A camp cleared came back, its creeps where they stood (see `respawnCamp`)
+ *
+ * @beta
+ */
+export declare const campReturned: import("./events").EventKey<{
+    camp: import("./camps").Camp;
+}>;
+/**
+ * A player marked a spot for their allies, or for everyone (see `ping`)
+ *
+ * @beta
+ */
+export declare const pinged: import("./events").EventKey<{
+    player: import("./entity").PlayerId;
+    point: import("./math").Vec2;
+    kind: import("./talk").PingKind;
+    to: import("./talk").ChatAudience;
+    by?: string;
+}>;
+/**
+ * A player gave an ally resources (see `give`): how much went, and how much came after the tax
+ *
+ * @beta
+ */
+export declare const traded: import("./events").EventKey<{
+    from: import("./entity").PlayerId;
+    to: import("./entity").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
+ *
+ * @beta
+ */
+export declare const exchanged: import("./events").EventKey<{
+    player: import("./entity").PlayerId;
+    sold: string;
+    sent: number;
+    bought: string;
+    received: number;
+}>;
+/**
+ * A player said a line (see `chat`): to their side, or to everyone
+ *
+ * @beta
+ */
+export declare const chatted: import("./events").EventKey<{
+    player: import("./entity").PlayerId;
+    text: string;
+    to: import("./talk").ChatAudience;
+    by?: string;
+}>;
+/**
+ * What a unit carries changed: an item given, taken, bought, sold, used up, or a hero carried in with theirs
+ *
+ * @beta
+ */
+export declare const inventoryChanged: import("./events").EventKey<{
+    entity: import("./entity").Entity;
+}>;
+/**
+ * A player was paid for a kill: the unit killed, who was paid, how much
+ *
+ * @beta
+ */
+export declare const bounty: import("./events").EventKey<{
+    entity: import("./entity").Entity;
+    player: import("./entity").PlayerId;
+    amount: number;
+}>;
+/**
+ * A worker struck what it is mending
+ *
+ * @beta
+ */
+export declare const worked: import("./events").EventKey<{
+    worker: import("./entity").Entity;
+    target: import("./entity").Entity;
+}>;
+/**
+ * A worker struck the tree it is working on
+ *
+ * @beta
+ */
+export declare const chopped: import("./events").EventKey<{
+    worker: import("./entity").Entity;
+    source: import("./entity").Entity;
+}>;
+/**
+ * A worker handed in what it carried: `amount` as it went into the purse, `upkeep` what upkeep took of it at the door
+ *
+ * @beta
+ */
+export declare const resourcesDeposited: import("./events").EventKey<{
+    entity: import("./entity").Entity;
+    player: import("./entity").PlayerId;
+    kind: import("./defs").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
+ *
+ * @beta
+ */
+export declare const resourcesSpent: import("./events").EventKey<{
+    player: import("./entity").PlayerId;
+    cost: import("./defs").Cost;
+    on: import("./player").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
+ *
+ * @beta
+ */
+export declare const commandRejected: import("./events").EventKey<{
+    player?: import("./entity").PlayerId;
+    type?: string;
+    kind: import("./errors").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
+ *
+ * @beta
+ */
+export declare const commandHandled: import("./events").EventKey<{
+    player: import("./entity").PlayerId;
+    seq: number;
+    refusal?: import("./messages").Message;
+}>;
+/**
+ * Feedback for a player, like "Not enough gold": what the client finds the words for
+ *
+ * @beta
+ */
+export declare const messageSent: import("./events").EventKey<{
+    player: import("./entity").PlayerId;
+    message: import("./messages").Message;
+    kind: import("./world").MessageKind;
+    seconds?: number;
+}>;
+/**
+ * A unit walked into an area of the game (`GameModule.areas`)
+ *
+ * @beta
+ */
+export declare const enteredArea: import("./events").EventKey<{
+    area: string;
+    entity: import("./entity").Entity;
+}>;
+/**
+ * A unit walked out of one. What dies in an area is not said to leave it
+ *
+ * @beta
+ */
+export declare const leftArea: import("./events").EventKey<{
+    area: string;
+    entity: import("./entity").Entity;
+}>;
+/**
+ * An objective of a player was given (`was` undefined), got further along, was done or failed
+ *
+ * @beta
+ */
+export declare const objectiveChanged: import("./events").EventKey<{
+    player: import("./entity").PlayerId;
+    objective: import("./objectives").ObjectiveState;
+    was?: import("./objectives").ObjectiveStatus;
+}>;
+/**
+ * Someone said a line, to some players or everyone (see `world.dialog`)
+ *
+ * @beta
+ */
+export declare const lineSaid: import("./events").EventKey<import("./dialog").SaidLine>;
+/**
+ * A line was skipped by whom it was said to: it ends early for them
+ *
+ * @beta
+ */
+export declare const lineEnded: import("./events").EventKey<{
+    id: number;
+    to: import("./entity").PlayerId[];
+}>;
+/**
+ * A player went over to another team (`setTeam`)
+ *
+ * @beta
+ */
+export declare const teamChanged: import("./events").EventKey<{
+    player: import("./entity").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
+ *
+ * @beta
+ */
+export declare const checkpoint: import("./events").EventKey<{
+    label: import("./messages").Message;
+}>;
+/**
+ * The rules play one of the view's cinematics on the screens of some players, or everyone's (see `playCinematic`)
+ *
+ * @beta
+ */
+export declare const cinematicCue: import("./events").EventKey<import("./cinematics").CinematicCue>;
+/**
+ * The rules cue the cinematic playing on some screens, or everyone's (see `cueCinematic`)
+ *
+ * @beta
+ */
+export declare const cinematicCued: import("./events").EventKey<import("./cinematics").CinematicCueSent>;
+/**
+ * A cinematic the rules played is over on a player's screen, as their screen said (see `cinematic`'s `wait`)
+ *
+ * @beta
+ */
+export declare const cinematicEnded: import("./events").EventKey<import("./cinematics").CinematicEnded>;
+/**
+ * A player picked an answer of a cinematic's choice, as their screen said (see `cinematicChose`)
+ *
+ * @beta
+ */
+export declare const cinematicChoice: import("./events").EventKey<import("./cinematics").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`)
+ *
+ * @beta
+ */
+export declare const effectStarted: import("./events").EventKey<import("./effects").EffectCue>;
+/**
+ * The rules stop an effect they played (see `world.stopEffect`)
+ *
+ * @beta
+ */
+export declare const effectStopped: import("./events").EventKey<{
+    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
+ *
+ * @beta
+ */
+export declare const rustled: import("./events").EventKey<{
+    layer: string;
+    entity: import("./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`)
+ *
+ * @beta
+ */
+export declare const cellsChanged: import("./events").EventKey<{
+    layer: string;
+    cells: number[];
+    value: number;
+}>;
+/**
+ * A part of the ground was reshaped (`World.reshapeGround`): told to every player
+ *
+ * @beta
+ */
+export declare const groundReshaped: import("./events").EventKey<{
+    patch: import("./ground").TerrainPatch;
+}>;
+/**
+ * Cells of a layer that changed out of a team's sight came into it (`TeamMemory.cells`): told to that team's players
+ *
+ * @beta
+ */
+export declare const cellsSeen: import("./events").EventKey<{
+    team: number;
+    layer: string;
+    cells: number[];
+    value: number;
+}>;
+/** 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
+ *
+ * @beta
+ */
+export declare const environmentChanged: import("./events").EventKey<{
+    environment: import("./map").MapEnvironment;
+    over?: number;
+}>;