@v12-engine/engine 0.1.0 → 0.4.0

package/dist/world.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"world.js","names":[],"sources":["../src/world.ts"],"sourcesContent":["import {\n\tcellsChanged,\n\tgroundReshaped,\n\tcheckpoint,\n\tcommandHandled,\n\tcommandRejected,\n\tentityRemoved,\n\tenvironmentChanged,\n\tmessageSent,\n\tworldFailed\n} from '#engine/engineEvents'\nimport { Life } from './life'\nimport { dashing } from './dashing'\nimport { Sight } from './sight'\nimport { Sides } from './sides'\nimport { Clock } from './clock'\nimport { Spawning } from './spawning'\nimport { constructionSite } from './systems/construction'\nimport { cellsIn, rememberUnseenCells } from './cellLayers'\nimport { executeCommand, type IssuedCommand } from './commands'\nimport type { Camp } from './camps'\nimport type { ChatAudience, PingId } from './talk'\nimport { checksOf, type DebugChecks } from './debug'\nimport {\n\ttype AbilityDef,\n\ttype AttackDef,\n\ttype Cost,\n\ttype DamageType,\n\ttype EffectDef,\n\ttype EffectOf,\n\tisScenery,\n\ttype MorphBack,\n\ttype ResourceId\n} from './defs'\nimport { detection, Entity, type EntityId, exposure, type ItemInstance, type PlayerId } from './entity'\nimport { EntityIndex } from './entityIndex'\nimport { type ErrorPolicy, type ErrorSite, GameEnded, modOfPart, type RejectedKind, siteKey, siteOf, siteWords, type WorldFailure } from './errors'\nimport { Emitter } from './events'\nimport { coreHooks } from './features'\nimport { errorFields, Logger, type LogLevel, rootLogger } from './log'\nimport { type AnyHook, type HookDef, Hooks } from './hooks'\nimport { FogOfWar } from './fog'\nimport { BuildGrid } from './grid'\nimport type { Vec2 } from './math'\nimport { AirNavigation, LayeredNavigation } from './navigation/air'\nimport type { SidePaths } from './navigation/sidePaths'\nimport type { Navigation } from './navigation/navigation'\nimport { Player, type PlayerInit, type SpentOn } from './player'\nimport type { Registry, System } from './registry'\nimport { hasGroundSpeeds, slowsOnFoot, stopsOnFoot } from './groundSpeed'\nimport type { RuleSettings } from './rules'\nimport { Scheduler } from './scheduler'\nimport { Score } from './score'\nimport { Computers } from './computers'\nimport { type Component, StateStore } from './components'\nimport { type Message, type MessageRef, toMessage } from './messages'\nimport { Rng } from './rng'\nimport { settleRaces } from './races'\nimport { tunableChanged, tunings } from './tunables'\nimport { type DataKind, type DataValues, definitionChanged, definitionIn, mergeValues, redefineIn, redefinitions } from './gameData'\nimport { SpatialIndex } from './spatial'\nimport { type GroundItem } from './items'\nimport { statsOf } from './stats'\nimport type { Terrain } from './terrain'\nimport { applyTerrainPatch, type GroundBase, type TerrainPatch } from './ground'\nimport { type AreaDef, type AreaShape, Areas } from './areas'\nimport { queryWorld, type WorldQuery } from './query'\nimport { Dialog, type SaidLine } from './dialog'\nimport { Objectives, type ObjectiveState, type ObjectiveStatus } from './objectives'\nimport { coreTimers, type SequenceDef, Sequences } from './sequences'\nimport { helpListeners } from './orders/idle'\nimport { type TimerDef, Timers } from './timers'\nimport type { ListenerDef } from './events'\nimport type { Trace } from './inspect'\nimport type { CameraOrder } from './cameraOrders'\nimport type { WindGust } from './foliage'\nimport type { CinematicChoice, CinematicCue, CinematicCueSent, CinematicEnded } from './cinematics'\nimport { type FxCue, type FxOptions, playFx, stopFx } from './effects'\nimport { mapInfo, names, WorldMap } from './names'\nimport type { MapEnvironment } from './map'\nimport { type PrefabDef, type SpawnedPrefab, spawnPrefab, type SpawnPrefabOptions } from './prefabs'\n\n/**\n * What two players are to each other, when set apart from their teams (`World.setRelation`)\n *\n * @beta\n */\nexport type PlayerRelation = 'ally' | 'enemy' | 'neutral'\n\n/**\n * A shot in flight to a target or a point; it deals its damage when it lands (`world.projectiles`)\n *\n * @beta\n */\nexport interface Projectile {\n\t/** The projectile's id, from `world.newId` */\n\tid: number\n\t/** The entity that fired it */\n\tsource: EntityId\n\t/** The player whose unit fired it, who is credited with what it does */\n\towner: PlayerId\n\t/** The entity it is after; 0 or gone for a shot that hits an area */\n\ttarget: EntityId\n\t/** Where it is now, east-west, in world units */\n\tx: number\n\t/** Where it is now, north-south, in world units */\n\tz: number\n\t/** Where it was at the last tick, east-west, for the screen to blend by */\n\tprevX: number\n\t/** Where it was at the last tick, north-south, for the screen to blend by */\n\tprevZ: number\n\t/** Where it is heading. Follows the target while it lives */\n\ttx: number\n\t/** The north-south coordinate it is heading for */\n\ttz: number\n\t/** World units it flies per second */\n\tspeed: number\n\t/** The damage it deals on landing */\n\tdamage: number\n\t/** The type of damage it deals */\n\ttype: DamageType\n\t/** Whether the hit is a critical one */\n\tcrit: boolean\n\t/** Fired uphill and going to miss: it flies all the way and does nothing when it comes down */\n\tmiss: boolean\n\t/** Where it was fired from */\n\tsx: number\n\t/** North-south coordinate it was fired from */\n\tsz: number\n\t/** Set for shots that hit an area instead of a target */\n\tsplash?: { radius: number; fells: boolean; targets?: AttackDef['targets'] }\n\t/** What it looks like, when the rules say: a look of the shooter's visual, for the screen (a flaming arrow) */\n\tlook?: string\n\t/** The type of what shot it: the screen draws it so, even once the shooter is gone or out of sight */\n\tkind: string\n\t/** Words of the game's own about it, which its damage carries (see `BeforeAttack.tags`) */\n\ttags?: string[]\n\t/** How what it kills dies, for the screen (see `AttackDef.how`) */\n\thow?: string\n\t/** Which of its shooter's attacks it is of, by place (`UnitTypeDef.attacks`): the first when left out */\n\tweapon?: number\n}\n\n/**\n * What an ability sent on its way: it travels in a line and does something to everything it passes through\n *\n * @beta\n */\nexport interface Missile {\n\t/** The missile's id, from `world.newId` */\n\tid: number\n\t/** The player whose unit sent it */\n\towner: PlayerId\n\t/** The caster entity that sent it */\n\tsource: EntityId\n\t/** The id of the ability it was sent by */\n\tability: string\n\t/** The ability's level when it was sent */\n\tlevel: number\n\t/** Where it is now, east-west, in world units */\n\tx: number\n\t/** Where it is now, north-south, in world units */\n\tz: number\n\t/** Where it was at the last tick, east-west */\n\tprevX: number\n\t/** Where it was at the last tick, north-south */\n\tprevZ: number\n\t/** Direction, of length 1 */\n\tdx: number\n\t/** North-south part of its direction */\n\tdz: number\n\t/** World units it travels per second */\n\tspeed: number\n\t/** How far it still goes */\n\tleft: number\n\t/** Seconds until it sets off, and how long that took in all */\n\tdelay: number\n\t/** Seconds it takes to take shape before it sets off: `delay` starts from it and counts down */\n\tforms: number\n\t/** How far from its path it hits things, in world units */\n\tradius: number\n\t/** The missile effect of the ability that made it, which says what it does to what it hits */\n\teffect: EffectOf<'missile'>\n\t/** Whom it has passed through already. Missiles sent together share it: what one of them hit the others pass by */\n\thit: Set<EntityId>\n\t/** The unit it flies after, for the ones that do */\n\ttarget: EntityId\n\t/** How far it has come */\n\ttravelled: number\n\t/** How far it has come since it set off, or sprang on last (`EffectFields.bounce`): how far along its arc it is */\n\tleg: number\n\t/** How high above the ground its arc carries it now, for whoever draws it: 0 for what is not thrown in an arc */\n\theight: number\n\t/** How many times it has sprung on to another */\n\tbounces: number\n\t/** Something got in its way: what happens where it ends does not */\n\tstopped: boolean\n\t/** On its way back to the caster (`EffectFields.returns`): it touches nobody (unless it `hitsOnReturn`), and ends where the caster is */\n\treturning?: boolean\n\t/** How many it went through, for one that goes through so many (`pierce`) or less on each (`falloff`) */\n\tstruck?: number\n\t/** The last one it hit, for what happens where it meets a wall (`onWall`) */\n\tlast?: EntityId\n\t/** The level of the ground it set off from, for one that stops at a wall (`onWall`): a cliff above it is a wall */\n\tfloor?: number\n\t/** Where its owner steers it (`steer`, `steerMissile`) */\n\tsteerTo?: Vec2\n\t/** How full the ability that sent it was held (`EffectContext.held`), for one held and let go */\n\theld?: number\n}\n\n/**\n * Something an ability does a while after it was cast\n *\n * @beta\n */\nexport interface Delayed {\n\t/** Seconds until its effects happen */\n\tleft: number\n\t/** The unit that cast the ability */\n\tcaster: Entity\n\t/** The ability whose effects are waiting */\n\tability: AbilityDef\n\t/** The ability's level when it was cast */\n\tlevel: number\n\t/** Where the effects happen */\n\tpoint: Vec2\n\t/** The effects to run when the time is up */\n\teffects: EffectDef[]\n\t/** What its arrival goes by, when not the ability */\n\timpact?: string\n\t/** Where the effects went off from and the way they faced as it was cast, for those with a shape (`EffectCommon.shape`) */\n\tfrom?: Vec2\n\t/** The way the effects faced as it was cast, in radians as a unit's `facing` (0 along +z), for those with a shape */\n\theading?: number\n}\n\n/**\n * Ground an ability goes on working on for a while\n *\n * @beta\n */\nexport interface Zone {\n\t/** The zone's id, from `world.newId` */\n\tid: number\n\t/** The unit that cast the ability */\n\tcaster: Entity\n\t/** The ability that made the zone */\n\tability: AbilityDef\n\t/** The ability's level when it was cast */\n\tlevel: number\n\t/** Centre of the zone, east-west */\n\tx: number\n\t/** Centre of the zone, north-south */\n\tz: number\n\t/** Seconds the zone goes on */\n\tleft: number\n\t/** Seconds until what is inside is next seen to */\n\tnext: number\n\t/** The zone effect that says what it does to what is inside */\n\teffect: EffectOf<'zone'>\n\t/**\n\t * Where the effects went off from and the way they faced as it was cast, kept for what it holds with a shape\n\t * (`EffectCommon.shape`): a cone of it goes off from there, the way it faced. Left out for one with no shape\n\t */\n\tfrom?: Vec2\n\t/** The way it faced as it was cast, in radians as a unit's `facing` (0 along +z); left out for one with no shape */\n\theading?: number\n\t/** The unit it goes with (`follow`) */\n\tfollows?: EntityId\n\t/** Who is in it now, by id from the lowest, for one that sees to who comes and goes (`onEnter`, `onLeave`, `edge`) */\n\tinside?: EntityId[]\n}\n\n/**\n * How a message to a player is shown: an error, information or a hint\n *\n * @beta\n */\nexport type MessageKind = 'error' | 'info' | 'hint'\n\n/**\n * The events a world emits (`world.events`), by name, each with its payload; what hooks do not cover and listeners and sessions hear\n *\n * @beta\n */\nexport interface WorldEvents {\n\t/** An entity was added to the world */\n\tentitySpawned: Entity\n\t/** An entity left the world, dead or taken away */\n\tentityRemoved: Entity\n\t/**\n\t * `cause`: the blow, for what died of damage. `how`: what the rules made of the death in the `death` hook, for the\n\t * screen to show (`'exploded'`, `'burned'`)\n\t */\n\tentityDied: { entity: Entity; killer?: Entity; attack: boolean; cause?: DeathCause; how?: string; reason: DeathReason }\n\t/** A buff was put on, or put on again (`renewed`, with the level it had before: `previousLevel`) */\n\tbuffApplied: { target: Entity; buff: string; level: number; source?: Entity; renewed: boolean; previousLevel?: number }\n\t/** A buff came off: it ran out (`expired`), or was taken off. Not for the buffs of something that dies */\n\tbuffRemoved: { entity: Entity; buff: string; expired: boolean }\n\t/** Damage was dealt to a target: how much, of which type, by whom and by what ability or attack */\n\tdamaged: { target: Entity; source?: Entity; amount: number; type: DamageType; crit: boolean; attack: boolean; ability?: string; tags?: string[] }\n\t/** An attack went wide. Where it would have landed, and whom it was for */\n\tmissed: { x: number; z: number; source?: Entity; target?: Entity }\n\t/** A target was healed by an amount, by a source when it has one */\n\thealed: { target: Entity; source?: Entity; amount: number }\n\t/** `weapon`: which of its attacks swings, by place (`UnitTypeDef.attacks`) */\n\tattackStarted: { attacker: Entity; target?: Entity; weapon: number }\n\t/**\n\t * A swing called off before its blow (`cancelSwing`): the unit was told something else, its target went, it was\n\t * stunned. What it was swinging at, where it was at something, and with which of its attacks\n\t */\n\tswingCancelled: { attacker: Entity; target?: Entity; weapon: number }\n\t/** A projectile was fired */\n\tprojectileSpawned: Projectile\n\t/** A projectile landed or was taken away */\n\tprojectileRemoved: Projectile\n\t/** An attack that hits an area came down */\n\timpact: { x: number; z: number; radius: number; owner: PlayerId }\n\t/** A building's construction began, its site placed */\n\tconstructionStarted: Entity\n\t/** A building was completed */\n\tconstructionFinished: Entity\n\t/** A construction was called off by its owner: it dies next, with the reason `cancelled` */\n\tconstructionCancelled: Entity\n\t/** A building started to turn into another type (`UnitTypeDef.upgradesTo`), over `time` seconds */\n\tmorphStarted: { entity: Entity; into: string; time: number }\n\t/** That was called off, or the building died before it was done */\n\tmorphCancelled: { entity: Entity; into: string }\n\t/** A building finished training a unit */\n\tunitTrained: { building: Entity; unit: Entity }\n\t/** An entity became another type: `from`, what it was */\n\tentityMorphed: { entity: Entity; from: string }\n\t/** A hero in a form turned back into what it was (`leaveForm`): `form`, the type it was in; `why`, what turned it back */\n\tmorphedBack: { entity: Entity; form: string; why?: MorphBack | (string & {}) }\n\t/** A player was defeated, out of the game */\n\tplayerDefeated: Player\n\t/** A player gave up (see `surrender`): `playerDefeated` follows */\n\tplayerSurrendered: { player: PlayerId }\n\t/** A player asked for a pause, and the rules let them (see `askPause`): whoever runs the world pauses it, for `seconds` at most */\n\tpauseAsked: { player: PlayerId; seconds: number; left: number }\n\t/** The game ended; `winner` is the winning team */\n\tgameOver: { winner: number }\n\t/** The game ended on an error in its rules (`world.failure`): it is not stepped again */\n\tworldFailed: WorldFailure\n\t/** A unit got into a transport (`UnitTypeDef.transport`), or out of one */\n\tboarded: { passenger: Entity; transport: Entity }\n\t/** A unit was hired at a place that hires (`UnitTypeDef.hires`) */\n\tunitHired: { shop: Entity; unit: Entity; player: PlayerId }\n\t/** A unit got out of a transport */\n\tunloaded: { passenger: Entity; transport: Entity }\n\t/** A hero reached a new level */\n\theroLevelUp: { hero: Entity; level: number }\n\t/** A hero earned experience (`grantXp`): how much, after `beforeXp`, and the level it is at after it */\n\txpGained: { hero: Entity; amount: number; level: number; from?: Entity }\n\t/**\n\t * A unit's mana changed by something it did or was given: spent on a cast (`amount` below 0, `ability` the one cast)\n\t * or given by an effect (above 0). Not its regeneration, which would be every tick\n\t */\n\tmanaChanged: { entity: Entity; amount: number; ability?: string; source?: Entity }\n\t/**\n\t * A pool of a game's own on a unit (rage, energy, charges) changed: emitted by the game's rules\n\t * (`world.events.emit(resourceChanged, …)`), heard by the screens of the unit's owner and allies (`resource`)\n\t */\n\tresourceChanged: { entity: Entity; kind: string; amount: number; reason?: string }\n\t/** A fallen hero was brought back */\n\theroRevived: Entity\n\t/** `duration`: seconds of the wind-up */\n\tcastStarted: { caster: Entity; ability: AbilityDef; point?: Vec2; duration: number }\n\t/**\n\t * A wind-up called off before it went off: the caster stunned, killed, or ordered elsewhere. `ability`: the one wound up,\n\t * where it is still known (an item's, gone with the item, is not)\n\t */\n\tcastCancelled: { caster: Entity; ability?: AbilityDef }\n\t/** A channelled ability started to be kept up, or ended: done, or `interrupted` */\n\tchannelStarted: { caster: Entity; ability: AbilityDef; duration: number }\n\t/** A channelled ability stopped being kept up; `interrupted` when it was broken off */\n\tchannelEnded: { caster: Entity; ability: AbilityDef; interrupted: boolean }\n\t/** A missile was sent on its way */\n\tmissileSpawned: Missile\n\t/** A missile passed through a target */\n\tmissileHit: { missile: Missile; target: Entity }\n\t/** A missile ended or was taken away */\n\tmissileRemoved: Missile\n\t/** An ability was cast: by whom, at what level, at which target or point, and whether it used a charge */\n\tabilityCast: { caster: Entity; ability: AbilityDef; level: number; target?: Entity; point: Vec2; charged?: boolean }\n\t/**\n\t * What an ability set off arrived: a missile hit, a rush ended, the time was up. `from`: where it went off from,\n\t * when not the caster (`EffectContext.origin`). `effect`: the effect of the ability whose arrival it is (a missile, a\n\t * delay, a zone at its end), where the list that landed is one of the ability's\n\t */\n\tabilityImpact: {\n\t\tcaster: Entity\n\t\tability: AbilityDef\n\t\tlevel: number\n\t\ttarget?: Entity\n\t\tpoint: Vec2\n\t\tradius: number\n\t\timpact?: string\n\t\tfrom?: Vec2\n\t\teffect?: EffectDef\n\t}\n\t/** A building finished researching an upgrade, to this level */\n\tresearchFinished: { building: Entity; upgrade: string; level: number }\n\t/** An item came to lie on the ground */\n\titemDropped: GroundItem\n\t/** An entity picked an item up from the ground */\n\titemPicked: { entity: Entity; item: ItemInstance }\n\t/** A hero took a purchase back at a shop (`undoBuy`): what it cost came back, the parts it used up came back */\n\titemUndone: { entity: Entity; item: string; shop: number }\n\t/** Every creep of a camp is gone. It comes back after a while, when it says so (see `Camp.respawn`) */\n\tcampCleared: { camp: Camp }\n\t/** A camp cleared came back, its creeps where they stood (see `respawnCamp`) */\n\tcampReturned: { camp: Camp }\n\t/** A player marked a spot for their allies, or for everyone (see `ping`) */\n\tpinged: { player: PlayerId; point: Vec2; kind: PingId; to: ChatAudience; by?: string }\n\t/** A player gave an ally resources (see `give`): how much went, and how much came after the tax */\n\ttraded: { from: PlayerId; to: PlayerId; resource: string; sent: number; received: number }\n\t/** A player traded one resource for another at a rate (see `exchange`): how much of what went, and how much of what came */\n\texchanged: { player: PlayerId; sold: string; sent: number; bought: string; received: number }\n\t/** A player said a line (see `chat`): to their side, or to everyone */\n\tchatted: { player: PlayerId; text: string; to: ChatAudience; by?: string }\n\t/** What a unit carries changed: an item given, taken, bought, sold, used up, or a hero carried in with theirs */\n\tinventoryChanged: { entity: Entity }\n\t/** A player was paid a bounty of this amount for an entity's death */\n\tbounty: { entity: Entity; player: PlayerId; amount: number }\n\t/** A worker struck what it is mending */\n\tworked: { worker: Entity; target: Entity }\n\t/** A worker struck the tree it is working on */\n\tchopped: { worker: Entity; source: Entity }\n\t/** A worker handed in what it carried: `amount` as it went into the purse, `upkeep` what upkeep took of it at the door */\n\tresourcesDeposited: { entity: Entity; player: PlayerId; kind: ResourceId; amount: number; upkeep?: number }\n\t/**\n\t * A player paid for something (`spend`), or was given back what they paid (`refund`, `giveBack`): `on` what (`unit`,\n\t * `upgrade`, `structure`, `item`, `hire`, `repair`... or a game's own word), and its id\n\t */\n\tresourcesSpent: { player: PlayerId; cost: Cost; on: SpentOn; id?: string; refund: boolean }\n\t/**\n\t * 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\n\t * field missing or of the wrong kind), or naming another player's unit, or a unit there never was. What a race makes\n\t * (an order to a unit that has just died) is not one. A server counts these against whoever sent them (`onCheat`);\n\t * a game's own commands may emit it too\n\t */\n\t/**\n\t * A command turned away (`RejectedKind`: why, for what counts them, as a server's cheat counter does), with the\n\t * reason in words for the log\n\t */\n\tcommandRejected: { player?: PlayerId; type?: string; kind: RejectedKind; reason: string }\n\t/** 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 */\n\tcommandHandled: { player: PlayerId; seq: number; refusal?: Message }\n\t/** Feedback for a player, like \"Not enough gold\": what the client finds the words for */\n\tmessageSent: { player: PlayerId; message: Message; kind: MessageKind; seconds?: number }\n\t/** A unit walked into an area of the game (`Rules.areas`) */\n\tenteredArea: { area: string; entity: Entity }\n\t/** A unit walked out of one. What dies in an area is not said to leave it */\n\tleftArea: { area: string; entity: Entity }\n\t/** An objective of a player was given (`was` undefined), got further along, was done or failed */\n\tobjectiveChanged: { player: PlayerId; objective: ObjectiveState; was?: ObjectiveStatus }\n\t/** Someone said a line, to some players or everyone (see `world.dialog`) */\n\tlineSaid: SaidLine\n\t/** A line was skipped by whom it was said to: it ends early for them */\n\tlineEnded: { id: number; to: PlayerId[] }\n\t/** A player went over to another team (`setTeam`) */\n\tteamChanged: { player: PlayerId; from: number; to: number }\n\t/** The rules marked a moment to start again from, like the start of a wave: a session keeps a save of it */\n\tcheckpoint: { label: Message }\n\t/** The rules play one of the view's cinematics on the screens of some players, or everyone's (see `playCinematic`) */\n\tcinematicCue: CinematicCue\n\t/** The rules cue the cinematic playing on some screens, or everyone's (see `cueCinematic`) */\n\tcinematicCued: CinematicCueSent\n\t/** The rules pan or shake one player's camera (see `cameraFor`) */\n\tcameraOrdered: { player: PlayerId } & Pick<CameraOrder, 'pan' | 'shake'>\n\t/** A cinematic the rules played is over on a player's screen, as their screen said (see `cinematic`'s `wait`) */\n\tcinematicEnded: CinematicEnded\n\t/** A player picked an answer of a cinematic's choice, as their screen said (see `cinematicChose`) */\n\tcinematicChoice: CinematicChoice\n\t/** The rules play one of the view's effects at a place or on an entity, for everyone who sees it (see `world.fx`) */\n\tfxStarted: FxCue\n\t/** The rules stop an effect they played (see `world.stopFx`) */\n\tfxStopped: { id: number; fade?: number }\n\t/**\n\t * One hidden in a layer of cells moved in it, or stepped into it (`ConcealmentOptions.rustle`): told to the teams\n\t * 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\n\t * layer draws there\n\t */\n\trustled: { layer: string; entity: Entity; x: number; z: number; entered: boolean; teams?: number[] }\n\t/**\n\t * A gust of wind blew at a place (`gust`, `WindGust`): where, and the gust. Told to the players who see the place,\n\t * for their screens to bend the grass and bushes there\n\t */\n\tgusted: { x: number; z: number; gust: WindGust }\n\t/**\n\t * Cells of a layer (`Terrain.cells`) were set to a value (`setCells`): told to the players who see them, the others\n\t * as they come into sight (`cellsSeen`). `over`: the seconds the screens ease into it over, where the rules said\n\t * (grass growing back)\n\t */\n\tcellsChanged: { layer: string; cells: number[]; value: number; over?: number }\n\t/**\n\t * Cells of a layer that changed out of a team's sight came into it (`TeamMemory.cells`): told to that team's players,\n\t * the cells at `value` now\n\t */\n\tcellsSeen: { team: number; layer: string; cells: number[]; value: number }\n\t/** A part of the ground was reshaped (`reshapeGround`): as it is now, told to every player */\n\tgroundReshaped: { patch: TerrainPatch }\n\t/** What the map looks like beyond its ground changed (`setEnvironment`): as it is now, told to every player */\n\t/** `over`: the seconds the screens ease into it over, where the rules said */\n\tenvironmentChanged: { environment: MapEnvironment; over?: number }\n}\n\n/**\n * What a world checks of itself and of its game as it runs, over the process's: for tests, development, a server that\n * runs games of its own\n *\n * @beta\n */\nexport interface WorldChecks {\n\t/** The engine's checks on itself (`DebugChecks`): all on or off, some of them; the process's (`setDebugChecks`) when left out */\n\tchecks?: boolean | Partial<DebugChecks>\n}\n\n/**\n * What a world is made of (`new World`): its ground and ways, its game, its players, its systems and hooks, and what it\n * checks of itself\n *\n * @beta\n */\nexport interface WorldOptions extends WorldChecks {\n\t/** The ground the world stands on */\n\tterrain: Terrain\n\t/** The navigation units on the ground walk by */\n\tnavigation: Navigation\n\t/** Where boats go (`UnitTypeDef.naval`): the deep water. None for a map without, and boats go on the ground */\n\twaterNavigation?: Navigation\n\t/** The navigations the sides plan their routes on, of what each knows (`Rules.paths: 'seen'`). None when left out */\n\tsidePaths?: SidePaths\n\t/** The game's definitions: unit types, abilities, orders and the rest */\n\tregistry: Registry\n\t/** The players of the world, in order, from which its `Player`s are made */\n\tplayers: PlayerInit[]\n\t/** The races one is drawn from for a player given `random`: all of the game's when left out */\n\trandomRaces?: readonly string[]\n\t/** Makes the systems of the world, once it is made: what keeps state of its own keeps it for this world */\n\tsystems: (world: World) => System[]\n\t/** Hook handlers. The engine's own (`coreHooks`) when left out */\n\thooks?: HookDef[]\n\t/** How the game reacts to events, subscribed in this order once the world is made */\n\tlisteners?: ListenerDef[]\n\t/** Parts of the map the rules watch */\n\tareas?: AreaDef[]\n\t/** What the game can set to go off later, by id */\n\ttimers?: TimerDef[]\n\t/** Scripts of steps the game can start, by id */\n\tsequences?: SequenceDef[]\n\t/** Seed for the world's random generator; 1 when left out */\n\tseed?: number\n\t/** Simulation steps per second */\n\ttickRate?: number\n\t/** The logger the world's own is made under (`world.log`): the root one when left out */\n\tlog?: Logger\n\t/** The least an entry of the world's log must matter to be said (`Rules.log`) */\n\tlogLevel?: LogLevel\n\t/** What becomes of a part of the game that throws (`Rules.onError`): it throws on, when left out */\n\tonError?: ErrorPolicy\n}\n\n/**\n * How a blow is described to `world.damage`: its type, whether it is an attack or crit, its ability, tags and how it kills\n *\n * @beta\n */\nexport interface DamageOptions {\n\t/** Physical when left out */\n\tdamageType?: DamageType\n\t/** A basic attack: life steal works on it */\n\tattack?: boolean\n\t/** It struck critically. The amount is what it is, this is for whoever is watching */\n\tcrit?: boolean\n\t/** The ability that dealt it, by id: for \"immune to Ice Storm\", or a kill feed. Left out for a basic attack */\n\tability?: string\n\t/** Words of the game's own about it (`'fire'`, `'explosive'`), for hooks and the screen to decide on */\n\ttags?: string[]\n\t/** How what this blow kills dies, for the screen (`'burnt'`): the death's `how` (`AttackDef.how`, `AbilityDef.how`) */\n\thow?: string\n}\n\n/**\n * What killed something that died of damage: the blow that did it\n *\n * @beta\n */\nexport interface DeathCause {\n\t/** The type of damage that killed */\n\ttype: DamageType\n\t/** What the blow took off */\n\tamount: number\n\t/** How much more it was than there was health left */\n\toverkill: number\n\t/** Whether the killing blow was a critical hit */\n\tcrit: boolean\n\t/** The id of the ability that dealt the blow, when it was one */\n\tability?: string\n\t/** Words of the game's own about the blow (`DamageOptions.tags`) */\n\ttags?: string[]\n\t/** How the blow says what it kills dies (`DamageOptions.how`) */\n\thow?: string\n}\n\n/**\n * Why something died, when it was not of damage: killed by the rules (`killed`, `world.kill`), its building called\n * off (`cancelled`), its time out (`expired`), a resource used up (`depleted`), brought down by a blast (`felled`), taken\n * away with what it stood on or by the debug tools (`removed`), or the game's own word (`sold`, `sacrificed`). `damage`\n * for one that ran out of health\n *\n * @beta\n */\nexport type DeathReason = 'damage' | 'killed' | 'cancelled' | 'expired' | 'depleted' | 'felled' | 'removed' | (string & {})\n\n/**\n * A spot a team sees for a while, with nothing standing there\n *\n * @beta\n */\nexport interface Reveal {\n\t/** The reveal's id, from `world.newId` */\n\tid: number\n\t/** The team that sees the spot */\n\tteam: number\n\t/** Centre of the revealed spot, east-west */\n\tx: number\n\t/** Centre of the revealed spot, north-south */\n\tz: number\n\t/** How far from the centre it reveals, in world units */\n\tradius: number\n\t/** Seconds it goes on */\n\tleft: number\n\t/** Shown, and nothing drawn for it: what the rules show a player, as a cinematic looks at it. A spell's, when left out */\n\tquiet?: boolean\n}\n\n/**\n * What `world.spawn` is told besides type, owner and position: facing, size, look and the rest\n *\n * @beta\n */\nexport interface SpawnOptions {\n\t/** The way it faces, in radians; the engine's default facing when left out */\n\tfacing?: number\n\t/** How big it is drawn */\n\tscale?: number\n\t/** Which of the models of its type it is drawn with, for things that come in kinds like trees */\n\tlook?: string\n\t/**\n\t * Drawn as this entity is: its type's model, its owner's colour, its size and its look, while the new one stays what\n\t * its own type and owner say it is (a soul in the fallen's shape). `scale` and `look` here win over the entity's\n\t */\n\tlooksLike?: Entity\n\t/**\n\t * Components it starts with, by id, as `Component.default` would not give them: `{ 'warden.soul': { hero: 4 } }`.\n\t * They are on it before the hooks of its making run. An id the game does not have throws\n\t */\n\tdata?: Record<string, unknown>\n\t/** A name of its own, for the rules to find it by: `world.named('gate')` */\n\tname?: string\n\t/** Seconds it lasts, when that is not what its type says */\n\tlifetime?: number\n\t/** Structures only: start as a construction site, with its build time and what was paid when they are not its type's */\n\tunderConstruction?: boolean | { buildTime?: number; paid?: Cost }\n}\n\n/**\n * Where a new entity goes and whose it is, with what else it starts with (`World.spawn(type, { at, owner })`)\n *\n * @public\n */\nexport interface SpawnAt extends SpawnOptions {\n\t/** Where it stands, in cells; a building is centred on the cells nearest it */\n\tat: Vec2\n\t/** The player it belongs to */\n\towner: PlayerId\n}\n\n/** See `World.internals` */\nexport interface WorldInternals {\n\tnextEntityId: number\n\tnextId: number\n\tclockShift: number\n\t/** The hour the clock stands at, when it does not move */\n\tstillHour?: number\n\tcommands: IssuedCommand[]\n\t/** Who died and has not been taken out of the world yet: at the end of the tick that comes */\n\tdead?: EntityId[]\n}\n\n/**\n * What watches a world from outside (`World.watch`): told of each command a player gives it, each save taken of it,\n * and each tick it ran\n *\n * @beta\n */\nexport interface WorldWatcher {\n\t/** A command given from outside a tick, before the tick it is applied at runs */\n\tcommand?(command: IssuedCommand): void\n\t/** A save was taken, which put the world's crowd back as a load puts it */\n\tsaved?(): void\n\t/** A tick ran */\n\tstepped?(): void\n}\n\n/**\n * The simulation: the ground, entities, players, systems and rules of one game, stepped a tick at a time with `step`\n *\n * @public\n */\nexport class World {\n\t/**\n\t * Obstacles the navigation had no room for (`RecastNavigationOptions.maxObstacles`): what is put down past it does not block the way\n\t *\n\t * @beta\n\t */\n\tobstaclesRefused = 0\n\t/**\n\t * The ground the world stands on\n\t *\n\t * @beta\n\t */\n\treadonly terrain: Terrain\n\t/**\n\t * The ground it started on, where it was made from a map (S36): what a save keeps only the changes of\n\t *\n\t * @beta\n\t */\n\tground?: GroundBase\n\t/**\n\t * The ground and the air. Agents find their own layer, everything else is about the ground\n\t *\n\t * @beta\n\t */\n\treadonly nav: Navigation\n\t/**\n\t * The navigations the sides plan their routes on, of the buildings each knows (`Rules.paths: 'seen'`): routes\n\t * of ground units are planned on their side's, and walked on `nav`. None where routes know everything\n\t *\n\t * @beta\n\t */\n\treadonly sidePaths?: SidePaths\n\t/** The ground, the air and the water, to find where a kind of unit can be */\n\tprivate readonly layers: LayeredNavigation\n\t/** The navigation an entity goes on: the air for what flies, the water for boats where the map has it, the ground for the rest */\n\t/**\n\t * The ways a type of entity walks, flies or sails on (`navFor` for one made)\n\t *\n\t * @internal\n\t */\n\tlayerOf(def: { flying?: boolean; naval?: boolean }): Navigation {\n\t\treturn this.layers.layer(def)\n\t}\n\n\t/**\n\t * An id for an entity about to be made (`Spawning`)\n\t *\n\t * @internal\n\t */\n\tnewEntityId(): number {\n\t\treturn this.nextEntityId++\n\t}\n\n\t/**\n\t * The navigation an entity walks by: the air, the water or the ground, by its layer\n\t *\n\t * @beta\n\t */\n\tnavFor(entity: Entity): Navigation {\n\t\treturn this.layers.layer(entity.def)\n\t}\n\t/**\n\t * The air alone\n\t *\n\t * @beta\n\t */\n\treadonly air: Navigation\n\t/** The game's definitions: unit types, abilities, orders and the rest */\n\treadonly registry: Registry\n\t/**\n\t * Which cells are taken by buildings and what can be built where\n\t *\n\t * @beta\n\t */\n\treadonly grid: BuildGrid\n\t/**\n\t * What each team has seen and sees, per cell\n\t *\n\t * @beta\n\t */\n\treadonly fog: FogOfWar\n\t/**\n\t * Index of entities by position, for asking what is near a point.\n\t *\n\t * Units are filed once a tick, where they stand as it starts (after the commands, before the systems: `step`).\n\t * A unit that moves during the tick (the `move` phase) is still filed where it was until the next, so a query in\n\t * `resolve` searches by where units started and checks distance against where they are now: a unit that walked\n\t * into range this tick may be found only the next. Structures are filed where they stand, as they are made\n\t *\n\t * @beta\n\t */\n\treadonly spatial: SpatialIndex\n\t/** What happened, for whoever watches: sessions, tests. Sent out at the end of each tick. Rules use `hooks` */\n\treadonly events = new Emitter()\n\t/**\n\t * What this world says about what it does: `world.log.warn('waves', 'nothing to send', { wave })`. Each entry says\n\t * the game and the tick it is from, and goes to whoever asked (`world.log.to(sink)`) and to the logger the world\n\t * was made under. It changes nothing in the world, and is not in a save\n\t */\n\treadonly log: Logger\n\t/**\n\t * The engine's checks on itself this world runs (`DebugChecks`): what it was made with (`CreateWorldOptions.checks`),\n\t * the process's (`setDebugChecks`) when it says nothing. Slow: tests and development\n\t *\n\t * @beta\n\t */\n\tchecks: DebugChecks = checksOf(undefined)\n\t/**\n\t * Moved on by `invalidateStats` without an entity: every entity's stats are added up again when next asked for\n\t *\n\t * @beta\n\t */\n\tstatsVersion = 0\n\t/**\n\t * What the debug tools follow of the rules as they run: hooks and listeners. Null when nobody asks, see `EventLog`\n\t *\n\t * @beta\n\t */\n\ttrace: Trace | null = null\n\t/** Where game modules and mods take part in damage, deaths, orders and the like, see `HookEvents` */\n\treadonly hooks: Hooks\n\t/** The areas of the game, and who is in them */\n\treadonly areas: Areas\n\t/** What is set to go off later: `world.timers.after(30, waveComes)` */\n\treadonly timers: Timers\n\t/** Scripts of steps that run over time: `world.sequences.start(briefing)` */\n\treadonly sequences: Sequences\n\t/** What each player is set to do, in a mission */\n\treadonly objectives: Objectives\n\t/**\n\t * What the game counts of its players (`RuleSettings.score`): `world.score.add(player, 'towersLost')`, `get`, `team`.\n\t * Counts nothing in a game that does not ask\n\t *\n\t * @beta\n\t */\n\treadonly score: Score\n\t/** What is said, by whom, to whom: `world.dialog.say(player, line)`, or `talk` in a sequence */\n\treadonly dialog: Dialog\n\t/** The world's seeded random generator; the only source of randomness the simulation uses */\n\treadonly rng: Rng\n\t/** Every player of the world, by id */\n\treadonly players = new Map<PlayerId, Player>()\n\t/**\n\t * Everything in the world, by id. Fallen heroes stay in here while they wait to be brought back\n\t *\n\t * @beta\n\t */\n\treadonly entities = new Map<EntityId, Entity>()\n\t/**\n\t * The entities that act: the ones that move, fight, build or change by themselves, which is everything but scenery.\n\t * Systems that run every tick go through these instead of `entities`, which on a big map is mostly trees.\n\t *\n\t * In the order each became a unit, which is the order of ids except for scenery woken later (`Spawning.wake`: a\n\t * tree given a buff), which comes last, after units made before it. A save keeps this order, so a loaded world\n\t * walks it the same. A component's index (`EntityIndex`, `SystemDef.over`) walks in id order instead, so code that\n\t * picks the first of equals breaks the tie by id, not by which it met first, to stay the same either way\n\t */\n\treadonly units = new Map<EntityId, Entity>()\n\t/**\n\t * The scenery each team sees right now, by team. Kept by the fog system whenever it works out what everyone sees:\n\t * scenery never moves, so this only changes then. Lets a session describe what is in sight without testing every tree\n\t *\n\t * @beta\n\t */\n\treadonly sceneryInSight = new Map<number, Set<Entity>>()\n\t/**\n\t * Entities by owner, heroes by owner, shops. For questions that would otherwise go through every entity\n\t *\n\t * @beta\n\t */\n\treadonly index = new EntityIndex(\n\t\t(id) => this.registry.used(id),\n\t\t() => this\n\t)\n\t/**\n\t * The shots in flight\n\t *\n\t * @beta\n\t */\n\treadonly projectiles: Projectile[] = []\n\t/**\n\t * The missiles in flight\n\t *\n\t * @beta\n\t */\n\treadonly missiles: Missile[] = []\n\t/**\n\t * Effects waiting for their time to come\n\t *\n\t * @beta\n\t */\n\treadonly delayed: Delayed[] = []\n\t/**\n\t * The zones that are working on the ground now\n\t *\n\t * @beta\n\t */\n\treadonly zones: Zone[] = []\n\t/**\n\t * Switches for trying things out. A game that is played for real leaves them off\n\t *\n\t * @beta\n\t */\n\treadonly cheats = {\n\t\t/** Abilities and what is carried can be used again at once */\n\t\tnoCooldowns: false,\n\t\t/** Abilities cost no mana, and are cast with none left */\n\t\tnoManaCosts: false,\n\t\t/** What the players allowed the debug tools own (`debugPlayers`) takes no harm, and so does not die of it */\n\t\tinvulnerable: false,\n\t\t/** How fast the game goes, 1 as it should, 0 paused: whoever runs it (a session in the page, a server) goes by it */\n\t\tspeed: 1\n\t}\n\t/**\n\t * Players who may use the debug commands (`debug.*`, see `debugCommands.ts`): who a session lets, a seat in the page\n\t * that asked, a server started to. Not in a save: whoever loads it says again\n\t *\n\t * @beta\n\t */\n\treadonly debugPlayers = new Set<PlayerId>()\n\t/**\n\t * The entity each object of the map became, by the object's id (`MapObject.id`): what the map put down as the world\n\t * was made of it (`createWorldFromMap`), and what the editor's Play here put down since (`debug.mapObject`), for the\n\t * editor to find again what it moves and takes away (EQ10). Kept in a save\n\t *\n\t * @beta\n\t */\n\treadonly fromMap = new Map<number, EntityId>()\n\t/**\n\t * Spots a team sees for a while without anything there to see them\n\t *\n\t * @beta\n\t */\n\treadonly reveals: Reveal[] = []\n\t/**\n\t * State of game modules and mods for the whole game, see `state`\n\t *\n\t * @beta\n\t */\n\treadonly states = new StateStore()\n\t/**\n\t * Items lying on the ground\n\t *\n\t * @beta\n\t */\n\treadonly items: GroundItem[] = []\n\t/**\n\t * Runs the systems, in order, each as often as it asks\n\t *\n\t * @beta\n\t */\n\treadonly scheduler: Scheduler\n\t/** The computer players: who is seated, kept in a save and seated again by a load (`world.computers.seat`) */\n\treadonly computers: Computers\n\t/**\n\t * 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\n\t *\n\t * @beta\n\t */\n\treadonly seed: number\n\n\t/** Simulation ticks per second */\n\treadonly tickRate: number\n\t/**\n\t * Seconds per tick\n\t *\n\t * @beta\n\t */\n\treadonly dt: number\n\t/** The tick number the world is at, from 0; it goes up by one for each `step` */\n\ttick = 0\n\t/**\n\t * How things are hurt, healed and die (`Life`)\n\t *\n\t * @beta\n\t */\n\treadonly life: Life = new Life(this)\n\t/**\n\t * What each team sees of the entities (`Sight`): the fog, what is invisible, the game's say\n\t *\n\t * @beta\n\t */\n\treadonly sight: Sight = new Sight(this)\n\t/**\n\t * Who is on whose side (`Sides`): teams, relations, shared vision and control\n\t *\n\t * @beta\n\t */\n\treadonly sides: Sides = new Sides(this)\n\t/**\n\t * How entities come into the world and are moved about in it (`Spawning`)\n\t *\n\t * @beta\n\t */\n\treadonly spawning: Spawning = new Spawning(this)\n\t/**\n\t * The time of day (`Clock`): the hour, night, turned forward or stopped\n\t *\n\t * @beta\n\t */\n\treadonly clock: Clock = new Clock(this)\n\t/** Team that won, once the game is decided */\n\twinner: number | null = null\n\t/**\n\t * What becomes of a part of the game that throws: a hook's handler, a listener, a system, a timer, an order, a\n\t * command (`ErrorPolicy`). The game's own (`Rules.onError`), or whoever runs the world's; with neither it\n\t * throws, as it always did. A server and a launched game end the game where nothing is said (`??= 'end'`)\n\t *\n\t * @beta\n\t */\n\terrorPolicy?: ErrorPolicy\n\t/**\n\t * Why the game ended on an error, once it has (`end`): the world is not stepped again\n\t *\n\t * @beta\n\t */\n\tfailure: WorldFailure | null = null\n\t/**\n\t * The parts switched off for having thrown (`disable`), by name (`siteKey`): kept in a save, and off again when it is loaded\n\t *\n\t * @beta\n\t */\n\treadonly disabled = new Map<string, ErrorSite>()\n\t/** True through a tick: an error then can end the game; outside one it is whoever called's */\n\tprivate stepping = false\n\tprivate toldFailure = false\n\t/** Errors already answered `throw` further in: not asked about again on their way out */\n\tprivate readonly thrown = new WeakSet<object>()\n\n\tprivate nextEntityId = 1\n\tprivate nextId = 1\n\tprivate commands: IssuedCommand[] = []\n\t/** Commands each player gave since the last tick, from outside one: what `commandLimit` counts */\n\tprivate readonly given = new Map<PlayerId, number>()\n\t/** Commands let go since the last tick, by player: told of at the next (`commandRejected`) */\n\tprivate readonly overLimit = new Map<PlayerId, number>()\n\t/** Those of them the sender numbered: each answered at the next tick, refused (`commandHandled`), for a screen that waits on it */\n\tprivate readonly overLimitSeqs: { player: PlayerId; seq: number }[] = []\n\n\t/**\n\t * Commands a player may give between two ticks, at most (`issue`, from outside a tick): those past it are let go,\n\t * and the tick says so once (`commandRejected`, reason `tooManyCommands`), and answers each the sender numbered,\n\t * refused (`commandHandled`). A server's rate limit keeps far under it; this bounds what has none (a worker, a\n\t * page's own host, a script gone wrong). The computer and scripts, which give theirs in a tick, are not counted.\n\t * 100 when left out; `Infinity` for none\n\t *\n\t * @beta\n\t */\n\tcommandLimit = 100\n\n\t/**\n\t * Makes an empty world of the options' terrain, rules and players; a game makes one with `createWorld` or\n\t * `createWorldFromMap`, which also place the map's things and start the rules\n\t *\n\t * @beta\n\t */\n\tconstructor(options: WorldOptions) {\n\t\tthis.terrain = options.terrain\n\t\tthis.air = new AirNavigation(options.terrain.width, options.terrain.depth)\n\t\tthis.layers = new LayeredNavigation(options.navigation, this.air, options.waterNavigation)\n\t\tthis.nav = this.layers\n\t\tthis.sidePaths = options.sidePaths\n\t\tthis.registry = options.registry\n\t\tthis.log = (options.log ?? rootLogger).child({ level: options.logLevel, context: () => ({ game: this.registry.game, tick: this.tick }) })\n\t\t// what the registry has to say (a part the game does not list) is said by the world it is the registry of\n\t\tthis.registry.log = this.log\n\t\tthis.errorPolicy = options.onError\n\t\tif (options.checks !== undefined) this.checks = checksOf(options.checks)\n\t\t// an event of the game's own that the game does not list is an error (`UnlistedError`)\n\t\tthis.events.watch((type) => {\n\t\t\tif (typeof type === 'string' && !this.registry.lists('event', type)) this.registry.event(type)\n\t\t})\n\t\tthis.hooks = new Hooks(this)\n\t\tfor (const hook of options.hooks ?? coreHooks) this.hooks.add(hook)\n\t\t// a layer of cells that slows one on foot (or a value of it: a style of grass), changed in play: the ways weigh it\n\t\t// again where it changed (EN2). Not a state layer of grass: a fire does not cut the ways again. Which layers slow is\n\t\t// asked as each change comes, of the game as it is then: a style given a speed or made a thicket while the game\n\t\t// plays (`debug.cellStyles`) counts from then on. Only where the ground slowed somewhere as the world was made:\n\t\t// its navigations weigh the ground only then (`RecastNavigationOptions.speedAt`)\n\t\tif (hasGroundSpeeds(this.registry)) {\n\t\t\tthis.events.on(cellsChanged, ({ layer, cells }) => {\n\t\t\t\tif (!slowsOnFoot(this.registry, layer)) return\n\t\t\t\t// a layer with a thicket among its values may have made cells walkable or not\n\t\t\t\tconst walkability = stopsOnFoot(this.registry, layer)\n\t\t\t\tthis.nav.groundChanged?.(cells, walkability)\n\t\t\t\tthis.sidePaths?.groundChanged(cells, walkability)\n\t\t\t})\n\t\t}\n\t\tthis.tickRate = options.tickRate ?? 30\n\t\tthis.dt = 1 / this.tickRate\n\t\tthis.seed = options.seed ?? 1\n\t\tthis.rng = new Rng(this.seed)\n\t\tthis.computers = new Computers(this)\n\t\tfor (const init of options.players) this.players.set(init.id, new Player(init))\n\t\t// a race for each who plays: drawn from the world's numbers only where one is to be drawn\n\t\tsettleRaces(this.players.values(), this.registry, (count) => this.rng.int(0, count - 1), options.randomRaces)\n\t\tthis.grid = new BuildGrid(this.terrain)\n\t\tconst teams = new Set<number>()\n\t\tfor (const player of this.players.values()) if (!player.neutral) teams.add(player.team)\n\t\tthis.fog = new FogOfWar(this.terrain.width, this.terrain.depth, [], this.terrain.levels)\n\t\t// the whole map explored from the start where the rules say (`FogSettings.startExplored`), for the teams there are and\n\t\t// to come. A map says otherwise as the game is made from it (`MapDef.explored`)\n\t\tthis.fog.exploredFromStart = !!this.settings.fog?.startExplored\n\t\tfor (const team of teams) this.fog.addTeam(team)\n\t\tthis.spatial = new SpatialIndex(this.terrain.width, this.terrain.depth)\n\t\t// last: what makes a system may look at the world\n\t\tthis.scheduler = new Scheduler(options.systems(this))\n\t\tthis.areas = new Areas(this, options.areas ?? [])\n\t\tthis.timers = new Timers(this, [...coreTimers, ...(options.timers ?? [])])\n\t\tthis.sequences = new Sequences(this, options.sequences ?? [])\n\t\tthis.objectives = new Objectives(this)\n\t\tthis.dialog = new Dialog(this)\n\t\t// counted ahead of the game's listeners: one that hears of a kill reads the score with it\n\t\tthis.score = new Score(this)\n\t\tconst ids = new Set<string>()\n\t\t// the game's listeners, then the ones its sequences need for what they wait for\n\t\tfor (const listener of [...helpListeners, ...(options.listeners ?? []), ...Sequences.listenersFor(options.sequences ?? [])]) {\n\t\t\tif (ids.has(listener.id)) throw new Error(`Listener \"${listener.id}\" is there twice`)\n\t\t\tids.add(listener.id)\n\t\t\tconst off = `listener:${listener.id}`\n\t\t\tthis.events.on(listener.event, (payload) => {\n\t\t\t\t// one switched off for having thrown no longer hears anything\n\t\t\t\tif (this.disabled.size && this.disabled.has(off)) return\n\t\t\t\tthis.trace?.listener(listener.id)\n\t\t\t\ttry {\n\t\t\t\t\tlistener.run(this, payload)\n\t\t\t\t} catch (error) {\n\t\t\t\t\tthis.caught(error, { kind: 'listener', id: listener.id })\n\t\t\t\t}\n\t\t\t})\n\t\t}\n\t}\n\n\t/**\n\t * The systems, in the order they run\n\t *\n\t * @beta\n\t */\n\tget systems(): readonly System[] {\n\t\treturn this.scheduler.systems\n\t}\n\n\t/**\n\t * Adds a system to the running world, like a computer player. It takes its place by its phase, `before` and `after`\n\t *\n\t * @beta\n\t */\n\taddSystem(system: System): void {\n\t\tthis.scheduler.add(system)\n\t\t// in a loaded world, what it kept when the game was saved\n\t\tconst saved = this.savedSystems.get(system.name)\n\t\tif (saved !== undefined && system.restore) {\n\t\t\tthis.savedSystems.delete(system.name)\n\t\t\tsystem.restore(this, saved)\n\t\t}\n\t}\n\n\t/** What systems kept in themselves when the game was saved, for those not added yet */\n\tprivate readonly savedSystems = new Map<string, unknown>()\n\n\t/**\n\t * Gives the systems what they kept in a save (see `System.save`): those there now, and those added later\n\t *\n\t * @beta\n\t */\n\trestoreSystems(saved: Record<string, unknown>): void {\n\t\tthis.savedSystems.clear()\n\t\tfor (const [name, data] of Object.entries(saved)) {\n\t\t\tconst system = this.systems.find((each) => each.name === name)\n\t\t\tif (system?.restore) system.restore(this, data)\n\t\t\telse this.savedSystems.set(name, data)\n\t\t}\n\t}\n\n\t/**\n\t * Takes a system out by name. False when there is none of that name\n\t *\n\t * @beta\n\t */\n\tremoveSystem(name: string): boolean {\n\t\treturn this.scheduler.remove(name)\n\t}\n\n\t/** Seconds of game time that have passed: `tick` times `dt` */\n\tget time(): number {\n\t\treturn this.tick * this.dt\n\t}\n\n\t/**\n\t * A number of the rules as it is tuned now (`TunableDef`): what it was set to while playing, or its default\n\t *\n\t * @beta\n\t */\n\ttunable(id: string): number {\n\t\tconst def = this.registry.tunable(id)\n\t\tif (!def) throw new Error(`The game has no tunable \"${id}\"`)\n\t\treturn this.state(tunings)[id] ?? def.default\n\t}\n\n\t/**\n\t * Tunes a number of the rules, within its bounds, and says so (`tunableChanged`)\n\t *\n\t * @beta\n\t */\n\tsetTunable(id: string, value: number): void {\n\t\tconst def = this.registry.tunable(id)\n\t\tif (!def || !Number.isFinite(value)) return\n\t\tconst set = Math.min(Math.max(value, def.min), def.max)\n\t\tthis.setState(tunings, { ...this.state(tunings), [id]: set })\n\t\tthis.events.emit(tunableChanged, { id, value: set })\n\t}\n\n\t/**\n\t * Changes a definition while the game runs (S61): a unit type's health, an ability's cooldown, as the editor's Data\n\t * 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\n\t * take it at once, with as much of their health lost as before. Kept with the world and in its save, and said\n\t * (`definitionChanged`). False for a definition the game does not have. Not held to what the game lets be changed\n\t * (`Rules.editable`), as `layData` and a map's definitions are: any field is taken. The check is the command's that\n\t * the Data panel sends (`redefineCommand`); code that calls this says what it allows itself\n\t *\n\t * @beta\n\t */\n\tredefine(kind: DataKind, id: string, values: DataValues): boolean {\n\t\tif (!redefineIn(this.registry, kind, id, values)) return false\n\t\tconst kept = this.state(redefinitions)\n\t\tconst before = kept[kind] ?? {}\n\t\tthis.setState(redefinitions, { ...kept, [kind]: { ...before, [id]: mergeValues(before[id] ?? {}, values) } })\n\t\tif (kind === 'units') this.retype(new Set([id]))\n\t\tthis.events.emit(definitionChanged, { kind, id, values })\n\t\treturn true\n\t}\n\n\t/**\n\t * The units of these types take their type as the registry has it now, with as much of their health lost as\n\t * before: after it was changed (`redefine`, `reloadGame`). Every type when none are said\n\t *\n\t * @internal\n\t */\n\tretype(types?: ReadonlySet<string>): void {\n\t\tfor (const entity of this.entities.values()) {\n\t\t\tif (types && !types.has(entity.def.id)) continue\n\t\t\tconst def = definitionIn(this.registry, 'units', entity.def.id)\n\t\t\tif (!def || def === entity.def) continue\n\t\t\t// filed again, as a unit that turns into another type is: what it sells, what it is, may be other now\n\t\t\tthis.index.remove(entity)\n\t\t\tentity.retype(def)\n\t\t\tthis.index.add(entity)\n\t\t\tconst hurt = entity.maxHealth - entity.health\n\t\t\tentity.maxHealth = statsOf(this, entity).health\n\t\t\tif (entity.alive) entity.health = Math.max(entity.maxHealth - hurt, 1)\n\t\t}\n\t}\n\n\t/** State of a game module or a mod for the whole game: made from the component's default when first asked for */\n\tstate<T>(key: Component<T, unknown>): T {\n\t\t// one the game does not list is an error (`UnlistedError`)\n\t\tif (!this.registry.lists('component', key.id)) this.registry.used(key.id)\n\t\treturn this.states.get(key)\n\t}\n\n\t/** Sets the whole game's state for a component, replacing what `state` gives for it */\n\tsetState<T>(key: Component<T, unknown>, value: T): void {\n\t\tthis.states.set(key, value)\n\t}\n\n\t/** The game's numbers that are not about any one unit, like the supply cap (`Rules.settings`) */\n\tget settings(): Readonly<RuleSettings> {\n\t\treturn this.registry.settings\n\t}\n\n\t/**\n\t * Hour of the day, 0..24. Noon in a game without days (`clock.hour`)\n\t *\n\t * @beta\n\t */\n\tget hour(): number {\n\t\treturn this.clock.hour\n\t}\n\n\t/**\n\t * Whether the sun is down (`clock.night`): asked for every unit's sight and stats, many times a tick\n\t *\n\t * @beta\n\t */\n\tget night(): boolean {\n\t\treturn this.clock.night\n\t}\n\n\t/**\n\t * Unique id for orders, order groups and projectiles\n\t *\n\t * @beta\n\t */\n\tnewId(): number {\n\t\treturn this.nextId++\n\t}\n\n\t/** The player of this id; throws when there is none */\n\tplayer(id: PlayerId): Player {\n\t\tconst player = this.players.get(id)\n\t\tif (!player) throw new Error(`Unknown player ${id}`)\n\t\treturn player\n\t}\n\n\t/**\n\t * Whether an entity of this id was ever made here: one that died was, one of a number not yet given out never was\n\t *\n\t * @beta\n\t */\n\tmade(id: EntityId): boolean {\n\t\treturn Number.isInteger(id) && id >= 1 && id < this.nextEntityId\n\t}\n\n\t/** Living entity with this id */\n\tget(id: EntityId | undefined): Entity | undefined {\n\t\tif (!id) return undefined\n\t\tconst entity = this.entities.get(id)\n\t\treturn entity?.alive ? entity : undefined\n\t}\n\n\t/**\n\t * The entity of this name, while it lives: one named on the map in the editor, or in code. Nothing once it is\n\t * dead, or when there never was one. A game can say which names there are: `world.named<RoadNames>('gate')`\n\t */\n\tnamed<Name extends string = string>(name: Name): Entity | undefined {\n\t\treturn this.get(this.state(names)[name])\n\t}\n\n\t/**\n\t * The name an entity was given, if any\n\t *\n\t * @beta\n\t */\n\tnameOf(entity: Entity): string | undefined {\n\t\tconst all = this.state(names)\n\t\tfor (const name in all) if (all[name] === entity.id) return name\n\t\treturn undefined\n\t}\n\n\t/**\n\t * Names an entity, for the rules to find it by (`named`), or takes its name away with none. It has one name, and a\n\t * name is one entity's: taking that of another that still lives throws. The name of the dead is free\n\t *\n\t * @beta\n\t */\n\tsetName(entity: Entity, name: string | undefined): void {\n\t\tconst all = this.state(names)\n\t\tconst before = this.nameOf(entity)\n\t\tif (before === name) return\n\t\tif (name !== undefined) {\n\t\t\tconst holder = this.named(name)\n\t\t\tif (holder) throw new Error(`\"${name}\" is the name of ${holder.def.id}#${holder.id} already: ${entity.def.id}#${entity.id} cannot have it too`)\n\t\t\tall[name] = entity.id\n\t\t}\n\t\tif (before !== undefined) delete all[before]\n\t}\n\n\t/**\n\t * What the map this world was made from says that is not an entity: its name, and what the game kept with it\n\t * (`GameMap.data`). Kept in the world, so a save has it. Empty for a world made without a map\n\t */\n\tget map(): WorldMap {\n\t\treturn new WorldMap(this.state(mapInfo))\n\t}\n\n\t/** Whether two players fight each other (`sides.enemies`): asked of every target, every tick */\n\tareEnemies(a: PlayerId, b: PlayerId): boolean {\n\t\treturn this.sides.enemies(a, b)\n\t}\n\n\t/** Whether two players are on one side (`sides.allies`) */\n\tareAllies(a: PlayerId, b: PlayerId): boolean {\n\t\treturn this.sides.allies(a, b)\n\t}\n\n\t/**\n\t * Whether a player may command an entity (`sides.mayCommand`): what every command is checked against\n\t *\n\t * @beta\n\t */\n\tmayCommand(player: PlayerId, entity: Entity): boolean {\n\t\treturn this.sides.mayCommand(player, entity)\n\t}\n\n\t/**\n\t * Whether a team currently sees the entity (`sight.sees`): asked of every entity, team and snapshot\n\t *\n\t * @beta\n\t */\n\tisVisibleTo(entity: Entity, team: number): boolean {\n\t\treturn this.sight.sees(entity, team)\n\t}\n\n\t/**\n\t * Creates an entity. Structures are centered on the grid cells closest to `position`;\n\t * the caller is responsible for checking `grid.canPlace` when that matters.\n\t */\n\t/**\n\t * A prefab put down as one: its objects spawned for the owner given, its camps and areas with them, turned and sized\n\t * around its middle (`spawnPrefab`)\n\t *\n\t * @beta\n\t */\n\tspawnPrefab(prefab: PrefabDef | string, options: SpawnPrefabOptions): SpawnedPrefab {\n\t\treturn spawnPrefab(this, prefab, options)\n\t}\n\n\t/**\n\t * The neutral player, who owns what belongs to nobody (a soul, a mine, a tree): the first of them, the game's\n\t * `MAP_NEUTRAL`. Throws for a game that has none\n\t *\n\t * @beta\n\t */\n\tget neutral(): PlayerId {\n\t\tfor (const player of this.players.values()) if (player.neutral && !player.creeps) return player.id\n\t\tthrow new Error('The world has no neutral player')\n\t}\n\n\t/**\n\t * Puts a new entity of the unit type `typeId` into the world for `owner` at `at`, and returns it:\n\t * `world.spawn('footman', { at: { x: 10, z: 12 }, owner: 1 })`, with the rest of what it may start with\n\t * (`SpawnOptions`: `facing`, `name`, `lifetime`, `data`…) beside them\n\t */\n\tspawn(typeId: string, options: SpawnAt): Entity\n\t/** Puts a new entity of the unit type `typeId` into the world for `owner` at `position`, and returns it */\n\tspawn(typeId: string, owner: PlayerId, position: Vec2, options?: SpawnOptions): Entity\n\tspawn(typeId: string, owner: PlayerId | SpawnAt, position?: Vec2, options: SpawnOptions = {}): Entity {\n\t\tif (typeof owner === 'object') {\n\t\t\tconst { at, owner: player, ...rest } = owner\n\t\t\treturn this.spawning.spawn(typeId, player, at, rest)\n\t\t}\n\t\treturn this.spawning.spawn(typeId, owner, position!, options)\n\t}\n\n\t/**\n\t * What its parts call off as an entity leaves its owner, dying or given away (`Component.onLeave`)\n\t *\n\t * @internal\n\t */\n\tleave(entity: Entity): void {\n\t\tthis.spawning.leave(entity)\n\t}\n\n\t/**\n\t * Turns scenery into an actor, for good: something gave it a reason to be looked at every tick, like a buff\n\t * that has to run out. Whatever does that to an entity calls this; the debug checks catch what forgets to.\n\t *\n\t * @beta\n\t */\n\twake(entity: Entity): void {\n\t\tthis.spawning.wake(entity)\n\t}\n\n\t/**\n\t * Sets cells of one of the game's layers (`Terrain.cells`, `CellLayerDef`) to a value: by their indices, or those in\n\t * a shape. A bush burnt, grass grown. The players who see a cell are told at once (a `cells` event), the others as it\n\t * comes into their sight (`TeamMemory.cells`), and saves keep it. Returns the cells that changed\n\t */\n\t/**\n\t * Changes what the map looks like beyond its ground, as the game goes: a storm rolling in (`weather`), night mist\n\t * (`fog`), the sky going red. Over what it was, field by field; a field given as undefined goes back to none. Every\n\t * player sees it (an `environment` event), a save keeps it, and a player who joins later is told it as it is.\n\t *\n\t * `over` (seconds) has the screens ease into it, from what they show: the rain comes on, the wind gets up, the mist\n\t * thickens. The world has the new look at once: a save or a player who joins sees it as it ends\n\t */\n\tsetEnvironment(change: Partial<MapEnvironment>, options: { over?: number } = {}): void {\n\t\tconst info = this.state(mapInfo)\n\t\tconst environment: MapEnvironment = { ...info.environment }\n\t\tfor (const [key, value] of Object.entries(change) as [keyof MapEnvironment, unknown][]) {\n\t\t\tif (value === undefined) delete environment[key]\n\t\t\telse Object.assign(environment, { [key]: structuredClone(value) })\n\t\t}\n\t\tthis.setState(mapInfo, { ...info, environment })\n\t\tconst over = options.over && options.over > 0 ? options.over : undefined\n\t\tthis.events.emit(environmentChanged, { environment: structuredClone(environment), ...(over && { over }) })\n\t}\n\n\t/**\n\t * Plays one of the view's fx (`GameView.fx.defs`) on the screens of the players who see where it is, or those it is\n\t * for (`to`): at a place (`at`), or on an entity (`on`, at a `point` of its model), with knobs (`params`). Its random\n\t * parts go by a seed, the same on every screen. Nothing it does decides anything: it is not in the world's state, a\n\t * save, or what a player who joins later is told. What it gives back stops it (`stopFx`)\n\t *\n\t * @beta\n\t */\n\tfx(fx: string, options: FxOptions = {}): number {\n\t\treturn playFx(this, fx, options)\n\t}\n\n\t/**\n\t * Stops an fx the rules played (`fx`) on every screen, as its own `stop` says, over `fade` seconds\n\t *\n\t * @beta\n\t */\n\tstopFx(id: number, options: { fade?: number } = {}): void {\n\t\tstopFx(this, id, options)\n\t}\n\n\t/**\n\t * Sets the cells of a cell layer, given as indices or an area, to a value 0..255, and returns the cells that changed.\n\t * `over`: the seconds the screens that see them ease into the value over (grass growing back), told with the cells;\n\t * a screen told of them later, as they come into its sight, eases in as it can\n\t *\n\t * @beta\n\t */\n\tsetCells(layer: string, cells: readonly number[] | AreaShape, value: number, options: { over?: number } = {}): number[] {\n\t\tconst { terrain } = this\n\t\tif (!Number.isInteger(value) || value < 0 || value > 255) throw new Error(`setCells: ${value} is not a value a cell holds, 0 to 255`)\n\t\tconst values = terrain.cellLayer(layer)\n\t\tconst changed: number[] = []\n\t\tconst was: number[] = []\n\t\tfor (const c of Array.isArray(cells) ? cells : cellsIn(terrain, cells as AreaShape)) {\n\t\t\tif (c < 0 || c >= values.length || values[c] === value) continue\n\t\t\twas.push(values[c])\n\t\t\tvalues[c] = value\n\t\t\tchanged.push(c)\n\t\t}\n\t\tif (!changed.length) return changed\n\t\t// what each team that does not see a cell knew of it, for it to be told as it comes into sight (RV7)\n\t\trememberUnseenCells(this, layer, changed, was, value)\n\t\tconst { over } = options\n\t\tthis.events.emit(cellsChanged, { layer, cells: changed, value, ...(over !== undefined && over > 0 && { over }) })\n\t\treturn changed\n\t}\n\n\t/**\n\t * Reshapes a part of the ground as the game goes (`TerrainPatch`): its heights, cliffs, water, paint, what is kept\n\t * 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\n\t * played (`debug.ground`, EQ10). What the rules go by follows: who sees whom from the levels, where can be built, and\n\t * the ways, cut again of the ground as it is now (`Navigation.reshape`: on this thread, every machine the same; only\n\t * the tiles of the ways the patch reaches, a few milliseconds for a field, where the ground is still cut on the same\n\t * grid, else all of them, which is not for nothing on a big map). What stands on it stays where it is. Every player\n\t * is told (a `ground` event), and saves keep it. Throws where the patch does not fit the ground (`terrainPatchProblem`)\n\t *\n\t * @beta\n\t */\n\treshapeGround(patch: TerrainPatch): void {\n\t\tapplyTerrainPatch(this.terrain, patch)\n\t\tthis.fog.levelsChanged()\n\t\tthis.grid.groundChanged(patch)\n\t\t// the part that changed: only what it reaches cut again, where the navigation can\n\t\tconst area = { x: patch.x, z: patch.z, width: patch.width, depth: patch.depth }\n\t\tthis.nav.reshape?.(area)\n\t\tthis.sidePaths?.reshape(area)\n\t\tthis.events.emit(groundReshaped, { patch })\n\t}\n\n\t/**\n\t * Lets a team see a spot for a while, with nothing standing there\n\t *\n\t * @beta\n\t */\n\treveal(team: number, point: Vec2, radius: number, seconds: number, options: { quiet?: boolean } = {}): Reveal {\n\t\tconst reveal: Reveal = { id: this.nextId++, team, x: point.x, z: point.z, radius, left: seconds, ...(options.quiet && { quiet: true }) }\n\t\tthis.reveals.push(reveal)\n\t\treturn reveal\n\t}\n\n\t/** Puts a unit somewhere else, where it stands: the way through is not its concern. Structures stay where they were built */\n\tplace(entity: Entity, point: Vec2): void {\n\t\tthis.spawning.place(entity, point)\n\t}\n\n\t/**\n\t * Gives an entity to another player, from now on in everything: whose it is, whom it fights, what it counts for.\n\t * What it was doing is called off, and what it was making is given back to the one it belonged to\n\t */\n\tsetOwner(entity: Entity, owner: PlayerId): void {\n\t\tthis.spawning.setOwner(entity, owner)\n\t}\n\n\t/**\n\t * Takes a unit out of the world for a while, or puts it back: a worker inside a gold mine, a unit carried in\n\t * something. While hidden it is not found, not seen and in nobody's way, and its orders wait. It comes back at\n\t * `at`, or where it went in, on the nearest ground it can stand on. Structures cannot hide\n\t *\n\t * @beta\n\t */\n\tsetHidden(entity: Entity, hidden: boolean, at?: Vec2): void {\n\t\tthis.spawning.setHidden(entity, hidden, at)\n\t}\n\n\t/**\n\t * Gives an entity a time after which it is gone by itself, like a ward, or takes it away with `null`\n\t *\n\t * @beta\n\t */\n\tsetLifetime(entity: Entity, seconds: number | null): void {\n\t\tthis.spawning.setLifetime(entity, seconds)\n\t}\n\n\t/** Deals damage (`life.damage`): the hooks, armor and shields, health, death */\n\tdamage(target: Entity, amount: number, source?: Entity, options: DamageOptions = {}): void {\n\t\tthis.life.damage(target, amount, source, options)\n\t}\n\n\t/** Heals (`life.heal`): how much it healed */\n\theal(target: Entity, amount: number, source?: Entity): number {\n\t\treturn this.life.heal(target, amount, source)\n\t}\n\n\t/** Kills (`life.kill`) */\n\tkill(entity: Entity, killer?: Entity, attack = false, reason: DeathReason = 'killed'): void {\n\t\tthis.life.kill(entity, killer, attack, reason)\n\t}\n\n\t/**\n\t * Tells a player something, like why what they asked for cannot be done. The world says which message,\n\t * and the player's screen finds the words for it (see `Message`). A bare string is a key without params\n\t */\n\tmessage(player: PlayerId, message: MessageRef, kind: MessageKind = 'error'): void {\n\t\tconst said = toMessage(message)\n\t\t// told while a command of theirs is carried out: why it was refused\n\t\tconst { handling } = this\n\t\tif (handling && handling.player === player && kind === 'error') handling.refusal ??= said\n\t\tthis.events.emit(messageSent, { player, message: said, kind })\n\t}\n\n\t/**\n\t * Gives a player a hint (campaign plan CP5): a message of the kind `hint`, shown for `seconds` (the screen's own\n\t * time when left out), which a player who turned hints off in the settings does not see\n\t *\n\t * @beta\n\t */\n\thint(player: PlayerId, message: MessageRef, options: { seconds?: number } = {}): void {\n\t\tconst said: WorldEvents['messageSent'] = { player, message: toMessage(message), kind: 'hint' }\n\t\tif (options.seconds !== undefined) said.seconds = options.seconds\n\t\tthis.events.emit(messageSent, said)\n\t}\n\n\t/**\n\t * The command being carried out, to find out whether it was refused: see `executeCommand`\n\t *\n\t * @beta\n\t */\n\thandling?: { player: PlayerId; refusal: Message | undefined }\n\n\t/**\n\t * What a save needs that is the world's own business: id counters, the clock and the commands waiting for\n\t * the next tick. For `saveWorld` and `loadWorld` only\n\t *\n\t * @beta\n\t */\n\tinternals(): WorldInternals {\n\t\treturn {\n\t\t\tnextEntityId: this.nextEntityId,\n\t\t\tnextId: this.nextId,\n\t\t\tclockShift: this.clock.shift,\n\t\t\t...(this.clock.still !== undefined && { stillHour: this.clock.still }),\n\t\t\tcommands: this.commands,\n\t\t\t...(this.life.dead.length > 0 && { dead: this.life.dead.map((entity) => entity.id) })\n\t\t}\n\t}\n\n\t/**\n\t * Puts back what `internals` gave, for `loadWorld` only\n\t *\n\t * @beta\n\t */\n\trestoreInternals(internals: WorldInternals): void {\n\t\tthis.nextEntityId = internals.nextEntityId\n\t\tthis.nextId = internals.nextId\n\t\tthis.clock.shift = internals.clockShift\n\t\tthis.clock.still = internals.stillHour\n\t\tthis.commands = [...internals.commands]\n\t\t// the dead are found once the entities are back: see `restoreDead`\n\t}\n\n\t/**\n\t * Puts back who died and waits to be taken out (`WorldInternals.dead`), once the entities are back. For `loadWorld` only\n\t *\n\t * @beta\n\t */\n\trestoreDead(ids: readonly EntityId[]): void {\n\t\tfor (const id of ids) {\n\t\t\tconst entity = this.entities.get(id)\n\t\t\tif (!entity) throw new Error(`Save: the dead ${id} is not in it`)\n\t\t\tthis.life.dead.push(entity)\n\t\t}\n\t}\n\n\t/**\n\t * Queues a player command. It is applied at the start of the next tick; talk (a command whose def says\n\t * `outsideTick`: chat, a ping) given between ticks is carried out at once, a paused game's too (RV14)\n\t */\n\tissue(command: IssuedCommand): void {\n\t\tif (!this.stepping && typeof command?.type === 'string' && this.registry.command(command.type)?.outsideTick) {\n\t\t\t// kept by what records the game where it was given, and carried out there again by its replay\n\t\t\tfor (const watcher of this.watchers) watcher.command?.(command)\n\t\t\texecuteCommand(this, command)\n\t\t\treturn\n\t\t}\n\t\tif (!this.stepping && typeof command?.player === 'number') {\n\t\t\tconst given = (this.given.get(command.player) ?? 0) + 1\n\t\t\tthis.given.set(command.player, given)\n\t\t\tif (given > this.commandLimit) {\n\t\t\t\tthis.overLimit.set(command.player, (this.overLimit.get(command.player) ?? 0) + 1)\n\t\t\t\tif (typeof command.seq === 'number') this.overLimitSeqs.push({ player: command.player, seq: command.seq })\n\t\t\t\treturn\n\t\t\t}\n\t\t}\n\t\tthis.commands.push(command)\n\t\t// one given from outside a tick is a player's: what a replay of commands keeps. One given in a tick (a computer\n\t\t// player's, a script's) the tick gives again when it runs again\n\t\tif (!this.stepping) for (const watcher of this.watchers) watcher.command?.(command)\n\t}\n\n\t/**\n\t * Whether a debug command (`debug.*`) waits for a tick: a game paused by `debug.speed` runs the tick it takes, or\n\t * nothing of the debug tools would be done again, the command to go on included\n\t *\n\t * @internal\n\t */\n\tget debugWaiting(): boolean {\n\t\treturn this.commands.some((command) => typeof command?.type === 'string' && command.type.startsWith('debug.'))\n\t}\n\n\t/** What watches the world from outside (`watch`) */\n\tprivate readonly watchers = new Set<WorldWatcher>()\n\n\t/**\n\t * Watches the world from outside, for what records it (a replay of commands, `recordGame`): each command a player\n\t * gives it, each save taken of it, each tick. Changes nothing. Gives what stops watching\n\t *\n\t * @beta\n\t */\n\twatch(watcher: WorldWatcher): () => void {\n\t\tthis.watchers.add(watcher)\n\t\treturn () => void this.watchers.delete(watcher)\n\t}\n\n\t/**\n\t * A save of the world was taken, which put its crowd back (`saveWorld`): told to what watches it. The engine's\n\t *\n\t * @beta\n\t */\n\tsaved(): void {\n\t\tfor (const watcher of this.watchers) watcher.saved?.()\n\t}\n\n\t/** Advances the simulation by one fixed tick */\n\t/**\n\t * The entities that are all of what is asked, for scripts: whose they are, of which type, in which area. Only the\n\t * living, unless asked. A new list: for what runs every tick, go through `index` or `areas` instead; by place and condition, `query`\n\t */\n\tfind(filter: { owner?: PlayerId; type?: string; area?: string; dead?: boolean } = {}): Entity[] {\n\t\tconst from =\n\t\t\tfilter.area !== undefined\n\t\t\t\t? this.areas.inside(filter.area)\n\t\t\t\t: filter.owner !== undefined\n\t\t\t\t\t? this.index.ownedBy(filter.owner)\n\t\t\t\t\t: this.entities.values()\n\t\tconst found: Entity[] = []\n\t\tfor (const entity of from) {\n\t\t\tif (filter.owner !== undefined && entity.owner !== filter.owner) continue\n\t\t\tif (filter.type !== undefined && entity.def.id !== filter.type) continue\n\t\t\tif (!filter.dead && !entity.alive) continue\n\t\t\tfound.push(entity)\n\t\t}\n\t\treturn found\n\t}\n\n\t/**\n\t * What in the world is all a query asks (`WorldQuery`): around a point or a unit (`near`, `radius`), in an area, of\n\t * whom, of which type, kind and layer, what it carries and how hurt it is (`UnitCondition`), what a player sees, or\n\t * code (`where`); in an order (`sort`: `nearest`, `lowestHealthShare`, `random`…), as many as `limit` says. A new list:\n\t * `world.query({ near: hero, radius: 8, is: 'enemy', healthBelow: 0.3, sort: 'nearest', limit: 3 })`\n\t *\n\t * @beta\n\t */\n\tquery(query: WorldQuery = {}): Entity[] {\n\t\treturn queryWorld(this, query)\n\t}\n\n\t/**\n\t * Marks a moment to start again from, like the start of a wave, with what the player is told it is (\"Wave 6\").\n\t * A session keeps a save of the world as it is at the end of this tick, for \"Retry from wave 6\"\n\t */\n\tcheckpoint(label: MessageRef): void {\n\t\tthis.events.emit(checkpoint, { label: toMessage(label) })\n\t}\n\n\t/**\n\t * Steps the world one tick; does nothing once the game failed. In this order:\n\t *\n\t * 1. The commands sent since the last tick are carried out.\n\t * 2. Units are filed by where they stand (`spatial`).\n\t * 3. The systems run, phase by phase (`commands`, `decide`, `move`, `resolve`, `cleanup`).\n\t * 4. The dead are taken out of the world (`remove` hook, `entityRemoved`).\n\t * 5. `tick` goes up by one.\n\t * 6. The tick's events go out to listeners (`world.events.on`), held until now.\n\t *\n\t * So a listener runs after the tick is over: `world.tick` is already the next one, and an entity that died this\n\t * tick is no longer in `world.entities` (the event still carries it; a fallen hero waiting to be brought back\n\t * stays). Hooks run at once, inside the tick, where\n\t * what they are asked about happens\n\t */\n\tstep(): void {\n\t\t// a game that ended on an error stays as it was: nothing of it runs again\n\t\tif (this.failure) return\n\t\tthis.events.hold()\n\t\tthis.stepping = true\n\t\ttry {\n\t\t\tthis.advance()\n\t\t} catch (error) {\n\t\t\t// the tick a game ends in is left where it failed (`caught`): everything else goes on to whoever stepped\n\t\t\tif (!(error instanceof GameEnded)) throw error\n\t\t} finally {\n\t\t\ttry {\n\t\t\t\t// what happened goes out now that the tick is over\n\t\t\t\tthis.events.release()\n\t\t\t} catch (error) {\n\t\t\t\tif (!(error instanceof GameEnded)) throw error\n\t\t\t} finally {\n\t\t\t\tthis.stepping = false\n\t\t\t}\n\t\t}\n\t\t// what the tick's changes of the ground asked of the ways (a slowing layer painted, the ground reshaped), done\n\t\t// together where nothing asked of them since did it: none of it left for between ticks (a save, a screen)\n\t\tthis.nav.settleGround?.()\n\t\tthis.sidePaths?.settleGround()\n\t\tif (this.failure && !this.toldFailure) {\n\t\t\tthis.toldFailure = true\n\t\t\tthis.events.emit(worldFailed, this.failure)\n\t\t}\n\t\tfor (const watcher of this.watchers) watcher.stepped?.()\n\t}\n\n\t/**\n\t * What a part of the game that threw comes to, by what the world says of errors (`errorPolicy`). It returns when\n\t * the part is to be switched off or let go (`disable`): the caller does that, and goes on. It throws otherwise: the\n\t * error itself (`throw`), or what leaves the tick of a game that ends there (`end`)\n\t *\n\t * @beta\n\t */\n\tcaught(error: unknown, where: ErrorSite): void {\n\t\t// already answered further in: a game ending, or an error on its way out\n\t\tif (error instanceof GameEnded) throw error\n\t\tconst judged = typeof error === 'object' && error !== null\n\t\tif (judged && this.thrown.has(error)) throw error\n\t\tconst policy = this.errorPolicy ?? 'throw'\n\t\t// whose it is, in a game with mods\n\t\tconst mod = modOfPart(this.registry.module, where)\n\t\tif (mod) where = { ...where, mod }\n\t\tlet answer = typeof policy === 'function' ? policy(error, where, this) : policy\n\t\t// outside a tick there is no tick to leave: whoever called the world is told\n\t\tif (answer === 'end' && !this.stepping) answer = 'throw'\n\t\tif (answer === 'throw') {\n\t\t\tif (judged) this.thrown.add(error)\n\t\t\tthrow error\n\t\t}\n\t\tconst fields = { ...where, error: errorFields(error) }\n\t\tif (answer === 'disable') {\n\t\t\tconst kept =\n\t\t\t\twhere.kind === 'order' ? 'the order is taken off the unit' : where.kind === 'command' ? 'the command is refused' : 'it is switched off'\n\t\t\tthis.log.error('game', `${siteWords(where)} threw: ${kept}, and the game goes on`, fields)\n\t\t\tif (where.kind !== 'order' && where.kind !== 'command') this.disabled.set(siteKey(where), siteOf(where))\n\t\t\treturn\n\t\t}\n\t\tthis.failure = { message: `The game stopped: ${siteWords(where)} failed`, where, error: errorFields(error), tick: this.tick }\n\t\tthis.log.error('game', `${siteWords(where)} threw: the game ends`, fields)\n\t\tthrow new GameEnded(this.failure)\n\t}\n\n\t/**\n\t * Switches off the parts a save says were (`world.disabled`): the same game goes on as the one that was saved\n\t *\n\t * @beta\n\t */\n\tdisable(sites: Iterable<ErrorSite>): void {\n\t\tfor (const site of sites) {\n\t\t\tthis.disabled.set(siteKey(site), siteOf(site))\n\t\t\tif (site.kind === 'system') this.scheduler.disable(site.id)\n\t\t\telse if (site.kind === 'hook') this.hooks.remove(site.hook as AnyHook, site.id)\n\t\t}\n\t}\n\n\tprivate advance(): void {\n\t\tif (this.checks.scenery) this.checkScenery()\n\t\tif (this.checks.index) this.index.check(this.entities.values())\n\t\t// where everything stood at the start of the tick: the renderer draws in between this and where it ends up\n\t\tfor (const entity of this.units.values()) {\n\t\t\tentity.prevPos.x = entity.pos.x\n\t\t\tentity.prevPos.z = entity.pos.z\n\t\t\tentity.prevFacing = entity.facing\n\t\t}\n\n\t\tthis.given.clear()\n\t\tif (this.overLimit.size) {\n\t\t\tfor (const [player, count] of this.overLimit)\n\t\t\t\tthis.events.emit(commandRejected, {\n\t\t\t\t\tplayer,\n\t\t\t\t\tkind: 'tooMany',\n\t\t\t\t\treason: `tooManyCommands: ${count} past the ${this.commandLimit} a tick takes`\n\t\t\t\t})\n\t\t\tthis.overLimit.clear()\n\t\t}\n\t\tif (this.commands.length) {\n\t\t\tconst commands = this.commands\n\t\t\tthis.commands = []\n\t\t\tfor (const command of commands) executeCommand(this, command)\n\t\t}\n\t\t// and each let go that its sender numbered is answered, refused, after those taken\n\t\tif (this.overLimitSeqs.length) {\n\t\t\tfor (const { player, seq } of this.overLimitSeqs) this.events.emit(commandHandled, { player, seq, refusal: { key: 'tooManyCommands' } })\n\t\t\tthis.overLimitSeqs.length = 0\n\t\t}\n\n\t\tthis.spatial.rebuild(this.units.values())\n\t\tthis.scheduler.run(this)\n\n\t\tif (this.life.dead.length) {\n\t\t\tfor (const entity of this.life.dead) {\n\t\t\t\tthis.entities.delete(entity.id)\n\t\t\t\tthis.units.delete(entity.id)\n\t\t\t\tthis.index.remove(entity)\n\t\t\t\tthis.hooks.run('remove', entity)\n\t\t\t\tthis.events.emit(entityRemoved, entity)\n\t\t\t}\n\t\t\tthis.life.dead.length = 0\n\t\t}\n\t\tthis.tick++\n\t}\n\n\t/** Throws when scenery has something that only units get looked after for. See `debugChecks` */\n\tprivate checkScenery(): void {\n\t\tfor (const entity of this.entities.values()) {\n\t\t\tif (!entity.scenery || !entity.alive) continue\n\t\t\tconst problem =\n\t\t\t\t(!isScenery(entity.def) && 'a type that is not scenery') ||\n\t\t\t\t(!this.player(entity.owner).neutral && 'an owner') ||\n\t\t\t\t(entity.buffs.length > 0 && 'buffs') ||\n\t\t\t\t(entity.orders.length > 0 && 'orders') ||\n\t\t\t\t(entity.hidden && 'been hidden') ||\n\t\t\t\t(entity.get(dashing) && 'a dash') ||\n\t\t\t\t(entity.has(constructionSite) && 'a construction site') ||\n\t\t\t\t(entity.expires !== null && 'a lifetime') ||\n\t\t\t\t((entity.has(exposure) || entity.has(detection)) && 'been exposed or detected')\n\t\t\tif (problem) throw new Error(`Scenery ${entity.def.id}#${entity.id} has ${problem}, but nothing woke it up (World.wake)`)\n\t\t}\n\t}\n\n\t/**\n\t * Whether it was disposed: its navigation is freed, and it is not to be stepped again\n\t *\n\t * @beta\n\t */\n\tget disposed(): boolean {\n\t\treturn this.wasDisposed\n\t}\n\tprivate wasDisposed = false\n\n\t/**\n\t * Frees what the world holds outside of JavaScript's memory: its navigation (a navmesh, its tiles and its crowd, in\n\t * WebAssembly, which is never collected by itself). Whoever made the world disposes it once done with it: the\n\t * session that owns it (`LocalSession`'s `ownsWorld`), the host (`SessionHost`'s), a test. Once is enough: again does\n\t * nothing\n\t */\n\tdispose(): void {\n\t\tif (this.wasDisposed) return\n\t\tthis.wasDisposed = true\n\t\tthis.events.clear()\n\t\tthis.nav.dispose()\n\t\tthis.sidePaths?.dispose()\n\t\tthis.entities.clear()\n\t\tthis.units.clear()\n\t\tthis.index.clear()\n\t}\n}\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@v12-engine/engine",
-	"version": "0.1.0",
+	"version": "0.4.0",
 	"license": "MIT",
 	"publishConfig": {
 		"access": "public"
@@ -14,7 +14,7 @@
 	"sideEffects": [
 		"./src/server/navigation-worker.ts",
 		"./src/simulate-worker.ts",
-		"./dist/navigation-worker.js",
+		"./dist/server/navigation-worker.js",
 		"./dist/simulate-worker.js"
 	],
 	"description": "The simulation of a real-time strategy game: the world, units, orders, hooks, sessions, and a server. Runs anywhere",