@v12-engine/engine 0.1.1 → 0.4.0

package/dist/entity.js

@@ -0,0 +1,441 @@
+import { defineComponent } from "./components.js";
+import { constructionSite } from "./systems/construction.js";
+//#region src/entity.ts
+/**
+* What moves of an entity: where it goes, how fast, how it is doing (`MovementState`). Units that walk, swim or fly
+* have it from their type's speed; a building, a tree, or a unit an upgrade stopped has none. Filed (`index`), for the
+* movement system to go through
+*
+* @beta
+*/
+var moving = defineComponent({
+	id: "core.moving",
+	index: true
+});
+/**
+* How an entity fights (`CombatState`): its cooldown, its swing, what it is engaged with. What attacks has it from its
+* type's attack; an upgrade that takes the attack away takes it. Filed (`index`), for the combat system to go through
+*
+* @beta
+*/
+var fighting = defineComponent({
+	id: "core.fighting",
+	index: true
+});
+/**
+* What is left of what can be gathered from an entity, and who is at it (`ResourceState`): a mine's gold, a tree's
+* lumber. What its type gives (`UnitTypeDef.resource`) as it is made. Filed (`index`), for what looks for the nearest
+*
+* @beta
+*/
+var deposit = defineComponent({
+	id: "core.deposit",
+	index: true
+});
+/** Seconds by team, kept in a save as its entries: what `exposure` and `detection` are */
+var byTeam = {
+	save: (value) => [...value],
+	load: (saved) => new Map(saved)
+};
+/**
+* Seconds an entity stays in sight of other teams, by team, for having attacked them: seen where it stands, in the fog
+* and in a bush. Filed (`index`), for the fog to light those that have it
+*
+* @beta
+*/
+var exposure = defineComponent({
+	id: "core.exposure",
+	index: true,
+	...byTeam
+});
+/**
+* Seconds the teams that found an invisible entity with something that reveals it can go on seeing it, by team. Filed
+* (`index`), for the fog to light those that have it
+*
+* @beta
+*/
+var detection = defineComponent({
+	id: "core.detection",
+	index: true,
+	...byTeam
+});
+/**
+* A point, told from an order's fields: what has a number `x` and `z` (a map's point, an entity's `pos`), which no field
+* of an order is named
+*/
+var isPoint = (aim) => typeof aim.x === "number" && typeof aim.z === "number";
+/**
+* Anything in the world: a unit, a building, a tree.
+*
+* Fields marked `readonly` are kept in step with things elsewhere (the navigation, the spatial index, the lookups
+* of the world), so they are changed through the world's functions only: `World.setOwner`, `World.setHidden`,
+* `World.setLifetime`, `World.place`, `startDash`, `morph` (each through the entity's own internal writes: `moveTo`,
+* `retype`, `changeOwner`…). The rest, like health, mana or cooldowns, a game
+* module may change as it likes: nothing is worked out from them that would not notice.
+*
+* @public
+*/
+var Entity = class Entity {
+	id;
+	def;
+	owner;
+	/** Whether the entity is in the world; false once it died */
+	alive = true;
+	/** Hidden entities are inside something (a gold mine) and do not take part in the world */
+	hidden = false;
+	/**
+	* Only stands there, like a tree: left out of the systems that run every tick, see `isScenery`.
+	* Becomes false for good once something gives it anything to do (`World.wake`)
+	*/
+	scenery = false;
+	/** Where it stands in cells (`x`, `z`), changed through the world's functions only */
+	pos;
+	/** Where it stood at the last tick, for the screen to draw between */
+	prevPos;
+	/** The way it faces in radians */
+	facing = 0;
+	/** The way it faced at the last tick, in radians, for the screen to draw between */
+	prevFacing = 0;
+	/** How big it is drawn, for the look of a map. Nothing in the rules goes by it */
+	scale = 1;
+	/** Which of the models of its type it is drawn with, for the look of a map. Nothing in the rules goes by it either */
+	look;
+	/**
+	* Drawn as another's type and owner: a soul in the fallen's shape (`SpawnOptions.looksLike`). Its own type and owner
+	* decide everything but the picture
+	*/
+	likeness;
+	/** Velocity of the last tick */
+	velocity = {
+		x: 0,
+		z: 0
+	};
+	/** Hit points it has now; it dies at 0 */
+	health;
+	/** Teams that have seen this entity at least once, one bit per team as `FogOfWar.teamBit` hands them out. Ask `World.hasSeen` */
+	seenBy = 0;
+	/** When it was last hurt, in seconds of the game. Long ago for what never was */
+	hurtAt = -Infinity;
+	/** Seconds until it is gone by itself, for what does not last */
+	expires = null;
+	/** Seconds it was given to last, for what does not */
+	lifetime = 0;
+	/** Seconds until enemies cannot see it any more, for what is invisible. 0 once they cannot */
+	unseenIn = null;
+	/**
+	* What it was told to do, the first what it does now and the rest in turn: read here, given and ended through the
+	* orders' functions (`giveOrder`, `clearOrders`, `completeOrder`), which write it with the entity's own `addOrder`,
+	* `keepOrders` and `removeOrder`
+	*/
+	orders = [];
+	/** Invisible to enemies right now, unless they have found it */
+	get unseen() {
+		return this.unseenIn === 0;
+	}
+	/** The most hit points it can have */
+	maxHealth;
+	/** Mana it has now */
+	mana = 0;
+	/** The most mana it can have */
+	maxMana;
+	/** Does nothing by itself until something wakes it, and is drawn sleeping: creeps at night */
+	asleep = false;
+	/** A fallen hero that is on its way back */
+	reviving = false;
+	/**
+	* What it can cast, with their levels and cooldowns: each state is the game's to change (`cooldown`, `autocast`),
+	* the list the engine's (a type's own, what a hero learns), written with the entity's own internal methods
+	*/
+	abilities = [];
+	/** What is on it: each instance the game's to change, the list put on and taken off by `applyBuff`, `removeBuff` */
+	buffs = [];
+	/** The resource it stands on (`UnitTypeDef.builtOn`), by id: none for what stands on the ground */
+	on;
+	/** Min corner of the footprint in grid cells, for buildings and resources */
+	cell;
+	/** Bookkeeping of the spatial index: the last query that found it. Not game state */
+	spatialStamp = 0;
+	/** Stats as last worked out, see `statsOf`. Derived from the rest, never saved or sent */
+	statsCache = null;
+	/**
+	* What everyone in sight was last told of it (`commonEntityState`), told again as it is while it still says the
+	* truth (`commonStillTold`). Derived from the rest, never saved
+	*
+	* @internal
+	*/
+	told = null;
+	/**
+	* What its buffs may hold it to (stunned, rooted, invisible...), one bit each as `buffFlags` works them out, -1 until
+	* it does: put back to that by every write of its buffs. Derived from the rest, never saved or sent
+	*
+	* @internal
+	*/
+	buffFlags = -1;
+	/** @internal The version of the buff definitions `buffFlags` was worked out from (`Definitions.version`) */
+	buffFlagsOf = 0;
+	/**
+	* State of game modules and mods by each component's number (`Component.slot`): the one store of it (design review
+	* E4), for `get` and `has` one load from a list. Plain data, which goes into a save (by id: `components`)
+	*
+	* @internal
+	*/
+	slots = [];
+	/**
+	* Its components, in the order it was given them: the order a save, a snapshot and the index go through them in,
+	* so that a world hashes and saves the same whatever numbers its process gave its components
+	*
+	* @internal
+	*/
+	held = [];
+	/**
+	* The index of the world it is in (`EntityIndex`), told when it gets or loses a component, and the way to its world
+	* (`order`). Not game state
+	*/
+	index = null;
+	constructor(id, def, owner, position) {
+		this.id = id;
+		this.def = def;
+		this.owner = owner;
+		this.pos = {
+			x: position.x,
+			z: position.z
+		};
+		this.prevPos = {
+			x: position.x,
+			z: position.z
+		};
+		this.health = this.maxHealth = def.stats.health;
+		this.maxMana = def.stats.mana ?? 0;
+	}
+	/**
+	* Gives it an order, as its owner would: `unit.order('move', point)`, `unit.order('attack', enemy)`,
+	* `unit.order('cast', { ability: 'blink', point })`. What it is aimed at is a point (`point`), an entity (`target`)
+	* or the order's fields (`OrderInits`). It is the `order` command of its owner through its world (`World.issue`):
+	* taken up at the next tick, turned away as a player's would be (an order its type does not take, a target its owner
+	* does not know), and kept by a replay. `queue` puts it after what it was told before. Throws for an entity that is
+	* in no world (taken out of it)
+	*/
+	order(type, aim, options = {}) {
+		const world = this.index?.world?.();
+		if (!world) throw new Error(`${this.def.id}#${this.id} is in no world: it cannot be given an order`);
+		let init;
+		if (aim instanceof Entity) init = {
+			type,
+			target: aim.id
+		};
+		else if (aim && isPoint(aim)) init = {
+			type,
+			point: {
+				x: aim.x,
+				z: aim.z
+			}
+		};
+		else init = {
+			...aim,
+			type
+		};
+		world.issue({
+			type: "order",
+			player: this.owner,
+			entities: [this.id],
+			order: init,
+			...options.queue && { queue: true }
+		});
+	}
+	/**
+	* The engine's writes of what is read-only to everyone else, each kept in step by the world's function that calls it
+	* (`World.place`, `World.setOwner`, `World.setHidden`, `World.setLifetime`, `morph`, a death, a hero brought back).
+	* A game changes these through those functions, never here
+	*
+	* @internal
+	*/
+	moveTo(x, z) {
+		const pos = this.pos;
+		pos.x = x;
+		pos.z = z;
+	}
+	/** @internal See `moveTo`: its type, which a building's upgrade or a morph changes */
+	retype(def) {
+		this.def = def;
+	}
+	/** @internal See `moveTo`: whose it is (`World.setOwner`) */
+	changeOwner(owner) {
+		this.owner = owner;
+	}
+	/** @internal See `moveTo`: whether it is in the world (a death, a hero brought back) */
+	setAlive(alive) {
+		this.alive = alive;
+	}
+	/** @internal See `moveTo`: whether it is inside something (`World.setHidden`) */
+	setInside(hidden) {
+		this.hidden = hidden;
+	}
+	/** @internal See `moveTo`: whether it only stands there (`isScenery`, `World.wake`) */
+	setScenery(scenery) {
+		this.scenery = scenery;
+	}
+	/** @internal See `moveTo`: seconds until it is gone by itself, none for what lasts (`World.setLifetime`). Gives them back */
+	expireIn(seconds) {
+		return this.expires = seconds;
+	}
+	/** @internal See `moveTo`: an order put at the end of its queue */
+	addOrder(order) {
+		this.orders.push(order);
+	}
+	/** @internal See `moveTo`: its queue cut to its first `count` orders, none when left out */
+	keepOrders(count = 0) {
+		this.orders.length = Math.min(count, this.orders.length);
+	}
+	/** @internal See `moveTo`: an order out of its queue, wherever it is: whether it was there */
+	removeOrder(order) {
+		const at = this.orders.indexOf(order);
+		if (at >= 0) this.orders.splice(at, 1);
+		return at >= 0;
+	}
+	/** @internal See `moveTo`: what it can cast, all of it (a morph, an upgrade) */
+	setAbilities(abilities) {
+		this.abilities = abilities;
+	}
+	/** @internal See `moveTo`: one more it can cast (a hero learning one) */
+	addAbility(ability) {
+		this.abilities.push(ability);
+	}
+	/** @internal See `moveTo`: a buff put on (`applyBuff`) */
+	addBuff(buff) {
+		this.buffs.push(buff);
+		this.buffFlags = -1;
+	}
+	/** @internal See `moveTo`: the buff at an index taken off (`removeBuff`, one run out): it, if there was one */
+	dropBuff(index) {
+		this.buffFlags = -1;
+		return this.buffs.splice(index, 1)[0];
+	}
+	/** @internal See `moveTo`: every buff off at once (a death, a hero brought back) */
+	clearBuffs() {
+		this.buffs.length = 0;
+		this.buffFlags = -1;
+	}
+	/** @internal See `moveTo`: its buffs changed in place by who had to (a kill's triggers lending the fallen what it carried) */
+	buffsChanged() {
+		this.buffFlags = -1;
+	}
+	/** @internal See `moveTo`: a field a save kept (`ENTITY_SAVE`), as a save is loaded */
+	restore(field, value) {
+		this[field] = value;
+		if (field === "buffs") this.buffFlags = -1;
+	}
+	/** A component of a game module or a mod, see `defineComponent` */
+	get(key) {
+		return this.slots[key.slot];
+	}
+	/** Whether it holds the component */
+	has(key) {
+		return this.slots[key.slot] !== void 0;
+	}
+	/** Gives it the component, or a new value of it. `undefined` takes it away (`remove`) */
+	set(key, value) {
+		if (value === void 0) return this.remove(key);
+		const had = this.slots[key.slot] !== void 0;
+		this.slots[key.slot] = value;
+		if (had) return;
+		this.held.push(key);
+		this.index?.componentChanged(this, key.id, true);
+	}
+	/** Takes the component away; nothing happens when it has none */
+	remove(key) {
+		if (this.slots[key.slot] === void 0) return;
+		this.slots[key.slot] = void 0;
+		this.held.splice(this.held.findIndex((each) => each.slot === key.slot), 1);
+		this.index?.componentChanged(this, key.id, false);
+	}
+	/** Its components, in the order it was given them: each one's value is `get(component)` */
+	heldComponents() {
+		return this.held;
+	}
+	/**
+	* Its components' values by id, in the order it was given them: made each time it is asked, for what reads them
+	* by id now and then (a save, the inspector). What does it often goes through `heldComponents`
+	*/
+	get components() {
+		const values = {};
+		for (const component of this.held) values[component.id] = this.slots[component.slot];
+		return values;
+	}
+	/** Whether its type is a building */
+	get isBuilding() {
+		return this.def.kind === "building";
+	}
+	/** Whether its type is a unit */
+	get isUnit() {
+		return this.def.kind === "unit";
+	}
+	/** Whether its type is a resource */
+	get isResource() {
+		return this.def.kind === "resource";
+	}
+	/** Up in the air, where the ground and what stands on it are not in the way */
+	get flying() {
+		return this.def.flying === true;
+	}
+	/** Whether its type is a building or a resource: anything but a unit */
+	get isStructure() {
+		return this.def.kind !== "unit";
+	}
+	/** Completed and able to do its job */
+	get operational() {
+		if (!this.alive) return false;
+		if (this.def.kind === "unit") return true;
+		return this.slots[constructionSite.slot] === void 0;
+	}
+	/** The order it carries out now, the first of its orders; nothing when it has none */
+	get currentOrder() {
+		return this.orders[0];
+	}
+	/** Ground area covered by a structure: a new rect each time, for who keeps it (an obstacle, a wall's reshape) */
+	get rect() {
+		return {
+			x: this.pos.x,
+			z: this.pos.z,
+			hw: this.halfWidth,
+			hd: this.halfDepth
+		};
+	}
+	/** Half of what it covers across (`rect.hw`), with no rect made: what is asked all the time (is a structure in sight) */
+	get halfWidth() {
+		const fp = this.def.footprint;
+		return fp ? fp.w / 2 : this.def.radius;
+	}
+	/** Half of what it covers from front to back (`rect.hd`), as `halfWidth` */
+	get halfDepth() {
+		const fp = this.def.footprint;
+		return fp ? fp.d / 2 : this.def.radius;
+	}
+};
+/**
+* Distance from a point to the edge of an entity
+*
+* @beta
+*/
+function distanceToEdge(point, target) {
+	if (target.def.footprint) {
+		const fp = target.def.footprint;
+		const dx = Math.max(Math.abs(point.x - target.pos.x) - fp.w / 2, 0);
+		const dz = Math.max(Math.abs(point.z - target.pos.z) - fp.d / 2, 0);
+		return Math.sqrt(dx * dx + dz * dz);
+	}
+	const dx = point.x - target.pos.x;
+	const dz = point.z - target.pos.z;
+	return Math.max(Math.sqrt(dx * dx + dz * dz) - target.def.radius, 0);
+}
+/**
+* Distance between the edges of two entities
+*
+* @beta
+*/
+function edgeDistance(a, b) {
+	return Math.max(distanceToEdge(a.pos, b) - a.def.radius, 0);
+}
+//#endregion
+export { Entity, deposit, detection, distanceToEdge, edgeDistance, exposure, fighting, moving };
+
+//# sourceMappingURL=entity.js.map

