@v12-engine/engine 0.1.0 → 0.4.0

package/dist/engineEvents.d.ts

@@ -14,7 +14,7 @@ export declare const entityRemoved: import("./events").EventKey<import("./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
+ * @public
  */
 export declare const entityDied: import("./events").EventKey<{
     entity: import("./entity").Entity;
@@ -93,6 +93,17 @@ export declare const attackStarted: import("./events").EventKey<{
     target?: import("./entity").Entity;
     weapon: number;
 }>;
+/**
+ * A unit's swing was called off before its blow landed (moved away, told something else, its target gone, stunned):
+ * told to the players as `attackCancelled`, for the screen to cut the attack to the walk
+ *
+ * @beta
+ */
+export declare const swingCancelled: import("./events").EventKey<{
+    attacker: import("./entity").Entity;
+    target?: import("./entity").Entity;
+    weapon: number;
+}>;
 /**
  * An attack's projectile set off
  *
@@ -171,6 +182,17 @@ export declare const entityMorphed: import("./events").EventKey<{
     entity: import("./entity").Entity;
     from: string;
 }>;
+/**
+ * A hero in a form turned back into what it was (`leaveForm`): the form it was in, and what turned it back (its
+ * ability cast again, its time, its death; none when it took another form or code did it)
+ *
+ * @beta
+ */
+export declare const morphedBack: import("./events").EventKey<{
+    entity: import("./entity").Entity;
+    form: string;
+    why?: import("./defs").MorphBack | (string & {});
+}>;
 /**
  * A player lost: their units and buildings are gone, or the rules said so
  *
@@ -298,6 +320,15 @@ export declare const castStarted: import("./events").EventKey<{
     point?: import("./math").Vec2;
     duration: number;
 }>;
+/**
+ * A wind-up called off before it went off (`castStarted` with no cast after it): stunned, killed, ordered elsewhere
+ *
+ * @beta
+ */
+export declare const castCancelled: import("./events").EventKey<{
+    caster: import("./entity").Entity;
+    ability?: import("./defs").AbilityDef;
+}>;
 /**
  * A channelled ability started to be kept up, or ended: done, or `interrupted`
  *
@@ -365,6 +396,8 @@ export declare const abilityImpact: import("./events").EventKey<{
     point: import("./math").Vec2;
     radius: number;
     impact?: string;
+    from?: import("./math").Vec2;
+    effect?: import("./defs").EffectDef;
 }>;
 /**
  * A building finished researching an upgrade: which, and its level now
@@ -391,6 +424,16 @@ export declare const itemPicked: import("./events").EventKey<{
     entity: import("./entity").Entity;
     item: import("./entity").ItemInstance;
 }>;
+/**
+ * A hero took a purchase back at a shop (`undoBuy`)
+ *
+ * @beta
+ */
+export declare const itemUndone: import("./events").EventKey<{
+    entity: import("./entity").Entity;
+    item: string;
+    shop: number;
+}>;
 /**
  * Every creep of a camp is gone. It comes back after a while, when it says so (see `Camp.respawn`)
  *
@@ -415,7 +458,7 @@ export declare const campReturned: import("./events").EventKey<{
 export declare const pinged: import("./events").EventKey<{
     player: import("./entity").PlayerId;
     point: import("./math").Vec2;
-    kind: import("./talk").PingKind;
+    kind: import("./talk").PingId;
     to: import("./talk").ChatAudience;
     by?: string;
 }>;
@@ -498,7 +541,7 @@ export declare const chopped: import("./events").EventKey<{
 export declare const resourcesDeposited: import("./events").EventKey<{
     entity: import("./entity").Entity;
     player: import("./entity").PlayerId;
-    kind: import("./defs").ResourceKind;
+    kind: import("./defs").ResourceId;
     amount: number;
     upkeep?: number;
 }>;
@@ -555,9 +598,9 @@ export declare const messageSent: import("./events").EventKey<{
     seconds?: number;
 }>;
 /**
- * A unit walked into an area of the game (`GameModule.areas`)
+ * A unit walked into an area of the game (`Rules.areas`)
  *
- * @beta
+ * @public
  */
 export declare const enteredArea: import("./events").EventKey<{
     area: string;
@@ -627,6 +670,14 @@ export declare const cinematicCue: import("./events").EventKey<import("./cinemat
  * @beta
  */
 export declare const cinematicCued: import("./events").EventKey<import("./cinematics").CinematicCueSent>;
+/**
+ * The rules pan or shake one player's camera (see `cameraFor`)
+ *
+ * @beta
+ */
+export declare const cameraOrdered: import("./events").EventKey<{
+    player: import("./entity").PlayerId;
+} & Pick<import("./cameraOrders").CameraOrder, "pan" | "shake">>;
 /**
  * A cinematic the rules played is over on a player's screen, as their screen said (see `cinematic`'s `wait`)
  *
@@ -640,17 +691,17 @@ export declare const cinematicEnded: import("./events").EventKey<import("./cinem
  */
 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`)
+ * The rules play one of the view's effects at a place or on an entity, for everyone who sees it (see `world.fx`)
  *
  * @beta
  */
-export declare const effectStarted: import("./events").EventKey<import("./effects").EffectCue>;
+export declare const fxStarted: import("./events").EventKey<import("./effects").FxCue>;
 /**
- * The rules stop an effect they played (see `world.stopEffect`)
+ * The rules stop an effect they played (see `world.stopFx`)
  *
  * @beta
  */
-export declare const effectStopped: import("./events").EventKey<{
+export declare const fxStopped: import("./events").EventKey<{
     id: number;
     fade?: number;
 }>;
@@ -669,6 +720,17 @@ export declare const rustled: import("./events").EventKey<{
     entered: boolean;
     teams?: number[];
 }>;
+/**
+ * A gust of wind blew at a place (`gust`, `WindGust`): where, and the gust. Told to the players who see the place, as
+ * a `gust` message, for their screens to bend the grass and bushes there. Nothing of the world changes by it
+ *
+ * @beta
+ */
+export declare const gusted: import("./events").EventKey<{
+    x: number;
+    z: number;
+    gust: import("./foliage").WindGust;
+}>;
 /**
  * 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`)
@@ -679,6 +741,7 @@ export declare const cellsChanged: import("./events").EventKey<{
     layer: string;
     cells: number[];
     value: number;
+    over?: number;
 }>;
 /**
  * A part of the ground was reshaped (`World.reshapeGround`): told to every player

package/dist/engineEvents.js

@@ -0,0 +1,520 @@
+import { engineEvent } from "./events.js";
+//#region src/engineEvents.ts
+/**
+* The engine's events (design review E7): a key each, as a game's own are (`defineEvent`), emitted on `world.events`
+* and listened to with `defineListener` the same way. What each says is its payload, typed by the key; its id is its
+* name, as the debug tools' event log shows it
+*/
+/**
+* Something was made in the world: a unit trained or spawned, a building put down, a tree of the map
+*
+* @beta
+*/
+var entitySpawned = engineEvent("entitySpawned");
+/**
+* Something left the world for good: a corpse gone, a building taken down, a unit removed by the rules
+*
+* @beta
+*/
+var entityRemoved = engineEvent("entityRemoved");
+/**
+* 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'`)
+*
+* @public
+*/
+var entityDied = engineEvent("entityDied");
+/**
+* A buff was put on, or put on again (`renewed`, with the level it had before: `previousLevel`)
+*
+* @beta
+*/
+var buffApplied = engineEvent("buffApplied");
+/**
+* A buff came off: it ran out (`expired`), or was taken off. Not for the buffs of something that dies
+*
+* @beta
+*/
+var buffRemoved = engineEvent("buffRemoved");
+/**
+* Something took damage: who dealt it, how much, of which type, whether a critical strike, and by an attack or an ability
+*
+* @beta
+*/
+var damaged = engineEvent("damaged");
+/**
+* An attack went wide. Where it would have landed, and whom it was for
+*
+* @beta
+*/
+var missed = engineEvent("missed");
+/**
+* Something was given health back, and by whom
+*
+* @beta
+*/
+var healed = engineEvent("healed");
+/**
+* A unit began an attack: its swing, at its target where it has one
+*
+* @beta
+*/
+var attackStarted = engineEvent("attackStarted");
+/**
+* A unit's swing was called off before its blow landed (moved away, told something else, its target gone, stunned):
+* told to the players as `attackCancelled`, for the screen to cut the attack to the walk
+*
+* @beta
+*/
+var swingCancelled = engineEvent("swingCancelled");
+/**
+* An attack's projectile set off
+*
+* @beta
+*/
+var projectileSpawned = engineEvent("projectileSpawned");
+/**
+* An attack's projectile landed or was taken away
+*
+* @beta
+*/
+var projectileRemoved = engineEvent("projectileRemoved");
+/**
+* An attack that hits an area came down
+*
+* @beta
+*/
+var impact = engineEvent("impact");
+/**
+* A building's site was put down: what it will be, while it goes up
+*
+* @beta
+*/
+var constructionStarted = engineEvent("constructionStarted");
+/**
+* A building went up whole and works
+*
+* @beta
+*/
+var constructionFinished = engineEvent("constructionFinished");
+/**
+* A construction was called off by its owner: it dies next, with the reason `cancelled`
+*
+* @beta
+*/
+var constructionCancelled = engineEvent("constructionCancelled");
+/**
+* A building started to turn into another type (`UnitTypeDef.upgradesTo`), over `time` seconds
+*
+* @beta
+*/
+var morphStarted = engineEvent("morphStarted");
+/**
+* That was called off, or the building died before it was done
+*
+* @beta
+*/
+var morphCancelled = engineEvent("morphCancelled");
+/**
+* A building trained a unit: the building, and the unit made
+*
+* @beta
+*/
+var unitTrained = engineEvent("unitTrained");
+/**
+* An entity became another type: `from`, what it was
+*
+* @beta
+*/
+var entityMorphed = engineEvent("entityMorphed");
+/**
+* A hero in a form turned back into what it was (`leaveForm`): the form it was in, and what turned it back (its
+* ability cast again, its time, its death; none when it took another form or code did it)
+*
+* @beta
+*/
+var morphedBack = engineEvent("morphedBack");
+/**
+* A player lost: their units and buildings are gone, or the rules said so
+*
+* @beta
+*/
+var playerDefeated = engineEvent("playerDefeated");
+/**
+* A player gave up (see `surrender`): `playerDefeated` follows
+*
+* @beta
+*/
+var playerSurrendered = engineEvent("playerSurrendered");
+/**
+* A player asked for a pause, and the rules let them (see `askPause`): whoever runs the world pauses it, for `seconds` at most
+*
+* @beta
+*/
+var pauseAsked = engineEvent("pauseAsked");
+/**
+* The game ended, with the winning team (`0` for none)
+*
+* @beta
+*/
+var gameOver = engineEvent("gameOver");
+/**
+* The game ended on an error in its rules (`world.failure`): it is not stepped again
+*
+* @beta
+*/
+var worldFailed = engineEvent("worldFailed");
+/**
+* A unit got into a transport (`UnitTypeDef.transport`), or out of one
+*
+* @beta
+*/
+var boarded = engineEvent("boarded");
+/**
+* A unit was hired at a place that hires (`UnitTypeDef.hires`)
+*
+* @beta
+*/
+var unitHired = engineEvent("unitHired");
+/**
+* A passenger left its transport
+*
+* @beta
+*/
+var unloaded = engineEvent("unloaded");
+/**
+* A hero went up a level
+*
+* @beta
+*/
+var heroLevelUp = engineEvent("heroLevelUp");
+/**
+* A hero earned experience (`grantXp`): how much, after `beforeXp`, and the level it is at after it
+*
+* @beta
+*/
+var xpGained = engineEvent("xpGained");
+/**
+* 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
+*/
+var manaChanged = engineEvent("manaChanged");
+/**
+* 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
+*/
+var resourceChanged = engineEvent("resourceChanged");
+/**
+* A hero came back to life (at an altar, or by the rules)
+*
+* @beta
+*/
+var heroRevived = engineEvent("heroRevived");
+/**
+* A unit began casting an ability, at a point where it has one. `duration`: seconds of the wind-up
+*
+* @beta
+*/
+var castStarted = engineEvent("castStarted");
+/**
+* A wind-up called off before it went off (`castStarted` with no cast after it): stunned, killed, ordered elsewhere
+*
+* @beta
+*/
+var castCancelled = engineEvent("castCancelled");
+/**
+* A channelled ability started to be kept up, or ended: done, or `interrupted`
+*
+* @beta
+*/
+var channelStarted = engineEvent("channelStarted");
+/**
+* A channelled ability stopped: run to its end, or broken off (`interrupted`)
+*
+* @beta
+*/
+var channelEnded = engineEvent("channelEnded");
+/**
+* An ability's missile set off
+*
+* @beta
+*/
+var missileSpawned = engineEvent("missileSpawned");
+/**
+* An ability's missile reached what it was sent at
+*
+* @beta
+*/
+var missileHit = engineEvent("missileHit");
+/**
+* An ability's missile is gone: it hit, or ran out
+*
+* @beta
+*/
+var missileRemoved = engineEvent("missileRemoved");
+/**
+* An ability went off: who cast it, at what level, at whom or where
+*
+* @beta
+*/
+var abilityCast = engineEvent("abilityCast");
+/**
+* What an ability set off arrived: a missile hit, a rush ended, the time was up
+*
+* @beta
+*/
+var abilityImpact = engineEvent("abilityImpact");
+/**
+* A building finished researching an upgrade: which, and its level now
+*
+* @beta
+*/
+var researchFinished = engineEvent("researchFinished");
+/**
+* An item was put on the ground
+*
+* @beta
+*/
+var itemDropped = engineEvent("itemDropped");
+/**
+* An item was picked up from the ground
+*
+* @beta
+*/
+var itemPicked = engineEvent("itemPicked");
+/**
+* A hero took a purchase back at a shop (`undoBuy`)
+*
+* @beta
+*/
+var itemUndone = engineEvent("itemUndone");
+/**
+* Every creep of a camp is gone. It comes back after a while, when it says so (see `Camp.respawn`)
+*
+* @beta
+*/
+var campCleared = engineEvent("campCleared");
+/**
+* A camp cleared came back, its creeps where they stood (see `respawnCamp`)
+*
+* @beta
+*/
+var campReturned = engineEvent("campReturned");
+/**
+* A player marked a spot for their allies, or for everyone (see `ping`)
+*
+* @beta
+*/
+var pinged = engineEvent("pinged");
+/**
+* A player gave an ally resources (see `give`): how much went, and how much came after the tax
+*
+* @beta
+*/
+var traded = engineEvent("traded");
+/**
+* A player traded one resource for another at a rate (see `exchange`): how much of what went, and how much of what came
+*
+* @beta
+*/
+var exchanged = engineEvent("exchanged");
+/**
+* A player said a line (see `chat`): to their side, or to everyone
+*
+* @beta
+*/
+var chatted = engineEvent("chatted");
+/**
+* What a unit carries changed: an item given, taken, bought, sold, used up, or a hero carried in with theirs
+*
+* @beta
+*/
+var inventoryChanged = engineEvent("inventoryChanged");
+/**
+* A player was paid for a kill: the unit killed, who was paid, how much
+*
+* @beta
+*/
+var bounty = engineEvent("bounty");
+/**
+* A worker struck what it is mending
+*
+* @beta
+*/
+var worked = engineEvent("worked");
+/**
+* A worker struck the tree it is working on
+*
+* @beta
+*/
+var chopped = engineEvent("chopped");
+/**
+* A worker handed in what it carried: `amount` as it went into the purse, `upkeep` what upkeep took of it at the door
+*
+* @beta
+*/
+var resourcesDeposited = engineEvent("resourcesDeposited");
+/**
+* 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
+*/
+var resourcesSpent = engineEvent("resourcesSpent");
+/**
+* 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
+*/
+var commandRejected = engineEvent("commandRejected");
+/**
+* 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
+*/
+var commandHandled = engineEvent("commandHandled");
+/**
+* Feedback for a player, like "Not enough gold": what the client finds the words for
+*
+* @beta
+*/
+var messageSent = engineEvent("messageSent");
+/**
+* A unit walked into an area of the game (`Rules.areas`)
+*
+* @public
+*/
+var enteredArea = engineEvent("enteredArea");
+/**
+* A unit walked out of one. What dies in an area is not said to leave it
+*
+* @beta
+*/
+var leftArea = engineEvent("leftArea");
+/**
+* An objective of a player was given (`was` undefined), got further along, was done or failed
+*
+* @beta
+*/
+var objectiveChanged = engineEvent("objectiveChanged");
+/**
+* Someone said a line, to some players or everyone (see `world.dialog`)
+*
+* @beta
+*/
+var lineSaid = engineEvent("lineSaid");
+/**
+* A line was skipped by whom it was said to: it ends early for them
+*
+* @beta
+*/
+var lineEnded = engineEvent("lineEnded");
+/**
+* A player went over to another team (`setTeam`)
+*
+* @beta
+*/
+var teamChanged = engineEvent("teamChanged");
+/**
+* The rules marked a moment to start again from, like the start of a wave: a session keeps a save of it
+*
+* @beta
+*/
+var checkpoint = engineEvent("checkpoint");
+/**
+* The rules play one of the view's cinematics on the screens of some players, or everyone's (see `playCinematic`)
+*
+* @beta
+*/
+var cinematicCue = engineEvent("cinematicCue");
+/**
+* The rules cue the cinematic playing on some screens, or everyone's (see `cueCinematic`)
+*
+* @beta
+*/
+var cinematicCued = engineEvent("cinematicCued");
+/**
+* The rules pan or shake one player's camera (see `cameraFor`)
+*
+* @beta
+*/
+var cameraOrdered = engineEvent("cameraOrdered");
+/**
+* A cinematic the rules played is over on a player's screen, as their screen said (see `cinematic`'s `wait`)
+*
+* @beta
+*/
+var cinematicEnded = engineEvent("cinematicEnded");
+/**
+* A player picked an answer of a cinematic's choice, as their screen said (see `cinematicChose`)
+*
+* @beta
+*/
+var cinematicChoice = engineEvent("cinematicChoice");
+/**
+* The rules play one of the view's effects at a place or on an entity, for everyone who sees it (see `world.fx`)
+*
+* @beta
+*/
+var fxStarted = engineEvent("fxStarted");
+/**
+* The rules stop an effect they played (see `world.stopFx`)
+*
+* @beta
+*/
+var fxStopped = engineEvent("fxStopped");
+/**
+* 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
+*/
+var rustled = engineEvent("rustled");
+/**
+* A gust of wind blew at a place (`gust`, `WindGust`): where, and the gust. Told to the players who see the place, as
+* a `gust` message, for their screens to bend the grass and bushes there. Nothing of the world changes by it
+*
+* @beta
+*/
+var gusted = engineEvent("gusted");
+/**
+* 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
+*/
+var cellsChanged = engineEvent("cellsChanged");
+/**
+* A part of the ground was reshaped (`World.reshapeGround`): told to every player
+*
+* @beta
+*/
+var groundReshaped = engineEvent("groundReshaped");
+/**
+* Cells of a layer that changed out of a team's sight came into it (`TeamMemory.cells`): told to that team's players
+*
+* @beta
+*/
+var cellsSeen = engineEvent("cellsSeen");
+/** 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
+*/
+var environmentChanged = engineEvent("environmentChanged");
+//#endregion
+export { abilityCast, abilityImpact, attackStarted, boarded, bounty, buffApplied, buffRemoved, cameraOrdered, campCleared, campReturned, castCancelled, castStarted, cellsChanged, cellsSeen, channelEnded, channelStarted, chatted, checkpoint, chopped, cinematicChoice, cinematicCue, cinematicCued, cinematicEnded, commandHandled, commandRejected, constructionCancelled, constructionFinished, constructionStarted, damaged, enteredArea, entityDied, entityMorphed, entityRemoved, entitySpawned, environmentChanged, exchanged, fxStarted, fxStopped, gameOver, groundReshaped, gusted, healed, heroLevelUp, heroRevived, impact, inventoryChanged, itemDropped, itemPicked, itemUndone, leftArea, lineEnded, lineSaid, manaChanged, messageSent, missed, missileHit, missileRemoved, missileSpawned, morphCancelled, morphStarted, morphedBack, objectiveChanged, pauseAsked, pinged, playerDefeated, playerSurrendered, projectileRemoved, projectileSpawned, researchFinished, resourceChanged, resourcesDeposited, resourcesSpent, rustled, swingCancelled, teamChanged, traded, unitHired, unitTrained, unloaded, worked, worldFailed, xpGained };
+
+//# sourceMappingURL=engineEvents.js.map