@v12-engine/engine 0.1.1 → 0.4.0

package/dist/world.js

@@ -0,0 +1,1263 @@
+import { GameEnded, modOfPart, siteKey, siteOf, siteWords } from "./errors.js";
+import { isScenery } from "./defs.js";
+import { StateStore } from "./components.js";
+import { statsOf } from "./stats.js";
+import { Emitter } from "./events.js";
+import { cellsChanged, checkpoint, commandHandled, commandRejected, entityRemoved, environmentChanged, groundReshaped, messageSent, worldFailed } from "./engineEvents.js";
+import { constructionSite } from "./systems/construction.js";
+import { detection, exposure } from "./entity.js";
+import { Player } from "./player.js";
+import { toMessage } from "./messages.js";
+import { Hooks } from "./hooks.js";
+import { dashing } from "./dashing.js";
+import { queryWorld } from "./query.js";
+import { Areas } from "./areas.js";
+import { WorldMap, mapInfo, names } from "./names.js";
+import { hasGroundSpeeds, slowsOnFoot, stopsOnFoot } from "./groundSpeed.js";
+import { checksOf } from "./debug2.js";
+import { Timers } from "./timers.js";
+import { Sequences, coreTimers } from "./sequences.js";
+import { cellsIn, rememberUnseenCells } from "./cellLayers.js";
+import { BuildGrid } from "./grid.js";
+import { settleRaces } from "./races.js";
+import { helpListeners } from "./orders/idle.js";
+import { executeCommand } from "./commands.js";
+import { Dialog } from "./dialog.js";
+import { playFx, stopFx } from "./effects.js";
+import { coreHooks } from "./features.js";
+import { errorFields, rootLogger } from "./log.js";
+import { definitionChanged, definitionIn, mergeValues, redefineIn, redefinitions } from "./gameData.js";
+import { Life } from "./life.js";
+import { Rng } from "./rng.js";
+import { Objectives } from "./objectives.js";
+import { applyTerrainPatch } from "./ground.js";
+import { Clock } from "./clock.js";
+import { Score } from "./score.js";
+import { tunableChanged, tunings } from "./tunables.js";
+import { FogOfWar } from "./fog.js";
+import { Sight } from "./sight.js";
+import { Sides } from "./sides.js";
+import { Spawning } from "./spawning.js";
+import { EntityIndex } from "./entityIndex.js";
+import { AirNavigation, LayeredNavigation } from "./navigation/air.js";
+import { Scheduler } from "./scheduler.js";
+import { Computers } from "./computers.js";
+import { SpatialIndex } from "./spatial.js";
+import { spawnPrefab } from "./prefabs.js";
+//#region src/world.ts
+/**
+* The simulation: the ground, entities, players, systems and rules of one game, stepped a tick at a time with `step`
+*
+* @public
+*/
+var World = class {
+	/**
+	* Obstacles the navigation had no room for (`RecastNavigationOptions.maxObstacles`): what is put down past it does not block the way
+	*
+	* @beta
+	*/
+	obstaclesRefused = 0;
+	/**
+	* The ground the world stands on
+	*
+	* @beta
+	*/
+	terrain;
+	/**
+	* The ground it started on, where it was made from a map (S36): what a save keeps only the changes of
+	*
+	* @beta
+	*/
+	ground;
+	/**
+	* The ground and the air. Agents find their own layer, everything else is about the ground
+	*
+	* @beta
+	*/
+	nav;
+	/**
+	* The navigations the sides plan their routes on, of the buildings each knows (`Rules.paths: 'seen'`): routes
+	* of ground units are planned on their side's, and walked on `nav`. None where routes know everything
+	*
+	* @beta
+	*/
+	sidePaths;
+	/** The ground, the air and the water, to find where a kind of unit can be */
+	layers;
+	/** 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 */
+	/**
+	* The ways a type of entity walks, flies or sails on (`navFor` for one made)
+	*
+	* @internal
+	*/
+	layerOf(def) {
+		return this.layers.layer(def);
+	}
+	/**
+	* An id for an entity about to be made (`Spawning`)
+	*
+	* @internal
+	*/
+	newEntityId() {
+		return this.nextEntityId++;
+	}
+	/**
+	* The navigation an entity walks by: the air, the water or the ground, by its layer
+	*
+	* @beta
+	*/
+	navFor(entity) {
+		return this.layers.layer(entity.def);
+	}
+	/**
+	* The air alone
+	*
+	* @beta
+	*/
+	air;
+	/** The game's definitions: unit types, abilities, orders and the rest */
+	registry;
+	/**
+	* Which cells are taken by buildings and what can be built where
+	*
+	* @beta
+	*/
+	grid;
+	/**
+	* What each team has seen and sees, per cell
+	*
+	* @beta
+	*/
+	fog;
+	/**
+	* Index of entities by position, for asking what is near a point.
+	*
+	* Units are filed once a tick, where they stand as it starts (after the commands, before the systems: `step`).
+	* A unit that moves during the tick (the `move` phase) is still filed where it was until the next, so a query in
+	* `resolve` searches by where units started and checks distance against where they are now: a unit that walked
+	* into range this tick may be found only the next. Structures are filed where they stand, as they are made
+	*
+	* @beta
+	*/
+	spatial;
+	/** What happened, for whoever watches: sessions, tests. Sent out at the end of each tick. Rules use `hooks` */
+	events = new Emitter();
+	/**
+	* What this world says about what it does: `world.log.warn('waves', 'nothing to send', { wave })`. Each entry says
+	* the game and the tick it is from, and goes to whoever asked (`world.log.to(sink)`) and to the logger the world
+	* was made under. It changes nothing in the world, and is not in a save
+	*/
+	log;
+	/**
+	* The engine's checks on itself this world runs (`DebugChecks`): what it was made with (`CreateWorldOptions.checks`),
+	* the process's (`setDebugChecks`) when it says nothing. Slow: tests and development
+	*
+	* @beta
+	*/
+	checks = checksOf(void 0);
+	/**
+	* Moved on by `invalidateStats` without an entity: every entity's stats are added up again when next asked for
+	*
+	* @beta
+	*/
+	statsVersion = 0;
+	/**
+	* What the debug tools follow of the rules as they run: hooks and listeners. Null when nobody asks, see `EventLog`
+	*
+	* @beta
+	*/
+	trace = null;
+	/** Where game modules and mods take part in damage, deaths, orders and the like, see `HookEvents` */
+	hooks;
+	/** The areas of the game, and who is in them */
+	areas;
+	/** What is set to go off later: `world.timers.after(30, waveComes)` */
+	timers;
+	/** Scripts of steps that run over time: `world.sequences.start(briefing)` */
+	sequences;
+	/** What each player is set to do, in a mission */
+	objectives;
+	/**
+	* What the game counts of its players (`RuleSettings.score`): `world.score.add(player, 'towersLost')`, `get`, `team`.
+	* Counts nothing in a game that does not ask
+	*
+	* @beta
+	*/
+	score;
+	/** What is said, by whom, to whom: `world.dialog.say(player, line)`, or `talk` in a sequence */
+	dialog;
+	/** The world's seeded random generator; the only source of randomness the simulation uses */
+	rng;
+	/** Every player of the world, by id */
+	players = /* @__PURE__ */ new Map();
+	/**
+	* Everything in the world, by id. Fallen heroes stay in here while they wait to be brought back
+	*
+	* @beta
+	*/
+	entities = /* @__PURE__ */ new Map();
+	/**
+	* The entities that act: the ones that move, fight, build or change by themselves, which is everything but scenery.
+	* Systems that run every tick go through these instead of `entities`, which on a big map is mostly trees.
+	*
+	* In the order each became a unit, which is the order of ids except for scenery woken later (`Spawning.wake`: a
+	* tree given a buff), which comes last, after units made before it. A save keeps this order, so a loaded world
+	* walks it the same. A component's index (`EntityIndex`, `SystemDef.over`) walks in id order instead, so code that
+	* picks the first of equals breaks the tie by id, not by which it met first, to stay the same either way
+	*/
+	units = /* @__PURE__ */ new Map();
+	/**
+	* The scenery each team sees right now, by team. Kept by the fog system whenever it works out what everyone sees:
+	* scenery never moves, so this only changes then. Lets a session describe what is in sight without testing every tree
+	*
+	* @beta
+	*/
+	sceneryInSight = /* @__PURE__ */ new Map();
+	/**
+	* Entities by owner, heroes by owner, shops. For questions that would otherwise go through every entity
+	*
+	* @beta
+	*/
+	index = new EntityIndex((id) => this.registry.used(id), () => this);
+	/**
+	* The shots in flight
+	*
+	* @beta
+	*/
+	projectiles = [];
+	/**
+	* The missiles in flight
+	*
+	* @beta
+	*/
+	missiles = [];
+	/**
+	* Effects waiting for their time to come
+	*
+	* @beta
+	*/
+	delayed = [];
+	/**
+	* The zones that are working on the ground now
+	*
+	* @beta
+	*/
+	zones = [];
+	/**
+	* Switches for trying things out. A game that is played for real leaves them off
+	*
+	* @beta
+	*/
+	cheats = {
+		/** Abilities and what is carried can be used again at once */
+		noCooldowns: false,
+		/** Abilities cost no mana, and are cast with none left */
+		noManaCosts: false,
+		/** What the players allowed the debug tools own (`debugPlayers`) takes no harm, and so does not die of it */
+		invulnerable: false,
+		/** How fast the game goes, 1 as it should, 0 paused: whoever runs it (a session in the page, a server) goes by it */
+		speed: 1
+	};
+	/**
+	* Players who may use the debug commands (`debug.*`, see `debugCommands.ts`): who a session lets, a seat in the page
+	* that asked, a server started to. Not in a save: whoever loads it says again
+	*
+	* @beta
+	*/
+	debugPlayers = /* @__PURE__ */ new Set();
+	/**
+	* The entity each object of the map became, by the object's id (`MapObject.id`): what the map put down as the world
+	* was made of it (`createWorldFromMap`), and what the editor's Play here put down since (`debug.mapObject`), for the
+	* editor to find again what it moves and takes away (EQ10). Kept in a save
+	*
+	* @beta
+	*/
+	fromMap = /* @__PURE__ */ new Map();
+	/**
+	* Spots a team sees for a while without anything there to see them
+	*
+	* @beta
+	*/
+	reveals = [];
+	/**
+	* State of game modules and mods for the whole game, see `state`
+	*
+	* @beta
+	*/
+	states = new StateStore();
+	/**
+	* Items lying on the ground
+	*
+	* @beta
+	*/
+	items = [];
+	/**
+	* Runs the systems, in order, each as often as it asks
+	*
+	* @beta
+	*/
+	scheduler;
+	/** The computer players: who is seated, kept in a save and seated again by a load (`world.computers.seat`) */
+	computers;
+	/**
+	* What the world's numbers started from (`rng`): 1 when none was given. A computer player's own numbers start from it and its player
+	*
+	* @beta
+	*/
+	seed;
+	/** Simulation ticks per second */
+	tickRate;
+	/**
+	* Seconds per tick
+	*
+	* @beta
+	*/
+	dt;
+	/** The tick number the world is at, from 0; it goes up by one for each `step` */
+	tick = 0;
+	/**
+	* How things are hurt, healed and die (`Life`)
+	*
+	* @beta
+	*/
+	life = new Life(this);
+	/**
+	* What each team sees of the entities (`Sight`): the fog, what is invisible, the game's say
+	*
+	* @beta
+	*/
+	sight = new Sight(this);
+	/**
+	* Who is on whose side (`Sides`): teams, relations, shared vision and control
+	*
+	* @beta
+	*/
+	sides = new Sides(this);
+	/**
+	* How entities come into the world and are moved about in it (`Spawning`)
+	*
+	* @beta
+	*/
+	spawning = new Spawning(this);
+	/**
+	* The time of day (`Clock`): the hour, night, turned forward or stopped
+	*
+	* @beta
+	*/
+	clock = new Clock(this);
+	/** Team that won, once the game is decided */
+	winner = null;
+	/**
+	* What becomes of a part of the game that throws: a hook's handler, a listener, a system, a timer, an order, a
+	* command (`ErrorPolicy`). The game's own (`Rules.onError`), or whoever runs the world's; with neither it
+	* throws, as it always did. A server and a launched game end the game where nothing is said (`??= 'end'`)
+	*
+	* @beta
+	*/
+	errorPolicy;
+	/**
+	* Why the game ended on an error, once it has (`end`): the world is not stepped again
+	*
+	* @beta
+	*/
+	failure = null;
+	/**
+	* The parts switched off for having thrown (`disable`), by name (`siteKey`): kept in a save, and off again when it is loaded
+	*
+	* @beta
+	*/
+	disabled = /* @__PURE__ */ new Map();
+	/** True through a tick: an error then can end the game; outside one it is whoever called's */
+	stepping = false;
+	toldFailure = false;
+	/** Errors already answered `throw` further in: not asked about again on their way out */
+	thrown = /* @__PURE__ */ new WeakSet();
+	nextEntityId = 1;
+	nextId = 1;
+	commands = [];
+	/** Commands each player gave since the last tick, from outside one: what `commandLimit` counts */
+	given = /* @__PURE__ */ new Map();
+	/** Commands let go since the last tick, by player: told of at the next (`commandRejected`) */
+	overLimit = /* @__PURE__ */ new Map();
+	/** Those of them the sender numbered: each answered at the next tick, refused (`commandHandled`), for a screen that waits on it */
+	overLimitSeqs = [];
+	/**
+	* Commands a player may give between two ticks, at most (`issue`, from outside a tick): those past it are let go,
+	* and the tick says so once (`commandRejected`, reason `tooManyCommands`), and answers each the sender numbered,
+	* refused (`commandHandled`). A server's rate limit keeps far under it; this bounds what has none (a worker, a
+	* page's own host, a script gone wrong). The computer and scripts, which give theirs in a tick, are not counted.
+	* 100 when left out; `Infinity` for none
+	*
+	* @beta
+	*/
+	commandLimit = 100;
+	/**
+	* Makes an empty world of the options' terrain, rules and players; a game makes one with `createWorld` or
+	* `createWorldFromMap`, which also place the map's things and start the rules
+	*
+	* @beta
+	*/
+	constructor(options) {
+		this.terrain = options.terrain;
+		this.air = new AirNavigation(options.terrain.width, options.terrain.depth);
+		this.layers = new LayeredNavigation(options.navigation, this.air, options.waterNavigation);
+		this.nav = this.layers;
+		this.sidePaths = options.sidePaths;
+		this.registry = options.registry;
+		this.log = (options.log ?? rootLogger).child({
+			level: options.logLevel,
+			context: () => ({
+				game: this.registry.game,
+				tick: this.tick
+			})
+		});
+		this.registry.log = this.log;
+		this.errorPolicy = options.onError;
+		if (options.checks !== void 0) this.checks = checksOf(options.checks);
+		this.events.watch((type) => {
+			if (typeof type === "string" && !this.registry.lists("event", type)) this.registry.event(type);
+		});
+		this.hooks = new Hooks(this);
+		for (const hook of options.hooks ?? coreHooks) this.hooks.add(hook);
+		if (hasGroundSpeeds(this.registry)) this.events.on(cellsChanged, ({ layer, cells }) => {
+			if (!slowsOnFoot(this.registry, layer)) return;
+			const walkability = stopsOnFoot(this.registry, layer);
+			this.nav.groundChanged?.(cells, walkability);
+			this.sidePaths?.groundChanged(cells, walkability);
+		});
+		this.tickRate = options.tickRate ?? 30;
+		this.dt = 1 / this.tickRate;
+		this.seed = options.seed ?? 1;
+		this.rng = new Rng(this.seed);
+		this.computers = new Computers(this);
+		for (const init of options.players) this.players.set(init.id, new Player(init));
+		settleRaces(this.players.values(), this.registry, (count) => this.rng.int(0, count - 1), options.randomRaces);
+		this.grid = new BuildGrid(this.terrain);
+		const teams = /* @__PURE__ */ new Set();
+		for (const player of this.players.values()) if (!player.neutral) teams.add(player.team);
+		this.fog = new FogOfWar(this.terrain.width, this.terrain.depth, [], this.terrain.levels);
+		this.fog.exploredFromStart = !!this.settings.fog?.startExplored;
+		for (const team of teams) this.fog.addTeam(team);
+		this.spatial = new SpatialIndex(this.terrain.width, this.terrain.depth);
+		this.scheduler = new Scheduler(options.systems(this));
+		this.areas = new Areas(this, options.areas ?? []);
+		this.timers = new Timers(this, [...coreTimers, ...options.timers ?? []]);
+		this.sequences = new Sequences(this, options.sequences ?? []);
+		this.objectives = new Objectives(this);
+		this.dialog = new Dialog(this);
+		this.score = new Score(this);
+		const ids = /* @__PURE__ */ new Set();
+		for (const listener of [
+			...helpListeners,
+			...options.listeners ?? [],
+			...Sequences.listenersFor(options.sequences ?? [])
+		]) {
+			if (ids.has(listener.id)) throw new Error(`Listener "${listener.id}" is there twice`);
+			ids.add(listener.id);
+			const off = `listener:${listener.id}`;
+			this.events.on(listener.event, (payload) => {
+				if (this.disabled.size && this.disabled.has(off)) return;
+				this.trace?.listener(listener.id);
+				try {
+					listener.run(this, payload);
+				} catch (error) {
+					this.caught(error, {
+						kind: "listener",
+						id: listener.id
+					});
+				}
+			});
+		}
+	}
+	/**
+	* The systems, in the order they run
+	*
+	* @beta
+	*/
+	get systems() {
+		return this.scheduler.systems;
+	}
+	/**
+	* Adds a system to the running world, like a computer player. It takes its place by its phase, `before` and `after`
+	*
+	* @beta
+	*/
+	addSystem(system) {
+		this.scheduler.add(system);
+		const saved = this.savedSystems.get(system.name);
+		if (saved !== void 0 && system.restore) {
+			this.savedSystems.delete(system.name);
+			system.restore(this, saved);
+		}
+	}
+	/** What systems kept in themselves when the game was saved, for those not added yet */
+	savedSystems = /* @__PURE__ */ new Map();
+	/**
+	* Gives the systems what they kept in a save (see `System.save`): those there now, and those added later
+	*
+	* @beta
+	*/
+	restoreSystems(saved) {
+		this.savedSystems.clear();
+		for (const [name, data] of Object.entries(saved)) {
+			const system = this.systems.find((each) => each.name === name);
+			if (system?.restore) system.restore(this, data);
+			else this.savedSystems.set(name, data);
+		}
+	}
+	/**
+	* Takes a system out by name. False when there is none of that name
+	*
+	* @beta
+	*/
+	removeSystem(name) {
+		return this.scheduler.remove(name);
+	}
+	/** Seconds of game time that have passed: `tick` times `dt` */
+	get time() {
+		return this.tick * this.dt;
+	}
+	/**
+	* A number of the rules as it is tuned now (`TunableDef`): what it was set to while playing, or its default
+	*
+	* @beta
+	*/
+	tunable(id) {
+		const def = this.registry.tunable(id);
+		if (!def) throw new Error(`The game has no tunable "${id}"`);
+		return this.state(tunings)[id] ?? def.default;
+	}
+	/**
+	* Tunes a number of the rules, within its bounds, and says so (`tunableChanged`)
+	*
+	* @beta
+	*/
+	setTunable(id, value) {
+		const def = this.registry.tunable(id);
+		if (!def || !Number.isFinite(value)) return;
+		const set = Math.min(Math.max(value, def.min), def.max);
+		this.setState(tunings, {
+			...this.state(tunings),
+			[id]: set
+		});
+		this.events.emit(tunableChanged, {
+			id,
+			value: set
+		});
+	}
+	/**
+	* Changes a definition while the game runs (S61): a unit type's health, an ability's cooldown, as the editor's Data
+	* panel tries them. What is made of it from then on is made of the new one; a unit type's units already in the world
+	* take it at once, with as much of their health lost as before. Kept with the world and in its save, and said
+	* (`definitionChanged`). False for a definition the game does not have. Not held to what the game lets be changed
+	* (`Rules.editable`), as `layData` and a map's definitions are: any field is taken. The check is the command's that
+	* the Data panel sends (`redefineCommand`); code that calls this says what it allows itself
+	*
+	* @beta
+	*/
+	redefine(kind, id, values) {
+		if (!redefineIn(this.registry, kind, id, values)) return false;
+		const kept = this.state(redefinitions);
+		const before = kept[kind] ?? {};
+		this.setState(redefinitions, {
+			...kept,
+			[kind]: {
+				...before,
+				[id]: mergeValues(before[id] ?? {}, values)
+			}
+		});
+		if (kind === "units") this.retype(/* @__PURE__ */ new Set([id]));
+		this.events.emit(definitionChanged, {
+			kind,
+			id,
+			values
+		});
+		return true;
+	}
+	/**
+	* The units of these types take their type as the registry has it now, with as much of their health lost as
+	* before: after it was changed (`redefine`, `reloadGame`). Every type when none are said
+	*
+	* @internal
+	*/
+	retype(types) {
+		for (const entity of this.entities.values()) {
+			if (types && !types.has(entity.def.id)) continue;
+			const def = definitionIn(this.registry, "units", entity.def.id);
+			if (!def || def === entity.def) continue;
+			this.index.remove(entity);
+			entity.retype(def);
+			this.index.add(entity);
+			const hurt = entity.maxHealth - entity.health;
+			entity.maxHealth = statsOf(this, entity).health;
+			if (entity.alive) entity.health = Math.max(entity.maxHealth - hurt, 1);
+		}
+	}
+	/** State of a game module or a mod for the whole game: made from the component's default when first asked for */
+	state(key) {
+		if (!this.registry.lists("component", key.id)) this.registry.used(key.id);
+		return this.states.get(key);
+	}
+	/** Sets the whole game's state for a component, replacing what `state` gives for it */
+	setState(key, value) {
+		this.states.set(key, value);
+	}
+	/** The game's numbers that are not about any one unit, like the supply cap (`Rules.settings`) */
+	get settings() {
+		return this.registry.settings;
+	}
+	/**
+	* Hour of the day, 0..24. Noon in a game without days (`clock.hour`)
+	*
+	* @beta
+	*/
+	get hour() {
+		return this.clock.hour;
+	}
+	/**
+	* Whether the sun is down (`clock.night`): asked for every unit's sight and stats, many times a tick
+	*
+	* @beta
+	*/
+	get night() {
+		return this.clock.night;
+	}
+	/**
+	* Unique id for orders, order groups and projectiles
+	*
+	* @beta
+	*/
+	newId() {
+		return this.nextId++;
+	}
+	/** The player of this id; throws when there is none */
+	player(id) {
+		const player = this.players.get(id);
+		if (!player) throw new Error(`Unknown player ${id}`);
+		return player;
+	}
+	/**
+	* Whether an entity of this id was ever made here: one that died was, one of a number not yet given out never was
+	*
+	* @beta
+	*/
+	made(id) {
+		return Number.isInteger(id) && id >= 1 && id < this.nextEntityId;
+	}
+	/** Living entity with this id */
+	get(id) {
+		if (!id) return void 0;
+		const entity = this.entities.get(id);
+		return entity?.alive ? entity : void 0;
+	}
+	/**
+	* The entity of this name, while it lives: one named on the map in the editor, or in code. Nothing once it is
+	* dead, or when there never was one. A game can say which names there are: `world.named<RoadNames>('gate')`
+	*/
+	named(name) {
+		return this.get(this.state(names)[name]);
+	}
+	/**
+	* The name an entity was given, if any
+	*
+	* @beta
+	*/
+	nameOf(entity) {
+		const all = this.state(names);
+		for (const name in all) if (all[name] === entity.id) return name;
+	}
+	/**
+	* Names an entity, for the rules to find it by (`named`), or takes its name away with none. It has one name, and a
+	* name is one entity's: taking that of another that still lives throws. The name of the dead is free
+	*
+	* @beta
+	*/
+	setName(entity, name) {
+		const all = this.state(names);
+		const before = this.nameOf(entity);
+		if (before === name) return;
+		if (name !== void 0) {
+			const holder = this.named(name);
+			if (holder) throw new Error(`"${name}" is the name of ${holder.def.id}#${holder.id} already: ${entity.def.id}#${entity.id} cannot have it too`);
+			all[name] = entity.id;
+		}
+		if (before !== void 0) delete all[before];
+	}
+	/**
+	* What the map this world was made from says that is not an entity: its name, and what the game kept with it
+	* (`GameMap.data`). Kept in the world, so a save has it. Empty for a world made without a map
+	*/
+	get map() {
+		return new WorldMap(this.state(mapInfo));
+	}
+	/** Whether two players fight each other (`sides.enemies`): asked of every target, every tick */
+	areEnemies(a, b) {
+		return this.sides.enemies(a, b);
+	}
+	/** Whether two players are on one side (`sides.allies`) */
+	areAllies(a, b) {
+		return this.sides.allies(a, b);
+	}
+	/**
+	* Whether a player may command an entity (`sides.mayCommand`): what every command is checked against
+	*
+	* @beta
+	*/
+	mayCommand(player, entity) {
+		return this.sides.mayCommand(player, entity);
+	}
+	/**
+	* Whether a team currently sees the entity (`sight.sees`): asked of every entity, team and snapshot
+	*
+	* @beta
+	*/
+	isVisibleTo(entity, team) {
+		return this.sight.sees(entity, team);
+	}
+	/**
+	* Creates an entity. Structures are centered on the grid cells closest to `position`;
+	* the caller is responsible for checking `grid.canPlace` when that matters.
+	*/
+	/**
+	* A prefab put down as one: its objects spawned for the owner given, its camps and areas with them, turned and sized
+	* around its middle (`spawnPrefab`)
+	*
+	* @beta
+	*/
+	spawnPrefab(prefab, options) {
+		return spawnPrefab(this, prefab, options);
+	}
+	/**
+	* The neutral player, who owns what belongs to nobody (a soul, a mine, a tree): the first of them, the game's
+	* `MAP_NEUTRAL`. Throws for a game that has none
+	*
+	* @beta
+	*/
+	get neutral() {
+		for (const player of this.players.values()) if (player.neutral && !player.creeps) return player.id;
+		throw new Error("The world has no neutral player");
+	}
+	spawn(typeId, owner, position, options = {}) {
+		if (typeof owner === "object") {
+			const { at, owner: player, ...rest } = owner;
+			return this.spawning.spawn(typeId, player, at, rest);
+		}
+		return this.spawning.spawn(typeId, owner, position, options);
+	}
+	/**
+	* What its parts call off as an entity leaves its owner, dying or given away (`Component.onLeave`)
+	*
+	* @internal
+	*/
+	leave(entity) {
+		this.spawning.leave(entity);
+	}
+	/**
+	* Turns scenery into an actor, for good: something gave it a reason to be looked at every tick, like a buff
+	* that has to run out. Whatever does that to an entity calls this; the debug checks catch what forgets to.
+	*
+	* @beta
+	*/
+	wake(entity) {
+		this.spawning.wake(entity);
+	}
+	/**
+	* Sets cells of one of the game's layers (`Terrain.cells`, `CellLayerDef`) to a value: by their indices, or those in
+	* a shape. A bush burnt, grass grown. The players who see a cell are told at once (a `cells` event), the others as it
+	* comes into their sight (`TeamMemory.cells`), and saves keep it. Returns the cells that changed
+	*/
+	/**
+	* Changes what the map looks like beyond its ground, as the game goes: a storm rolling in (`weather`), night mist
+	* (`fog`), the sky going red. Over what it was, field by field; a field given as undefined goes back to none. Every
+	* player sees it (an `environment` event), a save keeps it, and a player who joins later is told it as it is.
+	*
+	* `over` (seconds) has the screens ease into it, from what they show: the rain comes on, the wind gets up, the mist
+	* thickens. The world has the new look at once: a save or a player who joins sees it as it ends
+	*/
+	setEnvironment(change, options = {}) {
+		const info = this.state(mapInfo);
+		const environment = { ...info.environment };
+		for (const [key, value] of Object.entries(change)) if (value === void 0) delete environment[key];
+		else Object.assign(environment, { [key]: structuredClone(value) });
+		this.setState(mapInfo, {
+			...info,
+			environment
+		});
+		const over = options.over && options.over > 0 ? options.over : void 0;
+		this.events.emit(environmentChanged, {
+			environment: structuredClone(environment),
+			...over && { over }
+		});
+	}
+	/**
+	* 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
+	* for (`to`): at a place (`at`), or on an entity (`on`, at a `point` of its model), with knobs (`params`). Its random
+	* parts go by a seed, the same on every screen. Nothing it does decides anything: it is not in the world's state, a
+	* save, or what a player who joins later is told. What it gives back stops it (`stopFx`)
+	*
+	* @beta
+	*/
+	fx(fx, options = {}) {
+		return playFx(this, fx, options);
+	}
+	/**
+	* Stops an fx the rules played (`fx`) on every screen, as its own `stop` says, over `fade` seconds
+	*
+	* @beta
+	*/
+	stopFx(id, options = {}) {
+		stopFx(this, id, options);
+	}
+	/**
+	* Sets the cells of a cell layer, given as indices or an area, to a value 0..255, and returns the cells that changed.
+	* `over`: the seconds the screens that see them ease into the value over (grass growing back), told with the cells;
+	* a screen told of them later, as they come into its sight, eases in as it can
+	*
+	* @beta
+	*/
+	setCells(layer, cells, value, options = {}) {
+		const { terrain } = this;
+		if (!Number.isInteger(value) || value < 0 || value > 255) throw new Error(`setCells: ${value} is not a value a cell holds, 0 to 255`);
+		const values = terrain.cellLayer(layer);
+		const changed = [];
+		const was = [];
+		for (const c of Array.isArray(cells) ? cells : cellsIn(terrain, cells)) {
+			if (c < 0 || c >= values.length || values[c] === value) continue;
+			was.push(values[c]);
+			values[c] = value;
+			changed.push(c);
+		}
+		if (!changed.length) return changed;
+		rememberUnseenCells(this, layer, changed, was, value);
+		const { over } = options;
+		this.events.emit(cellsChanged, {
+			layer,
+			cells: changed,
+			value,
+			...over !== void 0 && over > 0 && { over }
+		});
+		return changed;
+	}
+	/**
+	* Reshapes a part of the ground as the game goes (`TerrainPatch`): its heights, cliffs, water, paint, what is kept
+	* off it and the game's layers of cells, all at once, as the editor's Play here pushes the map's ground into the game
+	* played (`debug.ground`, EQ10). What the rules go by follows: who sees whom from the levels, where can be built, and
+	* the ways, cut again of the ground as it is now (`Navigation.reshape`: on this thread, every machine the same; only
+	* the tiles of the ways the patch reaches, a few milliseconds for a field, where the ground is still cut on the same
+	* grid, else all of them, which is not for nothing on a big map). What stands on it stays where it is. Every player
+	* is told (a `ground` event), and saves keep it. Throws where the patch does not fit the ground (`terrainPatchProblem`)
+	*
+	* @beta
+	*/
+	reshapeGround(patch) {
+		applyTerrainPatch(this.terrain, patch);
+		this.fog.levelsChanged();
+		this.grid.groundChanged(patch);
+		const area = {
+			x: patch.x,
+			z: patch.z,
+			width: patch.width,
+			depth: patch.depth
+		};
+		this.nav.reshape?.(area);
+		this.sidePaths?.reshape(area);
+		this.events.emit(groundReshaped, { patch });
+	}
+	/**
+	* Lets a team see a spot for a while, with nothing standing there
+	*
+	* @beta
+	*/
+	reveal(team, point, radius, seconds, options = {}) {
+		const reveal = {
+			id: this.nextId++,
+			team,
+			x: point.x,
+			z: point.z,
+			radius,
+			left: seconds,
+			...options.quiet && { quiet: true }
+		};
+		this.reveals.push(reveal);
+		return reveal;
+	}
+	/** Puts a unit somewhere else, where it stands: the way through is not its concern. Structures stay where they were built */
+	place(entity, point) {
+		this.spawning.place(entity, point);
+	}
+	/**
+	* Gives an entity to another player, from now on in everything: whose it is, whom it fights, what it counts for.
+	* What it was doing is called off, and what it was making is given back to the one it belonged to
+	*/
+	setOwner(entity, owner) {
+		this.spawning.setOwner(entity, owner);
+	}
+	/**
+	* Takes a unit out of the world for a while, or puts it back: a worker inside a gold mine, a unit carried in
+	* something. While hidden it is not found, not seen and in nobody's way, and its orders wait. It comes back at
+	* `at`, or where it went in, on the nearest ground it can stand on. Structures cannot hide
+	*
+	* @beta
+	*/
+	setHidden(entity, hidden, at) {
+		this.spawning.setHidden(entity, hidden, at);
+	}
+	/**
+	* Gives an entity a time after which it is gone by itself, like a ward, or takes it away with `null`
+	*
+	* @beta
+	*/
+	setLifetime(entity, seconds) {
+		this.spawning.setLifetime(entity, seconds);
+	}
+	/** Deals damage (`life.damage`): the hooks, armor and shields, health, death */
+	damage(target, amount, source, options = {}) {
+		this.life.damage(target, amount, source, options);
+	}
+	/** Heals (`life.heal`): how much it healed */
+	heal(target, amount, source) {
+		return this.life.heal(target, amount, source);
+	}
+	/** Kills (`life.kill`) */
+	kill(entity, killer, attack = false, reason = "killed") {
+		this.life.kill(entity, killer, attack, reason);
+	}
+	/**
+	* Tells a player something, like why what they asked for cannot be done. The world says which message,
+	* and the player's screen finds the words for it (see `Message`). A bare string is a key without params
+	*/
+	message(player, message, kind = "error") {
+		const said = toMessage(message);
+		const { handling } = this;
+		if (handling && handling.player === player && kind === "error") handling.refusal ??= said;
+		this.events.emit(messageSent, {
+			player,
+			message: said,
+			kind
+		});
+	}
+	/**
+	* Gives a player a hint (campaign plan CP5): a message of the kind `hint`, shown for `seconds` (the screen's own
+	* time when left out), which a player who turned hints off in the settings does not see
+	*
+	* @beta
+	*/
+	hint(player, message, options = {}) {
+		const said = {
+			player,
+			message: toMessage(message),
+			kind: "hint"
+		};
+		if (options.seconds !== void 0) said.seconds = options.seconds;
+		this.events.emit(messageSent, said);
+	}
+	/**
+	* The command being carried out, to find out whether it was refused: see `executeCommand`
+	*
+	* @beta
+	*/
+	handling;
+	/**
+	* What a save needs that is the world's own business: id counters, the clock and the commands waiting for
+	* the next tick. For `saveWorld` and `loadWorld` only
+	*
+	* @beta
+	*/
+	internals() {
+		return {
+			nextEntityId: this.nextEntityId,
+			nextId: this.nextId,
+			clockShift: this.clock.shift,
+			...this.clock.still !== void 0 && { stillHour: this.clock.still },
+			commands: this.commands,
+			...this.life.dead.length > 0 && { dead: this.life.dead.map((entity) => entity.id) }
+		};
+	}
+	/**
+	* Puts back what `internals` gave, for `loadWorld` only
+	*
+	* @beta
+	*/
+	restoreInternals(internals) {
+		this.nextEntityId = internals.nextEntityId;
+		this.nextId = internals.nextId;
+		this.clock.shift = internals.clockShift;
+		this.clock.still = internals.stillHour;
+		this.commands = [...internals.commands];
+	}
+	/**
+	* Puts back who died and waits to be taken out (`WorldInternals.dead`), once the entities are back. For `loadWorld` only
+	*
+	* @beta
+	*/
+	restoreDead(ids) {
+		for (const id of ids) {
+			const entity = this.entities.get(id);
+			if (!entity) throw new Error(`Save: the dead ${id} is not in it`);
+			this.life.dead.push(entity);
+		}
+	}
+	/**
+	* Queues a player command. It is applied at the start of the next tick; talk (a command whose def says
+	* `outsideTick`: chat, a ping) given between ticks is carried out at once, a paused game's too (RV14)
+	*/
+	issue(command) {
+		if (!this.stepping && typeof command?.type === "string" && this.registry.command(command.type)?.outsideTick) {
+			for (const watcher of this.watchers) watcher.command?.(command);
+			executeCommand(this, command);
+			return;
+		}
+		if (!this.stepping && typeof command?.player === "number") {
+			const given = (this.given.get(command.player) ?? 0) + 1;
+			this.given.set(command.player, given);
+			if (given > this.commandLimit) {
+				this.overLimit.set(command.player, (this.overLimit.get(command.player) ?? 0) + 1);
+				if (typeof command.seq === "number") this.overLimitSeqs.push({
+					player: command.player,
+					seq: command.seq
+				});
+				return;
+			}
+		}
+		this.commands.push(command);
+		if (!this.stepping) for (const watcher of this.watchers) watcher.command?.(command);
+	}
+	/**
+	* Whether a debug command (`debug.*`) waits for a tick: a game paused by `debug.speed` runs the tick it takes, or
+	* nothing of the debug tools would be done again, the command to go on included
+	*
+	* @internal
+	*/
+	get debugWaiting() {
+		return this.commands.some((command) => typeof command?.type === "string" && command.type.startsWith("debug."));
+	}
+	/** What watches the world from outside (`watch`) */
+	watchers = /* @__PURE__ */ new Set();
+	/**
+	* Watches the world from outside, for what records it (a replay of commands, `recordGame`): each command a player
+	* gives it, each save taken of it, each tick. Changes nothing. Gives what stops watching
+	*
+	* @beta
+	*/
+	watch(watcher) {
+		this.watchers.add(watcher);
+		return () => void this.watchers.delete(watcher);
+	}
+	/**
+	* A save of the world was taken, which put its crowd back (`saveWorld`): told to what watches it. The engine's
+	*
+	* @beta
+	*/
+	saved() {
+		for (const watcher of this.watchers) watcher.saved?.();
+	}
+	/** Advances the simulation by one fixed tick */
+	/**
+	* The entities that are all of what is asked, for scripts: whose they are, of which type, in which area. Only the
+	* living, unless asked. A new list: for what runs every tick, go through `index` or `areas` instead; by place and condition, `query`
+	*/
+	find(filter = {}) {
+		const from = filter.area !== void 0 ? this.areas.inside(filter.area) : filter.owner !== void 0 ? this.index.ownedBy(filter.owner) : this.entities.values();
+		const found = [];
+		for (const entity of from) {
+			if (filter.owner !== void 0 && entity.owner !== filter.owner) continue;
+			if (filter.type !== void 0 && entity.def.id !== filter.type) continue;
+			if (!filter.dead && !entity.alive) continue;
+			found.push(entity);
+		}
+		return found;
+	}
+	/**
+	* What in the world is all a query asks (`WorldQuery`): around a point or a unit (`near`, `radius`), in an area, of
+	* whom, of which type, kind and layer, what it carries and how hurt it is (`UnitCondition`), what a player sees, or
+	* code (`where`); in an order (`sort`: `nearest`, `lowestHealthShare`, `random`…), as many as `limit` says. A new list:
+	* `world.query({ near: hero, radius: 8, is: 'enemy', healthBelow: 0.3, sort: 'nearest', limit: 3 })`
+	*
+	* @beta
+	*/
+	query(query = {}) {
+		return queryWorld(this, query);
+	}
+	/**
+	* Marks a moment to start again from, like the start of a wave, with what the player is told it is ("Wave 6").
+	* A session keeps a save of the world as it is at the end of this tick, for "Retry from wave 6"
+	*/
+	checkpoint(label) {
+		this.events.emit(checkpoint, { label: toMessage(label) });
+	}
+	/**
+	* Steps the world one tick; does nothing once the game failed. In this order:
+	*
+	* 1. The commands sent since the last tick are carried out.
+	* 2. Units are filed by where they stand (`spatial`).
+	* 3. The systems run, phase by phase (`commands`, `decide`, `move`, `resolve`, `cleanup`).
+	* 4. The dead are taken out of the world (`remove` hook, `entityRemoved`).
+	* 5. `tick` goes up by one.
+	* 6. The tick's events go out to listeners (`world.events.on`), held until now.
+	*
+	* So a listener runs after the tick is over: `world.tick` is already the next one, and an entity that died this
+	* tick is no longer in `world.entities` (the event still carries it; a fallen hero waiting to be brought back
+	* stays). Hooks run at once, inside the tick, where
+	* what they are asked about happens
+	*/
+	step() {
+		if (this.failure) return;
+		this.events.hold();
+		this.stepping = true;
+		try {
+			this.advance();
+		} catch (error) {
+			if (!(error instanceof GameEnded)) throw error;
+		} finally {
+			try {
+				this.events.release();
+			} catch (error) {
+				if (!(error instanceof GameEnded)) throw error;
+			} finally {
+				this.stepping = false;
+			}
+		}
+		this.nav.settleGround?.();
+		this.sidePaths?.settleGround();
+		if (this.failure && !this.toldFailure) {
+			this.toldFailure = true;
+			this.events.emit(worldFailed, this.failure);
+		}
+		for (const watcher of this.watchers) watcher.stepped?.();
+	}
+	/**
+	* What a part of the game that threw comes to, by what the world says of errors (`errorPolicy`). It returns when
+	* the part is to be switched off or let go (`disable`): the caller does that, and goes on. It throws otherwise: the
+	* error itself (`throw`), or what leaves the tick of a game that ends there (`end`)
+	*
+	* @beta
+	*/
+	caught(error, where) {
+		if (error instanceof GameEnded) throw error;
+		const judged = typeof error === "object" && error !== null;
+		if (judged && this.thrown.has(error)) throw error;
+		const policy = this.errorPolicy ?? "throw";
+		const mod = modOfPart(this.registry.module, where);
+		if (mod) where = {
+			...where,
+			mod
+		};
+		let answer = typeof policy === "function" ? policy(error, where, this) : policy;
+		if (answer === "end" && !this.stepping) answer = "throw";
+		if (answer === "throw") {
+			if (judged) this.thrown.add(error);
+			throw error;
+		}
+		const fields = {
+			...where,
+			error: errorFields(error)
+		};
+		if (answer === "disable") {
+			const kept = where.kind === "order" ? "the order is taken off the unit" : where.kind === "command" ? "the command is refused" : "it is switched off";
+			this.log.error("game", `${siteWords(where)} threw: ${kept}, and the game goes on`, fields);
+			if (where.kind !== "order" && where.kind !== "command") this.disabled.set(siteKey(where), siteOf(where));
+			return;
+		}
+		this.failure = {
+			message: `The game stopped: ${siteWords(where)} failed`,
+			where,
+			error: errorFields(error),
+			tick: this.tick
+		};
+		this.log.error("game", `${siteWords(where)} threw: the game ends`, fields);
+		throw new GameEnded(this.failure);
+	}
+	/**
+	* Switches off the parts a save says were (`world.disabled`): the same game goes on as the one that was saved
+	*
+	* @beta
+	*/
+	disable(sites) {
+		for (const site of sites) {
+			this.disabled.set(siteKey(site), siteOf(site));
+			if (site.kind === "system") this.scheduler.disable(site.id);
+			else if (site.kind === "hook") this.hooks.remove(site.hook, site.id);
+		}
+	}
+	advance() {
+		if (this.checks.scenery) this.checkScenery();
+		if (this.checks.index) this.index.check(this.entities.values());
+		for (const entity of this.units.values()) {
+			entity.prevPos.x = entity.pos.x;
+			entity.prevPos.z = entity.pos.z;
+			entity.prevFacing = entity.facing;
+		}
+		this.given.clear();
+		if (this.overLimit.size) {
+			for (const [player, count] of this.overLimit) this.events.emit(commandRejected, {
+				player,
+				kind: "tooMany",
+				reason: `tooManyCommands: ${count} past the ${this.commandLimit} a tick takes`
+			});
+			this.overLimit.clear();
+		}
+		if (this.commands.length) {
+			const commands = this.commands;
+			this.commands = [];
+			for (const command of commands) executeCommand(this, command);
+		}
+		if (this.overLimitSeqs.length) {
+			for (const { player, seq } of this.overLimitSeqs) this.events.emit(commandHandled, {
+				player,
+				seq,
+				refusal: { key: "tooManyCommands" }
+			});
+			this.overLimitSeqs.length = 0;
+		}
+		this.spatial.rebuild(this.units.values());
+		this.scheduler.run(this);
+		if (this.life.dead.length) {
+			for (const entity of this.life.dead) {
+				this.entities.delete(entity.id);
+				this.units.delete(entity.id);
+				this.index.remove(entity);
+				this.hooks.run("remove", entity);
+				this.events.emit(entityRemoved, entity);
+			}
+			this.life.dead.length = 0;
+		}
+		this.tick++;
+	}
+	/** Throws when scenery has something that only units get looked after for. See `debugChecks` */
+	checkScenery() {
+		for (const entity of this.entities.values()) {
+			if (!entity.scenery || !entity.alive) continue;
+			const problem = !isScenery(entity.def) && "a type that is not scenery" || !this.player(entity.owner).neutral && "an owner" || entity.buffs.length > 0 && "buffs" || entity.orders.length > 0 && "orders" || entity.hidden && "been hidden" || entity.get(dashing) && "a dash" || entity.has(constructionSite) && "a construction site" || entity.expires !== null && "a lifetime" || (entity.has(exposure) || entity.has(detection)) && "been exposed or detected";
+			if (problem) throw new Error(`Scenery ${entity.def.id}#${entity.id} has ${problem}, but nothing woke it up (World.wake)`);
+		}
+	}
+	/**
+	* Whether it was disposed: its navigation is freed, and it is not to be stepped again
+	*
+	* @beta
+	*/
+	get disposed() {
+		return this.wasDisposed;
+	}
+	wasDisposed = false;
+	/**
+	* Frees what the world holds outside of JavaScript's memory: its navigation (a navmesh, its tiles and its crowd, in
+	* WebAssembly, which is never collected by itself). Whoever made the world disposes it once done with it: the
+	* session that owns it (`LocalSession`'s `ownsWorld`), the host (`SessionHost`'s), a test. Once is enough: again does
+	* nothing
+	*/
+	dispose() {
+		if (this.wasDisposed) return;
+		this.wasDisposed = true;
+		this.events.clear();
+		this.nav.dispose();
+		this.sidePaths?.dispose();
+		this.entities.clear();
+		this.units.clear();
+		this.index.clear();
+	}
+};
+//#endregion
+export { World };
+
+//# sourceMappingURL=world.js.map