package/dist/entity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity.js","names":[],"sources":["../src/entity.ts"],"sourcesContent":["import { type Cost, type EffectDef, type ResourceId, type UnitTypeDef } from './defs'\nimport { type Component, defineComponent } from './components'\n// (read as a structure asks whether it stands, never as the modules load: the systems' module comes round to this one)\nimport { constructionSite } from './systems/construction'\nimport type { Rect, Vec2 } from './math'\nimport type { StatsCache } from './stats'\nimport type { EntityState } from './session/protocol'\nimport type { OrderInit, OrderParams } from './registry'\nimport type { World } from './world'\n\n/**\n * The number an entity has in its world, unique there\n *\n * @public\n */\nexport type EntityId = number\n/**\n * The number of a player in a world\n *\n * @public\n */\nexport type PlayerId = number\n\n/**\n * An order a unit carries out or has queued. `State` is what its behaviour keeps in it (`OrderBehavior<State>`): empty\n * as the order is given, so every field of it is one that may not be there yet\n *\n * @beta\n */\nexport interface Order<State extends object = Record<string, any>, Init extends object = OrderParams> {\n\t/** The order's number, unique in its world */\n\tid: number\n\t/** The order's type, naming the behaviour that carries it out */\n\ttype: string\n\t/** What it was given, as its type takes it (`OrderInits`): plain data, saved with the order */\n\tinit: Init\n\t/** Shared by every unit that received the order from the same command */\n\tgroupId: number\n\t/** Whether the order has begun being carried out */\n\tstarted: boolean\n\t/** Scratch space owned by the order behavior: plain data, saved with the order */\n\tstate: State\n}\n\n/**\n * What a unit holds of one of its abilities: its level, cooldown, charges and autocast\n *\n * @beta\n */\nexport interface AbilityState {\n\t/** The id of the ability this is the state of */\n\tid: string\n\t/** 0 for an ability a hero has not learned yet */\n\tlevel: number\n\t/** Seconds until it can be used again */\n\tcooldown: number\n\t/**\n\t * Uses left, of an ability with charges (`AbilityDef.charges`): all it holds when left out, and `chargesLeft` says\n\t * how many that is. Set while it holds fewer\n\t */\n\tcharges?: number\n\t/** Seconds until the next use is back, while it holds fewer than it can */\n\trefill?: number\n\t/** Whether the ability is cast by itself when its conditions are met */\n\tautocast: boolean\n\t/** Where it was last aimed */\n\tpoint?: Vec2\n\t/** For one aimed along two points (`vector`): the second, the way it went from `point` */\n\tto?: Vec2\n\t/**\n\t * The game's own state of the ability on this unit, plain data (numbers, text, lists and plain objects of them):\n\t * ammo, a count of what it hit, a mark it left. Saved with the unit and told to its owner's screen with the rest of\n\t * the ability (`AbilityInfo.data`), for a button to show. Nothing of the engine's reads it\n\t *\n\t * @beta\n\t */\n\tdata?: Record<string, unknown>\n\t/**\n\t * Its window to be cast again, while it is open (`AbilityDef.recast`): the next cast is a recast\n\t *\n\t * @beta\n\t */\n\trecast?: RecastWindow\n}\n\n/**\n * An ability's window to be cast again (`AbilityState.recast`, `AbilityDef.recast`)\n *\n * @beta\n */\nexport interface RecastWindow {\n\t/** Seconds left of it */\n\tleft: number\n\t/** Seconds it was open for in all, for a button to show how much is left */\n\ttotal: number\n\t/** Recasts made in it so far */\n\tused: number\n\t/** The cooldown that starts as it closes, for one whose cooldown waits for it (`after`) */\n\tcooldown?: number\n}\n\n/**\n * A buff on a unit: which, from what level, how long is left and who put it there\n *\n * @beta\n */\nexport interface BuffInstance {\n\t/** The id of the buff */\n\tid: string\n\t/** Level of the ability it came from */\n\tlevel: number\n\t/** Seconds left. Infinity for buffs that stay */\n\tremaining: number\n\t/** Seconds the buff has been on */\n\telapsed: number\n\t/** Entity that put it there */\n\tsource: EntityId\n\t/** What is left of the shield it gives */\n\tshield?: number\n\t/** How many of it there are, for buffs that pile up */\n\tstacks?: number\n\t/** The ability it came from, for buffs that do something when their time is up */\n\tability?: string\n\t/**\n\t * Kept up by an ability of its source's for as long as it holds (a passive's buff, an aura's): put on again every\n\t * round for a moment, with no time of its own to show (`EntityState.buffTimes` says -1)\n\t */\n\tkept?: boolean\n\t/** State of the game's own about this one buff: a counter, what it has done so far. Plain data: it is saved */\n\tdata?: Record<string, unknown>\n}\n\n/**\n * An item someone carries\n *\n * @beta\n */\nexport interface ItemInstance {\n\t/** The item instance's number, unique in its world */\n\tid: number\n\t/** The id of the item type */\n\titem: string\n\t/** Uses left, for items that run out */\n\tcharges: number\n\t/** Cooldown of the ability the item gives */\n\tstate?: AbilityState\n\t/** Seconds until its next charge comes back, for an item that refills over time (`ItemDef.refill`) while it is short */\n\trefill?: number\n\t/** State of the game's own about this one item: kills it has seen, what it has stored. Plain data: it is saved */\n\tdata?: Record<string, unknown>\n}\n\n/**\n * What a shop has of one of its wares (`shopStock`, a component of the entity's)\n *\n * @beta\n */\nexport interface StockState {\n\t/** The id of the item type for sale */\n\titem: string\n\t/** How many of it the shop has now */\n\tcount: number\n\t/** Seconds until the next one arrives */\n\trestock: number\n}\n\n/**\n * How a unit's move is going: it is not moving, on its way, got there, or could not\n *\n * @beta\n */\nexport type MoveStatus = 'idle' | 'moving' | 'arrived' | 'failed'\n\n/**\n * What a unit keeps of its moving: speed, goal, status and the path's bookkeeping\n *\n * @beta\n */\nexport interface MovementState {\n\t/** Units per second it goes at now */\n\tspeed: number\n\t/** The fastest it goes for now, whatever its speed: a group's slowest, as it moves together (`OrderParams.together`) */\n\tcap?: number\n\t/** Whether it is idle, on its way, arrived or failed to get there */\n\tstatus: MoveStatus\n\t/** Where it is heading, in cells */\n\tgoal: Vec2\n\t/** When set the goal follows this entity */\n\tgoalEntity: EntityId\n\t/** Arrive once this close to the goal (edge distance for entity goals) */\n\trange: number\n\t/** The group of units that were sent together; the same as the `groupId` of their order */\n\tgroupId: number\n\t/** Last destination handed to the navigation */\n\tnavGoal: Vec2\n\t/** The version of the navigation when the goal was handed to it */\n\tnavVersion: number\n\t/** Corner of the path the unit is heading for. Progress is measured towards it, so a long way round is not mistaken for standing still */\n\tcorner: Vec2\n\t/** Closest the unit has been to its corner, used to detect that it stopped making progress */\n\tbestDistance: number\n\t/** Seconds it has made no progress towards its corner */\n\tstalledTime: number\n\t/**\n\t * Seconds it has gone well under its speed on its way, held up by others (not counting getting going, or slowing\n\t * to arrive): what has those in its way asked to step aside (see `RuleSettings.movement.lookAhead`)\n\t */\n\tslowTime?: number\n\t/**\n\t * The point it goes round standing units by, on its way to the next corner of its path, when that is not much\n\t * longer (`RuleSettings.movement.goesAround`, the `detour` hook): none while it goes straight\n\t */\n\tdetour?: Vec2\n\t/** Where it heads on from `detour`: the corner of its path it went round the knot towards */\n\tdetourAim?: Vec2\n\t/** On a step aside for another (`MoveOptions.aside`): it goes round nobody and asks nobody to make way */\n\taside?: boolean\n\t/** Whether it was sent on past `detour`, towards its path, as it neared it */\n\tdetourPast?: boolean\n\t/**\n\t * The group of the formation it was last sent in (`OrderInit.formation`, the order's `groupId`): those of one swap\n\t * places on the way, and keep the places they get to (`place`)\n\t */\n\tformation?: number\n\t/**\n\t * Its place in its formation, once there. Stepped aside or pushed off it, it walks back once it has stood off it a\n\t * while. None once it walks off on a move of its own, or is given another order\n\t */\n\tplace?: Vec2\n\t/** How many times it went back to its place without getting there: it lets it go after a few */\n\tbackTries?: number\n\t/**\n\t * How many times it tried again on this move, held up 3 seconds by others that may yet go (in a crowd, say): sent on\n\t * anew, round the whole knot, those in it asked aside. It gives up after 4, or none when what holds it up is the\n\t * ground or those holding their ground. Counted again once it gets 2 cells nearer\n\t */\n\ttries?: number\n\t/** How far it had left to go when it last tried again */\n\ttriedAt?: number\n\t/**\n\t * On a step aside asked by one stepping aside itself: how far down that line it is (2, 3). One that far asks nobody\n\t * aside in turn, so that a crowd parts a few deep and no further\n\t */\n\tasideDepth?: number\n\t/** Whether the last move failed by getting stuck on the way (in a crowd, say), not for there being no way there */\n\tstuck?: boolean\n\t/** Whether the unit holds its ground in a fight, so that others come round it */\n\tanchored: boolean\n\t/** Whether the navigation lets it through others, as a ghost */\n\tghost: boolean\n\t/**\n\t * Whether a buff it carries has it walk through others now (`BuffDef.phasing`): a ghost to the navigation as well,\n\t * whatever `ghost` says. Seen to every tick by the movement\n\t */\n\tphased?: boolean\n\t/** Direction the unit turns to while it stands still. Null when it may face wherever it ended up */\n\tfinalFacing: number | null\n\t/**\n\t * The route its side planned to the goal, corner by corner, with what the side knows (`Rules.paths: 'seen'`):\n\t * walked a stretch at a time. None where routes know everything, or there is no route\n\t */\n\troute?: Vec2[]\n\t/** The corner of `route` it heads past next */\n\trouteAt?: number\n\t/** What its side knew when the route was planned (`SidePaths.version`): it is planned again once that changes */\n\trouteVersion?: number\n\t/** Where along `route` the navigation was last sent it: a stretch no longer than it can see */\n\tstretch?: Vec2\n}\n\n/**\n * What moves of an entity: where it goes, how fast, how it is doing (`MovementState`). Units that walk, swim or fly\n * have it from their type's speed; a building, a tree, or a unit an upgrade stopped has none. Filed (`index`), for the\n * movement system to go through\n *\n * @beta\n */\nexport const moving = defineComponent<MovementState>({ id: 'core.moving', index: true })\n\n/**\n * What a unit keeps of its fighting: cooldown, swing, targets and recovery\n *\n * @beta\n */\nexport interface CombatState {\n\t/** Seconds until the next attack may start */\n\tcooldown: number\n\t/** Seconds until the running swing lands. 0 when not swinging */\n\tswing: number\n\t/** The entity the running swing is aimed at */\n\tswingTarget: EntityId\n\t/**\n\t * Which of its attacks the running swing, or the last, is of, by place (`UnitTypeDef.attacks`): the first when left\n\t * out, as for every unit with one. It swings one at a time, and waits out the cooldown of the one that hit\n\t */\n\tweapon?: number\n\t/**\n\t * Seconds left of the recovery after its last blow (`AttackDef.recovery`), while what it is told waits: none when\n\t * it has none\n\t */\n\trecovery?: number\n\t/** Target picked by the unit itself rather than by an order */\n\tautoTarget: EntityId\n\t/** The entity that last hit it */\n\tlastAttacker: EntityId\n\t/** Where an idle unit returns to after chasing */\n\tguard: Vec2 | null\n\t/** Does not pick fights of its own accord until it gets an order (set by a game's rules; `stop` no longer sets it) */\n\tpassive: boolean\n\t/** What it is fighting or closing in on, whoever picked it: 0 for nothing (see `engagement.ts`) */\n\tengaged?: EntityId\n\t/** The spot it holds around that, as an angle seen from it. Null when it has none: it flies, it hits a building */\n\tslot?: number | null\n\t/** Targets it left alone because it could not get at them, and until when, in world time */\n\tshunned?: [EntityId, number][]\n\t/** The tick the allies of whoever it hit were last called to help (`RuleSettings.combat.helpRange`), so that they are asked once in a while, not by every blow. Unset until it hits someone */\n\thelpedAt?: number\n}\n\n/**\n * How an entity fights (`CombatState`): its cooldown, its swing, what it is engaged with. What attacks has it from its\n * type's attack; an upgrade that takes the attack away takes it. Filed (`index`), for the combat system to go through\n *\n * @beta\n */\nexport const fighting = defineComponent<CombatState>({ id: 'core.fighting', index: true })\n\n/**\n * What a worker keeps of its gathering: what it carries and where it gathered\n *\n * @beta\n */\nexport interface HarvesterState {\n\t/** How much of the resource the worker carries */\n\tcarrying: number\n\t/** What it is that the worker carries, or last gathered. Null for one that has not gathered anything yet */\n\tkind: ResourceId | null\n\t/** Last resource this worker gathered from */\n\tresource: EntityId\n}\n\n/**\n * What is left of a deposit and how many are at it\n *\n * @beta\n */\nexport interface ResourceState {\n\t/** How much of the resource is left in it */\n\tamount: number\n\t/** How many workers are at it, inside or working on it */\n\toccupants: number\n\t/** The building that stands on it (`UnitTypeDef.builtOn`), by id: none when nothing does */\n\tunder?: EntityId\n}\n\n/**\n * What is left of what can be gathered from an entity, and who is at it (`ResourceState`): a mine's gold, a tree's\n * lumber. What its type gives (`UnitTypeDef.resource`) as it is made. Filed (`index`), for what looks for the nearest\n *\n * @beta\n */\nexport const deposit = defineComponent<ResourceState>({ id: 'core.deposit', index: true })\n\n/**\n * How far a building under construction has got\n *\n * @beta\n */\nexport interface ConstructionState {\n\t/** 0..1 */\n\tprogress: number\n\t/** Seconds a single builder needs to finish it */\n\tbuildTime: number\n\t/** Builders that worked on it during the current tick */\n\tbuilders: number\n\t/** What was paid for it, when that is not what its type costs. A cancelled site gives part of this back */\n\tpaid?: Cost\n}\n\n/**\n * One thing a building makes: a unit, an upgrade, a revive or a morph\n *\n * @beta\n */\nexport interface ProductionItem {\n\t/** What it makes: a unit, an upgrade, a revived hero or a morph into another type */\n\tkind: 'unit' | 'upgrade' | 'revive' | 'morph'\n\t/** Unit type, upgrade id, the id of the hero to bring back, or the type the building turns into */\n\tid: string\n\t/** What was paid, when that does not follow from the id */\n\tpaid?: Cost\n\t/** Seconds of work done */\n\tprogress: number\n\t/** Seconds it takes in all */\n\tduration: number\n}\n\n/** Seconds by team, kept in a save as its entries: what `exposure` and `detection` are */\nconst byTeam = { save: (value: Map<number, number>) => [...value], load: (saved: unknown) => new Map(saved as [number, number][]) }\n\n/**\n * Seconds an entity stays in sight of other teams, by team, for having attacked them: seen where it stands, in the fog\n * and in a bush. Filed (`index`), for the fog to light those that have it\n *\n * @beta\n */\nexport const exposure = defineComponent<Map<number, number>>({ id: 'core.exposure', index: true, ...byTeam })\n\n/**\n * Seconds the teams that found an invisible entity with something that reveals it can go on seeing it, by team. Filed\n * (`index`), for the fog to light those that have it\n *\n * @beta\n */\nexport const detection = defineComponent<Map<number, number>>({ id: 'core.detection', index: true, ...byTeam })\n\n/**\n * Whose picture an entity wears: the type it is drawn as, and the owner whose colour it is drawn in. Nothing in the\n * rules goes by it\n *\n * @beta\n */\nexport interface Likeness {\n\t/** The unit type whose picture the entity wears */\n\ttype: string\n\t/** The player whose colour the entity is drawn in */\n\towner: PlayerId\n}\n\n/**\n * A rush to a spot: nothing stops it, and what it does happens where it ends\n *\n * @beta\n */\nexport interface Dash {\n\t/** Where it ends, east-west in cells */\n\tx: number\n\t/** Where it ends, north-south in cells */\n\tz: number\n\t/** Where it started */\n\tfrom: Vec2\n\t/** Units per second */\n\tspeed: number\n\t/** The id of the ability that sent it */\n\tability: string\n\t/** The level of the ability it was cast at */\n\tlevel: number\n\t/**\n\t * Which effect of the ability sent it, by its place there (`effectIndex`): what the screen draws it with\n\t * (`AbilityLook.effects`). Nothing to the rules\n\t *\n\t * @beta\n\t */\n\teffect?: number\n\t/** The effects that happen where it ends */\n\teffects: EffectDef[]\n\t/** How high it rises on the way: a leap, over whatever is in between */\n\theight?: number\n\t/** A buff it carries for as long as the rush lasts */\n\tbuff?: string\n\t/**\n\t * Dragged by someone (the effect `pull`): `by` whom, in whose name `effects` happen to it as it arrives, and whether\n\t * it is dragged after them as they move (`follows`) or to the spot (`x`, `z`). It does nothing of its own meanwhile,\n\t * and nothing else moves it\n\t *\n\t * @beta\n\t */\n\tpulled?: { by: EntityId; follows: boolean }\n\t/**\n\t * The unit it rushes to (a `dash` to a unit, in a game with the moves pack): its landing `effects` happen to it, where\n\t * it still is in the world\n\t *\n\t * @beta\n\t */\n\ttarget?: EntityId\n}\n\n/**\n * Where the units a building makes go: a point, or an entity they follow\n *\n * @beta\n */\nexport interface RallyPoint {\n\t/** The place the units go to */\n\tpoint: Vec2\n\t/** The entity they follow; 0 for none */\n\ttarget: EntityId\n}\n\n/**\n * What a building makes: the queue of what it is making, and its rally point\n *\n * @beta\n */\nexport interface ProductionState {\n\t/** What it makes in turn, the first being worked on */\n\tqueue: ProductionItem[]\n\t/** Where the units it makes go, or null for none */\n\trally: RallyPoint | null\n}\n\n/**\n * How an order is given (`Entity.order`)\n *\n * @public\n */\nexport interface OrderOptions {\n\t/** After what it was told before, rather than in its place: Shift held */\n\tqueue?: boolean\n}\n\n/**\n * A point, told from an order's fields: what has a number `x` and `z` (a map's point, an entity's `pos`), which no field\n * of an order is named\n */\nconst isPoint = (aim: object): aim is Vec2 => typeof (aim as Vec2).x === 'number' && typeof (aim as Vec2).z === 'number'\n\n/**\n * Anything in the world: a unit, a building, a tree.\n *\n * Fields marked `readonly` are kept in step with things elsewhere (the navigation, the spatial index, the lookups\n * of the world), so they are changed through the world's functions only: `World.setOwner`, `World.setHidden`,\n * `World.setLifetime`, `World.place`, `startDash`, `morph` (each through the entity's own internal writes: `moveTo`,\n * `retype`, `changeOwner`…). The rest, like health, mana or cooldowns, a game\n * module may change as it likes: nothing is worked out from them that would not notice.\n *\n * @public\n */\nexport class Entity {\n\t/** Whether the entity is in the world; false once it died */\n\treadonly alive: boolean = true\n\t/** Hidden entities are inside something (a gold mine) and do not take part in the world */\n\treadonly hidden: boolean = false\n\t/**\n\t * Only stands there, like a tree: left out of the systems that run every tick, see `isScenery`.\n\t * Becomes false for good once something gives it anything to do (`World.wake`)\n\t */\n\treadonly scenery: boolean = false\n\n\t/** Where it stands in cells (`x`, `z`), changed through the world's functions only */\n\treadonly pos: Readonly<Vec2>\n\t/** Where it stood at the last tick, for the screen to draw between */\n\treadonly prevPos: Vec2\n\t/** The way it faces in radians */\n\tfacing = 0\n\t/** The way it faced at the last tick, in radians, for the screen to draw between */\n\tprevFacing = 0\n\t/** How big it is drawn, for the look of a map. Nothing in the rules goes by it */\n\tscale = 1\n\t/** Which of the models of its type it is drawn with, for the look of a map. Nothing in the rules goes by it either */\n\tlook?: string\n\t/**\n\t * Drawn as another's type and owner: a soul in the fallen's shape (`SpawnOptions.looksLike`). Its own type and owner\n\t * decide everything but the picture\n\t */\n\tlikeness?: Likeness\n\t/** Velocity of the last tick */\n\treadonly velocity: Vec2 = { x: 0, z: 0 }\n\n\t/** Hit points it has now; it dies at 0 */\n\thealth: number\n\t/** Teams that have seen this entity at least once, one bit per team as `FogOfWar.teamBit` hands them out. Ask `World.hasSeen` */\n\tseenBy = 0\n\t/** When it was last hurt, in seconds of the game. Long ago for what never was */\n\thurtAt = -Infinity\n\t/** Seconds until it is gone by itself, for what does not last */\n\treadonly expires: number | null = null\n\t/** Seconds it was given to last, for what does not */\n\tlifetime = 0\n\t/** Seconds until enemies cannot see it any more, for what is invisible. 0 once they cannot */\n\tunseenIn: number | null = null\n\n\t/**\n\t * What it was told to do, the first what it does now and the rest in turn: read here, given and ended through the\n\t * orders' functions (`giveOrder`, `clearOrders`, `completeOrder`), which write it with the entity's own `addOrder`,\n\t * `keepOrders` and `removeOrder`\n\t */\n\treadonly orders: readonly Order[] = []\n\n\t/** Invisible to enemies right now, unless they have found it */\n\tget unseen(): boolean {\n\t\treturn this.unseenIn === 0\n\t}\n\n\t/** The most hit points it can have */\n\tmaxHealth: number\n\t/** Mana it has now */\n\tmana = 0\n\t/** The most mana it can have */\n\tmaxMana: number\n\t/** Does nothing by itself until something wakes it, and is drawn sleeping: creeps at night */\n\tasleep = false\n\t/** A fallen hero that is on its way back */\n\treviving = false\n\t/**\n\t * What it can cast, with their levels and cooldowns: each state is the game's to change (`cooldown`, `autocast`),\n\t * the list the engine's (a type's own, what a hero learns), written with the entity's own internal methods\n\t */\n\treadonly abilities: readonly AbilityState[] = []\n\t/** What is on it: each instance the game's to change, the list put on and taken off by `applyBuff`, `removeBuff` */\n\treadonly buffs: readonly BuffInstance[] = []\n\n\t/** The resource it stands on (`UnitTypeDef.builtOn`), by id: none for what stands on the ground */\n\ton?: EntityId\n\t/** Min corner of the footprint in grid cells, for buildings and resources */\n\tcell?: { x: number; z: number }\n\n\t/** Bookkeeping of the spatial index: the last query that found it. Not game state */\n\tspatialStamp = 0\n\t/** Stats as last worked out, see `statsOf`. Derived from the rest, never saved or sent */\n\tstatsCache: StatsCache | null = null\n\t/**\n\t * What everyone in sight was last told of it (`commonEntityState`), told again as it is while it still says the\n\t * truth (`commonStillTold`). Derived from the rest, never saved\n\t *\n\t * @internal\n\t */\n\ttold: EntityState | null = null\n\t/**\n\t * What its buffs may hold it to (stunned, rooted, invisible...), one bit each as `buffFlags` works them out, -1 until\n\t * it does: put back to that by every write of its buffs. Derived from the rest, never saved or sent\n\t *\n\t * @internal\n\t */\n\tbuffFlags = -1\n\t/** @internal The version of the buff definitions `buffFlags` was worked out from (`Definitions.version`) */\n\tbuffFlagsOf = 0\n\n\t/**\n\t * State of game modules and mods by each component's number (`Component.slot`): the one store of it (design review\n\t * E4), for `get` and `has` one load from a list. Plain data, which goes into a save (by id: `components`)\n\t *\n\t * @internal\n\t */\n\tslots: unknown[] = []\n\t/**\n\t * Its components, in the order it was given them: the order a save, a snapshot and the index go through them in,\n\t * so that a world hashes and saves the same whatever numbers its process gave its components\n\t *\n\t * @internal\n\t */\n\treadonly held: Component<unknown, unknown>[] = []\n\t/**\n\t * The index of the world it is in (`EntityIndex`), told when it gets or loses a component, and the way to its world\n\t * (`order`). Not game state\n\t */\n\tindex: { componentChanged(entity: Entity, id: string, has: boolean): void } | null = null\n\n\tconstructor(\n\t\t/** The entity's number, unique in its world */\n\t\treadonly id: EntityId,\n\t\t/** Changes when a building is upgraded into another type */\n\t\treadonly def: UnitTypeDef,\n\t\t/** The player it belongs to, changed through `World.setOwner` only */\n\t\treadonly owner: PlayerId,\n\t\tposition: Vec2\n\t) {\n\t\tthis.pos = { x: position.x, z: position.z }\n\t\tthis.prevPos = { x: position.x, z: position.z }\n\t\t// what its type starts with: no game rule changes health or mana\n\t\tthis.health = this.maxHealth = def.stats.health\n\t\tthis.maxMana = def.stats.mana ?? 0\n\t}\n\n\t/**\n\t * Gives it an order, as its owner would: `unit.order('move', point)`, `unit.order('attack', enemy)`,\n\t * `unit.order('cast', { ability: 'blink', point })`. What it is aimed at is a point (`point`), an entity (`target`)\n\t * or the order's fields (`OrderInits`). It is the `order` command of its owner through its world (`World.issue`):\n\t * taken up at the next tick, turned away as a player's would be (an order its type does not take, a target its owner\n\t * does not know), and kept by a replay. `queue` puts it after what it was told before. Throws for an entity that is\n\t * in no world (taken out of it)\n\t */\n\torder<Type extends string>(type: Type, aim?: Vec2 | Entity | Omit<OrderInit<Type>, 'type'>, options: OrderOptions = {}): void {\n\t\t// the world by its index (`EntityIndex.world`), which the type of the field leaves out: a type of the data a pack\n\t\t// schema is made of reaches an entity, and must not reach the world through it\n\t\tconst world = (this.index as { world?(): World } | null)?.world?.()\n\t\tif (!world) throw new Error(`${this.def.id}#${this.id} is in no world: it cannot be given an order`)\n\t\tlet init: OrderInit\n\t\tif (aim instanceof Entity) init = { type, target: aim.id }\n\t\telse if (aim && isPoint(aim)) init = { type, point: { x: aim.x, z: aim.z } }\n\t\telse init = { ...(aim as object), type } as OrderInit\n\t\tworld.issue({ type: 'order', player: this.owner, entities: [this.id], order: init, ...(options.queue && { queue: true }) })\n\t}\n\n\t/**\n\t * The engine's writes of what is read-only to everyone else, each kept in step by the world's function that calls it\n\t * (`World.place`, `World.setOwner`, `World.setHidden`, `World.setLifetime`, `morph`, a death, a hero brought back).\n\t * A game changes these through those functions, never here\n\t *\n\t * @internal\n\t */\n\tmoveTo(x: number, z: number): void {\n\t\tconst pos = this.pos as Vec2\n\t\tpos.x = x\n\t\tpos.z = z\n\t}\n\n\t/** @internal See `moveTo`: its type, which a building's upgrade or a morph changes */\n\tretype(def: UnitTypeDef): void {\n\t\t;(this as { def: UnitTypeDef }).def = def\n\t}\n\n\t/** @internal See `moveTo`: whose it is (`World.setOwner`) */\n\tchangeOwner(owner: PlayerId): void {\n\t\t;(this as { owner: PlayerId }).owner = owner\n\t}\n\n\t/** @internal See `moveTo`: whether it is in the world (a death, a hero brought back) */\n\tsetAlive(alive: boolean): void {\n\t\t;(this as { alive: boolean }).alive = alive\n\t}\n\n\t/** @internal See `moveTo`: whether it is inside something (`World.setHidden`) */\n\tsetInside(hidden: boolean): void {\n\t\t;(this as { hidden: boolean }).hidden = hidden\n\t}\n\n\t/** @internal See `moveTo`: whether it only stands there (`isScenery`, `World.wake`) */\n\tsetScenery(scenery: boolean): void {\n\t\t;(this as { scenery: boolean }).scenery = scenery\n\t}\n\n\t/** @internal See `moveTo`: seconds until it is gone by itself, none for what lasts (`World.setLifetime`). Gives them back */\n\texpireIn(seconds: number | null): number | null {\n\t\treturn ((this as { expires: number | null }).expires = seconds)\n\t}\n\n\t/** @internal See `moveTo`: an order put at the end of its queue */\n\taddOrder(order: Order): void {\n\t\t;(this.orders as Order[]).push(order)\n\t}\n\n\t/** @internal See `moveTo`: its queue cut to its first `count` orders, none when left out */\n\tkeepOrders(count = 0): void {\n\t\t;(this.orders as Order[]).length = Math.min(count, this.orders.length)\n\t}\n\n\t/** @internal See `moveTo`: an order out of its queue, wherever it is: whether it was there */\n\tremoveOrder(order: Order): boolean {\n\t\tconst at = this.orders.indexOf(order)\n\t\tif (at >= 0) (this.orders as Order[]).splice(at, 1)\n\t\treturn at >= 0\n\t}\n\n\t/** @internal See `moveTo`: what it can cast, all of it (a morph, an upgrade) */\n\tsetAbilities(abilities: AbilityState[]): void {\n\t\t;(this as { abilities: readonly AbilityState[] }).abilities = abilities\n\t}\n\n\t/** @internal See `moveTo`: one more it can cast (a hero learning one) */\n\taddAbility(ability: AbilityState): void {\n\t\t;(this.abilities as AbilityState[]).push(ability)\n\t}\n\n\t/** @internal See `moveTo`: a buff put on (`applyBuff`) */\n\taddBuff(buff: BuffInstance): void {\n\t\t;(this.buffs as BuffInstance[]).push(buff)\n\t\tthis.buffFlags = -1\n\t}\n\n\t/** @internal See `moveTo`: the buff at an index taken off (`removeBuff`, one run out): it, if there was one */\n\tdropBuff(index: number): BuffInstance | undefined {\n\t\tthis.buffFlags = -1\n\t\treturn (this.buffs as BuffInstance[]).splice(index, 1)[0]\n\t}\n\n\t/** @internal See `moveTo`: every buff off at once (a death, a hero brought back) */\n\tclearBuffs(): void {\n\t\t;(this.buffs as BuffInstance[]).length = 0\n\t\tthis.buffFlags = -1\n\t}\n\n\t/** @internal See `moveTo`: its buffs changed in place by who had to (a kill's triggers lending the fallen what it carried) */\n\tbuffsChanged(): void {\n\t\tthis.buffFlags = -1\n\t}\n\n\t/** @internal See `moveTo`: a field a save kept (`ENTITY_SAVE`), as a save is loaded */\n\trestore(field: string, value: unknown): void {\n\t\t;(this as unknown as Record<string, unknown>)[field] = value\n\t\tif (field === 'buffs') this.buffFlags = -1\n\t}\n\n\t/** A component of a game module or a mod, see `defineComponent` */\n\tget<T>(key: Component<T, unknown>): T | undefined {\n\t\treturn this.slots[key.slot] as T | undefined\n\t}\n\n\t/** Whether it holds the component */\n\thas(key: Component<unknown>): boolean {\n\t\treturn this.slots[key.slot] !== undefined\n\t}\n\n\t/** Gives it the component, or a new value of it. `undefined` takes it away (`remove`) */\n\tset<T>(key: Component<T, unknown>, value: T): void {\n\t\tif (value === undefined) return this.remove(key)\n\t\tconst had = this.slots[key.slot] !== undefined\n\t\tthis.slots[key.slot] = value\n\t\tif (had) return\n\t\tthis.held.push(key as Component<unknown, unknown>)\n\t\tthis.index?.componentChanged(this, key.id, true)\n\t}\n\n\t/** Takes the component away; nothing happens when it has none */\n\tremove(key: Component<unknown>): void {\n\t\tif (this.slots[key.slot] === undefined) return\n\t\tthis.slots[key.slot] = undefined\n\t\t// by its number: a module loaded again (a dev server's) defines another object of the same component\n\t\tthis.held.splice(\n\t\t\tthis.held.findIndex((each) => each.slot === key.slot),\n\t\t\t1\n\t\t)\n\t\tthis.index?.componentChanged(this, key.id, false)\n\t}\n\n\t/** Its components, in the order it was given them: each one's value is `get(component)` */\n\theldComponents(): readonly Component<unknown, unknown>[] {\n\t\treturn this.held\n\t}\n\n\t/**\n\t * Its components' values by id, in the order it was given them: made each time it is asked, for what reads them\n\t * by id now and then (a save, the inspector). What does it often goes through `heldComponents`\n\t */\n\tget components(): Readonly<Record<string, unknown>> {\n\t\tconst values: Record<string, unknown> = {}\n\t\tfor (const component of this.held) values[component.id] = this.slots[component.slot]\n\t\treturn values\n\t}\n\n\t/** Whether its type is a building */\n\tget isBuilding() {\n\t\treturn this.def.kind === 'building'\n\t}\n\n\t/** Whether its type is a unit */\n\tget isUnit() {\n\t\treturn this.def.kind === 'unit'\n\t}\n\n\t/** Whether its type is a resource */\n\tget isResource() {\n\t\treturn this.def.kind === 'resource'\n\t}\n\n\t/** Up in the air, where the ground and what stands on it are not in the way */\n\tget flying() {\n\t\treturn this.def.flying === true\n\t}\n\n\t/** Whether its type is a building or a resource: anything but a unit */\n\tget isStructure() {\n\t\treturn this.def.kind !== 'unit'\n\t}\n\n\t/** Completed and able to do its job */\n\tget operational() {\n\t\t// (a site is a structure's, and what moves is most of what asks)\n\t\tif (!this.alive) return false\n\t\tif (this.def.kind === 'unit') return true\n\t\treturn this.slots[constructionSite.slot] === undefined\n\t}\n\n\t/** The order it carries out now, the first of its orders; nothing when it has none */\n\tget currentOrder(): Order | undefined {\n\t\treturn this.orders[0]\n\t}\n\n\t/** Ground area covered by a structure: a new rect each time, for who keeps it (an obstacle, a wall's reshape) */\n\tget rect(): Rect {\n\t\treturn { x: this.pos.x, z: this.pos.z, hw: this.halfWidth, hd: this.halfDepth }\n\t}\n\n\t/** Half of what it covers across (`rect.hw`), with no rect made: what is asked all the time (is a structure in sight) */\n\tget halfWidth(): number {\n\t\tconst fp = this.def.footprint\n\t\treturn fp ? fp.w / 2 : this.def.radius\n\t}\n\n\t/** Half of what it covers from front to back (`rect.hd`), as `halfWidth` */\n\tget halfDepth(): number {\n\t\tconst fp = this.def.footprint\n\t\treturn fp ? fp.d / 2 : this.def.radius\n\t}\n}\n\n/**\n * Anything with a place and a size: an entity, or what a client knows of one\n *\n * @beta\n */\nexport interface Placed {\n\t/** Where it stands in cells */\n\tpos: Vec2\n\t/** The definition of its type */\n\tdef: UnitTypeDef\n}\n\n/**\n * Distance from a point to the edge of an entity\n *\n * @beta\n */\nexport function distanceToEdge(point: Vec2, target: Placed): number {\n\tif (target.def.footprint) {\n\t\tconst fp = target.def.footprint\n\t\tconst dx = Math.max(Math.abs(point.x - target.pos.x) - fp.w / 2, 0)\n\t\tconst dz = Math.max(Math.abs(point.z - target.pos.z) - fp.d / 2, 0)\n\t\treturn Math.sqrt(dx * dx + dz * dz)\n\t}\n\tconst dx = point.x - target.pos.x\n\tconst dz = point.z - target.pos.z\n\treturn Math.max(Math.sqrt(dx * dx + dz * dz) - target.def.radius, 0)\n}\n\n/**\n * Distance between the edges of two entities\n *\n * @beta\n */\nexport function edgeDistance(a: Placed, b: Placed): number {\n\treturn Math.max(distanceToEdge(a.pos, b) - a.def.radius, 0)\n}\n"],"mappings":"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"}

package/dist/entityIndex.d.ts

@@ -1,5 +1,6 @@
 import type { Component } from './components';
 import type { Entity, PlayerId } from './entity';
+import type { World } from './world';
 /**
  * Entities filed by what they are asked for by: whose they are, which have a component (and, for a component that
  * asks, whose they are too: `Component.index`). Answers questions like "the heroes of player 2"
@@ -14,8 +15,14 @@ import type { Entity, PlayerId } from './entity';
  */
 export declare class EntityIndex {
     private readonly componentOf;
-    /** `componentOf`: a component of the world's game by its id, an error for one it does not list (`registry.used`) */
-    constructor(componentOf: (id: string) => Component<unknown, unknown> | undefined);
+    private readonly worldOf;
+    /**
+     * `componentOf`: a component of the world's game by its id, an error for one it does not list (`registry.used`);
+     * `worldOf`: the world it is the index of, which its entities reach through it (`Entity.order`)
+     */
+    constructor(componentOf: (id: string) => Component<unknown, unknown> | undefined, worldOf: () => World);
+    /** The world it is the index of */
+    world(): World;
     private readonly owned;
     private readonly components;
     /** By component id, then by owner: for the components that ask (`index: 'owner'`) */
@@ -30,7 +37,7 @@ export declare class EntityIndex {
      */
     with(key: Component<unknown, unknown>, owner?: PlayerId): ReadonlySet<Entity>;
     /**
-     * Everything that has the component, in the order of the entities' ids: the order a walk through `World.actors`
+     * Everything that has the component, in the order of the entities' ids: the order a walk through `World.units`
      * meets them in. What a system that runs over a component goes through (`System.over`), so a game plays the same
      * as one that looks at every actor. A list of its own, kept until what has the component changes: what is given it
      * or loses it while the list is gone through is in the next one