@v12-engine/engine 0.1.1 → 0.4.0

package/dist/registry.js

@@ -0,0 +1,323 @@
+import { CORE_STAT_KEYS, noStats } from "./defs.js";
+import { engineEventById, isGameEvent } from "./events.js";
+import { defaultSettings } from "./rules.js";
+import { gameHash } from "./mods.js";
+import { DATA_KINDS } from "./gameData.js";
+import { Definitions } from "./definitions.js";
+//#region src/registry.ts
+/**
+* What is thrown for a component or an event of its own that a game uses without listing it (`Rules.components`,
+* `Rules.events`): no world finds it by its id, so a save, a snapshot or the index would lose it
+*
+* @beta
+*/
+var UnlistedError = class extends Error {
+	kind;
+	id;
+	game;
+	constructor(kind, id, game) {
+		super(`The ${kind} "${id}" is used by the game "${game}" without being listed in it: add it to Rules.${kind}s, as its timers and listeners are`);
+		this.kind = kind;
+		this.id = id;
+		this.game = game;
+		this.name = "UnlistedError";
+	}
+};
+/** A list's entries by id, with their place: worked out once a list (`tile`, `resource`, `tunable` are asked every tick) */
+var indexes = /* @__PURE__ */ new WeakMap();
+function indexOf(list) {
+	let index = indexes.get(list);
+	if (!index) indexes.set(list, index = new Map(list.map((def, at) => [def.id, {
+		def,
+		at
+	}])));
+	return index;
+}
+/**
+* The registry of a game's definitions and behaviours: unit types, abilities, orders, systems, buffs and the rest, by id
+*
+* @public
+*/
+var Registry = class {
+	/** The game's unit types, buildings and resources (`Rules.units`) */
+	units = new Definitions("unit type", void 0, (def) => {
+		if (def.kind !== "unit" && !def.footprint) throw new Error(`Unit type "${def.id}" needs a footprint`);
+	});
+	/** The orders units can be given, the engine's and the game's, by type */
+	orders = new Definitions("order type", (behavior) => behavior.type);
+	/** How groups line up (`Rules.formations`) */
+	formations = new Definitions("formation");
+	/** The game's research (`Rules.upgrades`) */
+	upgrades = new Definitions("upgrade");
+	/** Every ability there is, of units, heroes and items alike (`Rules.abilities`) */
+	abilities = new Definitions("ability");
+	/** The game's buffs (`Rules.buffs`) */
+	buffs = new Definitions("buff");
+	/** The game's items (`Rules.items`) */
+	items = new Definitions("item");
+	/** The tags of the game's items named and given a look (`Rules.tags`): a tag none names is its own word */
+	tags = new Definitions("tag");
+	/** The game's races, in its order (`Rules.races`): none in a game without */
+	races = new Definitions("race");
+	/** The game's prefabs (`Rules.prefabs`) */
+	prefabs = new Definitions("prefab");
+	/** The commands a world takes, the engine's and the game's, by type */
+	commands = new Definitions("command", (def) => def.type);
+	/** What each type of an ability's effect does, by type */
+	effects = new Definitions("effect type", (effect) => effect.type);
+	/** A game's own ways of aiming an ability (`Rules.targetings`), by name */
+	targetings = new Definitions("way of aiming");
+	/**
+	* The kinds of definition a game's data is kept for (`DataKind`), each its collection: what the Data panel, mods,
+	* saves and a game's reload walk, one loop each
+	*/
+	kinds = {
+		units: this.units,
+		abilities: this.abilities,
+		buffs: this.buffs,
+		items: this.items,
+		upgrades: this.upgrades,
+		races: this.races
+	};
+	/** The components the game lists (`Rules.components`), and those its app keeps in its worlds, by id */
+	components = /* @__PURE__ */ new Map();
+	/** The engine's own components (`coreComponents`) and the listed, by id: what `component` finds, in one look */
+	known = /* @__PURE__ */ new Map();
+	/** The events of its own the game lists (`Rules.events`), by id */
+	events = /* @__PURE__ */ new Map();
+	/**
+	* Takes in the engine's own components, which every game has (`coreComponents`)
+	*
+	* @internal
+	*/
+	defineCore(components) {
+		for (const component of components) if (!this.components.has(component.id)) this.known.set(component.id, component);
+	}
+	/** Takes in the components and events a game lists. Throws for an id that is there twice, another way */
+	defineParts(components, events) {
+		for (const component of components) {
+			const before = this.components.get(component.id);
+			if (before && before !== component) throw new Error(`The component "${component.id}" is there twice`);
+			this.components.set(component.id, component);
+			this.known.set(component.id, component);
+		}
+		for (const event of events) {
+			const before = this.events.get(event.id);
+			if (before && before !== event) throw new Error(`The event "${event.id}" is there twice`);
+			this.events.set(event.id, event);
+		}
+	}
+	/** A component of this game by its id: one the game lists, or one of the engine's own (`coreComponents`). None for any other */
+	component(id) {
+		return this.known.get(id);
+	}
+	/** A component of this game by its id, as something of the world uses it: throws for one the game does not list (`UnlistedError`) */
+	used(id) {
+		const found = this.component(id);
+		if (!found) throw new UnlistedError("component", id, this.game);
+		return found;
+	}
+	/**
+	* An event of the game's own by its id: listed, or the engine's (`core.`), as the engine defined it. One of a game's
+	* that it does not list throws (`UnlistedError`). Never another game's: a process may hold more than one, each
+	* defining an id its own way (E7)
+	*/
+	event(id) {
+		const listed = this.events.get(id) ?? engineEventById(id);
+		if (listed) return listed;
+		if (isGameEvent(id)) throw new UnlistedError("event", id, this.game);
+	}
+	/**
+	* The components the game lists, for what goes through them all: the map's fields they have
+	*
+	* @beta
+	*/
+	listedComponents() {
+		return this.components.values();
+	}
+	/** Whether the game lists a component or an event, or it is one of the engine's own */
+	lists(kind, id) {
+		return kind === "component" ? this.known.has(id) : this.events.has(id) || engineEventById(id) !== void 0;
+	}
+	/** The log of the world this is the registry of, once there is one (`World.log`) */
+	log;
+	/**
+	* Takes the definitions of another registry of the same game over its own (`world.reload`): its unit types,
+	* abilities, buffs, items, upgrades and races, the code of its effects and orders, its rules, and its module. Those
+	* it has that the other has not are kept (a world may have units of them). What the game is made of otherwise (its
+	* resources, stats, components, events) stays as it is: a world was made of it
+	*/
+	takeFrom(other) {
+		for (const kind of DATA_KINDS) this.kinds[kind].takeFrom(other.kinds[kind]);
+		this.effects.takeFrom(other.effects);
+		this.targetings.takeFrom(other.targetings);
+		this.orders.takeFrom(other.orders);
+		this.formations.takeFrom(other.formations);
+		this.tags.takeFrom(other.tags);
+		this.settings = other.settings;
+		this.score = other.score;
+		this.day = other.day;
+		this.report = other.report;
+		this.tunables = other.tunables;
+		this.files = new Map(other.files);
+		this.fileDefs = new Map(other.fileDefs);
+		this.upkeep = other.upkeep;
+		this.module = other.module;
+		this.hashed = this.dataHashed = void 0;
+	}
+	/** Lowest threshold first. Empty for a game without upkeep */
+	upkeep = [];
+	/** Id of the game module it was made from */
+	game = "";
+	/** The game module it was made from */
+	module = null;
+	hashed;
+	/** What identifies the game exactly, mods and code included (see `gameHash`). Worked out the first time it is asked for */
+	get hash() {
+		return this.hashed ??= this.module ? gameHash(this.module) : "";
+	}
+	dataHashed;
+	/**
+	* What identifies the game's data: everything but how its code reads (see `gameHash`). What a server and a player
+	* check they share: the two run builds of the same code that print it differently
+	*/
+	get dataHash() {
+		return this.dataHashed ??= this.module ? gameHash(this.module, { code: false }) : "";
+	}
+	/** The version of what the game keeps in a save (`Rules.saves.version`): 1 for a game that says none */
+	get saveVersion() {
+		return this.module?.saves?.version ?? 1;
+	}
+	/** The game's own stats, next to the engine's (`Rules.stats`) */
+	stats = [];
+	/** The game put together with its packs (`assembleGame`): set as the registry is made of it */
+	assembly = null;
+	/** The engine's parts and the game's that give an entity something as it is made (`Component.onSpawn`), in order */
+	spawning = [];
+	/** The engine's parts and the game's that call something off as an entity leaves its owner (`Component.onLeave`) */
+	leaving = [];
+	/** The engine's parts and the game's that may have a structure stand open, in nobody's way (`Component.passable`) */
+	passing = [];
+	/** Whether a structure stands open now, in nobody's way, by its parts (`Component.passable`): a gate opened */
+	standsOpen(entity) {
+		for (const part of this.passing) if (entity.has(part) && part.passable(entity.get(part), entity)) return true;
+		return false;
+	}
+	/** What the game's packs add to a unit's stats (`GamePack.stats`): a hero's growth */
+	statFields = [];
+	/** How each event of the world is told to a player, the engine's then the packs' (`replicateEvent`), in order */
+	replications = [];
+	/** The parts of a player's snapshot, the engine's then the packs' (`SnapshotField`), in order */
+	snapshotFields = [];
+	/** What the game counts of its players (`RuleSettings.score`), its stats made: null for a game that counts nothing */
+	score = null;
+	/** What each of the game's own files was read as (`Rules.files`), by id */
+	files = /* @__PURE__ */ new Map();
+	/** The game's own files (`Rules.files`), by id */
+	fileDefs = /* @__PURE__ */ new Map();
+	/** What the rules read of a file of the game's own data (`Rules.files`): throws for one the game does not list */
+	file(def) {
+		if (!this.files.has(def.id)) throw new Error(`The file "${def.id}" is not the game's: list it in Rules.files`);
+		return this.files.get(def.id);
+	}
+	/** Puts what a file of the game's is read as, for this registry's world alone: the editor's panel, as it is edited */
+	setFile(def, value) {
+		this.files.set(def.id, value);
+		this.fileDefs.set(def.id, def);
+	}
+	/** A file of the game's own data by its id (`waves.json`): what reads it, for an editor that writes it. None for one the game does not list */
+	fileDef(id) {
+		return this.fileDefs.get(id);
+	}
+	/** A prefab of the game's by id, for `world.spawnPrefab`; throws for one there is not */
+	prefab(id) {
+		const def = this.prefabs.find(id);
+		if (!def) throw new Error(`No prefab is called "${id}": list it in Rules.prefabs, or give the prefab itself`);
+		return def;
+	}
+	/** What the ground can be painted with, in the order of their indices: the first is 1 (`Rules.tiles`) */
+	tiles = [];
+	/** The game's layers of cells (`Rules.cellLayers`): what `Terrain.cells` is keyed by, with what each means */
+	cellLayers = [];
+	/** The numbers of the rules to be tuned while the game plays (`Rules.tunables`) */
+	tunables = [];
+	/** A tunable by id, or nothing for one the game does not have */
+	tunable(id) {
+		return indexOf(this.tunables).get(id)?.def;
+	}
+	/** The index of a tile of the game, for painting the ground in code: `terrain.tiles[cell] = registry.tile('road')` */
+	tile(id) {
+		const found = indexOf(this.tiles).get(id);
+		if (!found) throw new Error(`Unknown tile "${id}"`);
+		return found.at + 1;
+	}
+	/** The ids of the game's tiles, in the order of their indices */
+	get tileIds() {
+		return this.tiles.map((tile) => tile.id);
+	}
+	/** Every stat there is in the game, the engine's first */
+	statKeys = [...CORE_STAT_KEYS];
+	/** Every stat of the game at 0, its own at their default: what base stats start from */
+	statDefaults = noStats();
+	/** The game's numbers that are not about any one unit (`Rules.settings`) */
+	settings = defaultSettings;
+	/** Null for a game where it is always day */
+	day = null;
+	/** What the game tells each player about itself, see `Rules.report`. Asked by the session that runs the world */
+	report = null;
+	/** The resources of the game, in the order players are shown them */
+	resources = [];
+	/**
+	* The resource prices, bounties, revives and sales are in: the game's money. Null for a game without one,
+	* where there is nothing of that kind to pay with
+	*/
+	currency = null;
+	/** The command type, or undefined for one the game does not have: commands come from outside, and may name anything */
+	command(type) {
+		return this.commands.find(type);
+	}
+	/** The definition of a resource, or undefined for one the game does not have */
+	resource(id) {
+		return indexOf(this.resources).get(id)?.def;
+	}
+	/** A unit type by id: throws for one the game does not have (`units`) */
+	unit(id) {
+		return this.units.get(id);
+	}
+	/** An upgrade by id: throws for one the game does not have (`upgrades`) */
+	upgrade(id) {
+		return this.upgrades.get(id);
+	}
+	/** A race by id: throws for one the game does not have (`races`) */
+	race(id) {
+		return this.races.get(id);
+	}
+	/** An ability by id: throws for one the game does not have (`abilities`) */
+	ability(id) {
+		return this.abilities.get(id);
+	}
+	/** A buff by id: throws for one the game does not have (`buffs`) */
+	buff(id) {
+		return this.buffs.get(id);
+	}
+	/** An item by id: throws for one the game does not have (`items`) */
+	item(id) {
+		return this.items.get(id);
+	}
+	/** What an effect type does: throws for one there is not (`effects`) */
+	effect(type) {
+		return this.effects.get(type).run;
+	}
+	/** An order type's behaviour, typed by what its orders keep (`OrderStates`): throws for one there is not (`orders`) */
+	order(type) {
+		return this.orders.get(type);
+	}
+	/** A formation by id: throws for one there is not (`formations`) */
+	formation(id) {
+		return this.formations.get(id);
+	}
+};
+//#endregion
+export { Registry, UnlistedError };
+
+//# sourceMappingURL=registry.js.map

package/dist/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.js","names":[],"sources":["../src/registry.ts"],"sourcesContent":["import type { AdvanceState, AlongPath, AttackGroundState, AttackState, FollowState, HoldState, PatrolState } from './orders/basic'\nimport type { GameFileDef } from './gameFiles'\nimport type { ReplicatedEvent, SnapshotField } from './replication'\nimport { DATA_KINDS, type DataDefs, type DataKind } from './gameData'\nimport { Definitions } from './definitions'\nimport type { BuildState, RepairState, WorkState } from './orders/build'\nimport type { CastState } from './orders/cast'\nimport type { HarvestState } from './orders/harvest'\nimport type { ItemOrderState } from './orders/items'\nimport type { BoardState, LoadState, UnloadState } from './transport'\nimport type { RaceDef } from './races'\nimport type { Logger } from './log'\nimport type { Component } from './components'\nimport { engineEventById, type EventKey, isGameEvent } from './events'\nimport type { EffectHandler, EffectType } from './abilities/effects'\nimport type { Targeting } from './targeting'\nimport type { CommandDef } from './commands'\nimport {\n\ttype AbilityDef,\n\ttype BuffDef,\n\tCORE_STAT_KEYS,\n\ttype DayCycle,\n\ttype ItemDef,\n\tnoStats,\n\ttype ResourceDef,\n\ttype ResourceId,\n\ttype StatDef,\n\ttype Stats,\n\ttype TagDef,\n\ttype UnitTypeDef,\n\ttype UpgradeDef,\n\ttype UpkeepTier\n} from './defs'\nimport type { Entity, EntityId, Order, PlayerId } from './entity'\nimport type { Vec2 } from './math'\nimport type { StatField } from './stats'\nimport type { FormationDef } from './formation'\nimport type { AssembledGame, Rules } from './game'\nimport { gameHash } from './mods'\nimport { defaultSettings, type RuleSettings } from './rules'\nimport type { TileDef } from './tiles'\nimport type { PrefabDef } from './prefabs'\nimport type { TunableDef } from './tunables'\nimport type { World } from './world'\nimport type { CellLayerDef } from './cellLayers'\nimport type { ResolvedScore } from './score'\n\n/**\n * Where an order stands after an update: still `running`, `done`, or `failed`\n *\n * @beta\n */\nexport type OrderStatus = 'running' | 'done' | 'failed'\n\n/**\n * What an order can be given, every order's field in one: for what reads an order of any type (the queue, a save, a\n * screen's waypoints). An order of a type is given its own of them (`OrderInits`)\n *\n * @beta\n */\nexport interface OrderParams {\n\t/** The entity an order is aimed at: to attack, follow, harvest from, repair, board or load */\n\ttarget?: EntityId\n\t/** The point an order is aimed at, in world coordinates */\n\tpoint?: Vec2\n\t/** Type to build, for build orders */\n\tunitType?: string\n\t/** Ability to use, for cast orders */\n\tability?: string\n\t/** For an ability aimed along two points (`vector`): the second, the way it goes from `point` */\n\tto?: Vec2\n\t/** An item: the one to use, drop or hand over by its place in the inventory, or the one on the ground to pick up */\n\titem?: number\n\t/** Direction to face at the end. Commands fill this in with the direction of travel */\n\tfacing?: number\n\t/**\n\t * For a move: the group goes at the pace of its slowest (campaign plan GP1), so that it arrives together. The\n\t * command works the pace out (`speedCap`)\n\t */\n\ttogether?: boolean\n\t/** For a move: the fastest it goes, set by the command for a group that goes `together`: the slowest one's speed */\n\tspeedCap?: number\n\t/** A path of the map, by its name (`MapPath`): for the orders that go along one (`followPath`, `attackPath`) */\n\tpath?: string\n\t/**\n\t * Which way along `path`: to its first point or its last. Away from the end the unit is nearer to when left out: a\n\t * minion back on its lane after a chase, past its middle, goes on the way it was going\n\t */\n\ttowards?: 'first' | 'last'\n}\n\n/**\n * What each order type is given (`Order.init`), by type (design review E14): the engine's, and a game's own added by\n * declaration merging, as `OrderStates` is:\n *\n * ```ts\n * declare module '@v12-engine/engine' {\n * \tinterface OrderInits {\n * \t\t'mygame.dig': { point?: Vec2 }\n * \t}\n * }\n * ```\n *\n * Every field may be missing from what a command sends, which comes from a player: the behaviour's `accepts` checks\n * what it needs\n *\n * @beta\n */\nexport interface OrderInits {\n\t/** What a `move` order is given (`Order.init`): point, facing, target, together and speedCap: where to, which way to face at the end, an entity to go to, group pace */\n\tmove: Pick<OrderParams, 'point' | 'facing' | 'target' | 'together' | 'speedCap'>\n\t/** What a `hold` order is given (`Order.init`): facing: which way to face while holding */\n\thold: Pick<OrderParams, 'facing'>\n\t/** What a `attack` order is given (`Order.init`): the target to attack and the facing to keep */\n\tattack: Pick<OrderParams, 'target' | 'facing'>\n\t/** What a `attackMove` order is given (`Order.init`): the point to advance to, fighting what it meets, and the facing at the end */\n\tattackMove: Pick<OrderParams, 'point' | 'facing'>\n\t/** What a `followPath` order is given (`Order.init`): the map path to follow by name and which end (`towards`) to go to */\n\tfollowPath: Pick<OrderParams, 'path' | 'towards'>\n\t/** What a `attackPath` order is given (`Order.init`): the map path to advance along, fighting, and which end (`towards`) to go to */\n\tattackPath: Pick<OrderParams, 'path' | 'towards'>\n\t/** What a `patrolPath` order is given (`Order.init`): the map path to patrol along and which end (`towards`) to start towards */\n\tpatrolPath: Pick<OrderParams, 'path' | 'towards'>\n\t/** What a `patrol` order is given (`Order.init`): the point to patrol to and back from, and the facing */\n\tpatrol: Pick<OrderParams, 'point' | 'facing'>\n\t/** What a `follow` order is given (`Order.init`): the entity to follow */\n\tfollow: Pick<OrderParams, 'target'>\n\t/** What a `attackGround` order is given (`Order.init`): the point to attack and optionally an entity there */\n\tattackGround: Pick<OrderParams, 'point' | 'target'>\n\t/** What a `cast` order is given (`Order.init`): the ability, an item to use, the target, the point and the second point (`to`) of a vector ability */\n\tcast: Pick<OrderParams, 'ability' | 'item' | 'target' | 'point' | 'to'>\n\t/** What a `harvest` order is given (`Order.init`): the resource entity to gather from */\n\tharvest: Pick<OrderParams, 'target'>\n\t/** What a `return` order is given (`Order.init`): the hall to hand in at; the resource to go back to when left out */\n\treturn: Pick<OrderParams, 'target'>\n\t/** What a `build` order is given (`Order.init`): the unit type to build, the point and the facing of the site */\n\tbuild: Pick<OrderParams, 'unitType' | 'point' | 'facing'>\n\t/** What a `construct` order is given (`Order.init`): the unfinished building to work on */\n\tconstruct: Pick<OrderParams, 'target'>\n\t/** What a `repair` order is given (`Order.init`): the building to repair */\n\trepair: Pick<OrderParams, 'target'>\n\t/** What a `pickUp` order is given (`Order.init`): the item on the ground to pick up (`target`) and the inventory slot */\n\tpickUp: Pick<OrderParams, 'target' | 'item'>\n\t/** What a `dropItem` order is given (`Order.init`): the inventory slot to drop, and the point or the unit to drop it at */\n\tdropItem: Pick<OrderParams, 'item' | 'point' | 'target'>\n\t/** What a `board` order is given (`Order.init`): the transport to board */\n\tboard: Pick<OrderParams, 'target'>\n\t/** What a `load` order is given (`Order.init`): the unit for a transport to load */\n\tload: Pick<OrderParams, 'target'>\n\t/** What a `unload` order is given (`Order.init`): the point to unload the cargo at */\n\tunload: Pick<OrderParams, 'point'>\n}\n\n/**\n * What an order of a type is given: its `OrderInits` entry, every order's fields (`OrderParams`) for a type not in it\n *\n * @beta\n */\nexport type OrderInitOf<Type extends string> = Type extends keyof OrderInits ? OrderInits[Type] : OrderParams\n\n/**\n * What a command asks a unit to do: the order's type and what it is given (`OrderInitOf`). Turned into an `Order` once\n * it is accepted\n *\n * @beta\n */\nexport type OrderInit<Type extends string = string> = {\n\ttype: Type\n\t/**\n\t * The formation units ordered to a point together take, by id (`FormationDef`): the engine's `rows`, `circle`,\n\t * `square` or `none`, or a game's own. What the rules say (`RuleSettings.movement.formation`: `rows`) when left out\n\t */\n\tformation?: string\n} & OrderInitOf<Type>\n\n/**\n * Logic behind an order type. Orders are the only way units act, which is what\n * makes queueing work for everything. Game modules can register their own.\n *\n * `State` is what it keeps in the order (`Order.state`), every field optional: the order starts with none of them.\n * `OrderStates` names each order type's, for `registry.order(type)` to hand back the behaviour typed\n *\n * @public\n */\nexport interface OrderBehavior<State extends object = Record<string, any>, Init extends object = OrderParams> {\n\t/** The order type this behaviour handles, the key of `registry.order` and of `Order.type` */\n\ttype: string\n\t/** Units ordered to a point together are spread out in a formation instead of all walking to the same spot */\n\tformation?: boolean\n\t/** Whether the entity is able to carry out this order at all */\n\taccepts(world: World, entity: Entity, init: Init): boolean\n\t/** Called once when the order reaches the front of the queue */\n\tstart?(world: World, entity: Entity, order: Order<State, Init>): void\n\t/** Runs each tick while the order is at the front; returns whether it is still running, done or failed. `dt` is the tick's seconds */\n\tupdate(world: World, entity: Entity, order: Order<State, Init>, dt: number): OrderStatus\n\t/** Called when the order finishes or is interrupted, to undo anything it left behind */\n\tend?(world: World, entity: Entity, order: Order<State, Init>): void\n\t/**\n\t * Whether the unit is in the middle of it and cannot be called away (a cast past turning back): what was to come\n\t * after is dropped, it is finished first (`interrupt`). Never, when left out\n\t */\n\tcommitted?(order: Order<State, Init>): boolean\n\t/**\n\t * Whether the unit stands waiting by a fight for a spot in it (an attack or an attack-move held up: `holdOff`): an\n\t * ally on its way may ask it aside (`settings.movement.makesWay`). Never, when left out\n\t */\n\twaiting?(order: Order<State, Init>): boolean\n\t/** Whether the unit keeps something up that being stunned breaks off (a channelled ability). Never, when left out */\n\tchannelling?(order: Order<State, Init>): boolean\n\t/** Whether the unit has begun what it builds (its site is down): what it builds is counted as itself. Never, when left out */\n\tbuilding?(order: Order<State, Init>): boolean\n}\n\n/**\n * A fact the engine asks of an order, its behaviour's to say (`OrderBehavior.committed`, `waiting`, `channelling`,\n * `building`)\n *\n * @beta\n */\nexport type OrderFact = 'committed' | 'waiting' | 'channelling' | 'building'\n\n/**\n * What each order type keeps in its orders (`Order.state`), by type: the engine's, and a game's own added to it by\n * declaration merging, for `registry.order(type)` to say what its behaviour keeps:\n *\n * ```ts\n * declare module '@v12-engine/engine' {\n * \tinterface OrderStates {\n * \t\t'mygame.dig': { dug?: number }\n * \t}\n * }\n * ```\n *\n * @beta\n */\nexport interface OrderStates {\n\t/** What a `move` order keeps in `Order.state` */\n\tmove: NoState\n\t/** What a `hold` order keeps in `Order.state` */\n\thold: HoldState\n\t/** What a `attack` order keeps in `Order.state` */\n\tattack: AttackState\n\t/** What a `attackMove` order keeps in `Order.state` */\n\tattackMove: AdvanceState\n\t/** What a `followPath` order keeps in `Order.state` */\n\tfollowPath: AlongPath\n\t/** What a `attackPath` order keeps in `Order.state` */\n\tattackPath: AlongPath & AdvanceState\n\t/** What a `patrol` order keeps in `Order.state` */\n\tpatrol: PatrolState\n\t/** What a `follow` order keeps in `Order.state` */\n\tfollow: FollowState\n\t/** What a `attackGround` order keeps in `Order.state` */\n\tattackGround: AttackGroundState\n\t/** What a `cast` order keeps in `Order.state` */\n\tcast: CastState\n\t/** What a `harvest` order keeps in `Order.state` */\n\tharvest: HarvestState\n\t/** What a `return` order keeps in `Order.state` */\n\treturn: HarvestState\n\t/** What a `build` order keeps in `Order.state` */\n\tbuild: BuildState\n\t/** What a `construct` order keeps in `Order.state` */\n\tconstruct: WorkState\n\t/** What a `repair` order keeps in `Order.state` */\n\trepair: RepairState\n\t/** What a `pickUp` order keeps in `Order.state` */\n\tpickUp: ItemOrderState\n\t/** What a `dropItem` order keeps in `Order.state` */\n\tdropItem: ItemOrderState\n\t/** What a `board` order keeps in `Order.state` */\n\tboard: BoardState\n\t/** What a `load` order keeps in `Order.state` */\n\tload: LoadState\n\t/** What a `unload` order keeps in `Order.state` */\n\tunload: UnloadState\n}\n\n/**\n * What an order that keeps nothing keeps\n *\n * @beta\n */\nexport type NoState = Record<string, never>\n\n/**\n * What an order of a type keeps: its `OrderStates` entry, any plain data for a type not in it\n *\n * @beta\n */\nexport type OrderStateOf<Type extends string> = Type extends keyof OrderStates ? OrderStates[Type] : Record<string, any>\n\n/**\n * The part of a tick a system runs in, see `PHASES` in the scheduler\n *\n * @beta\n */\nexport type SystemPhase = 'commands' | 'decide' | 'move' | 'resolve' | 'cleanup'\n\n/**\n * Something that runs every tick, or every few: moves units, lands attacks, works out what each team sees.\n * When it runs is worked out once, from its phase, then from what it says it comes before and after.\n *\n * @public\n */\nexport interface System {\n\t/** Unique in a world. A game's system with the name of a core one takes its place */\n\tname: string\n\t/** `cleanup` when left out: after everything else in the tick */\n\tphase?: SystemPhase\n\t/** Names of systems in the same phase this one runs ahead of, or after */\n\tbefore?: string[]\n\t/** Names of systems in the same phase this one runs after */\n\tafter?: string[]\n\t/** Runs once in so many ticks, for work that does not need doing every tick. Every tick when left out */\n\tevery?: number\n\t/** With `every`, the tick in each round it runs at: systems with the same `every` and other offsets spread the work */\n\toffset?: number\n\t/**\n\t * `dt` is the time since it last ran: the length of a tick, times `every`. Before `each`, for a system that has\n\t * both. One of the two is needed\n\t */\n\tupdate?(world: World, dt: number): void\n\t/**\n\t * What `each` is run for (OB5): every unit (`'units'`, when left out, in `World.units`' order), what has a component,\n\t * in the order of its id (`EntityIndex.ordered`: a system about a few, like the buildings that train, does not look\n\t * at every unit and tree), or the units a test says yes to. The two orders differ for scenery woken into a unit\n\t * (`Spawning.wake`), which `World.units` has last: moving a system from one to the other can change which of two\n\t * equals goes first, unless it breaks ties by id\n\t *\n\t * @beta\n\t */\n\tover?: SystemOver\n\t/**\n\t * Run for each entity of `over`, in order, after `update`. The dead are not left out: a system that wants only the\n\t * living says so\n\t *\n\t * @beta\n\t */\n\teach?(world: World, entity: Entity, dt: number): void\n\t/**\n\t * What it keeps in itself, for a save: plain data. For state that is easier kept in a system than in a component\n\t * (`World.state`): a computer player's plans, a director's mood\n\t */\n\tsave?(world: World): unknown\n\t/** Takes back what `save` gave, in a world loaded from a save: when it is made, or added again (`addSystem`) */\n\trestore?(world: World, data: unknown): void\n}\n\n/**\n * What a system runs `each` for (`System.over`): every unit, what has a component, or the units a test says yes to\n *\n * @beta\n */\nexport type SystemOver = 'units' | Component<unknown, unknown> | ((entity: Entity, world: World) => boolean)\n\n/**\n * A system, or what makes one for each world: for a system that keeps state of its own, which belongs to one game\n *\n * @public\n */\nexport type SystemDef = System | ((world: World) => System)\n\n/**\n * What is thrown for a component or an event of its own that a game uses without listing it (`Rules.components`,\n * `Rules.events`): no world finds it by its id, so a save, a snapshot or the index would lose it\n *\n * @beta\n */\nexport class UnlistedError extends Error {\n\tconstructor(\n\t\t/** What it is: a component or an event */\n\t\treadonly kind: 'component' | 'event',\n\t\t/** Its id */\n\t\treadonly id: string,\n\t\t/** The id of the game that used it */\n\t\treadonly game: string\n\t) {\n\t\tsuper(`The ${kind} \"${id}\" is used by the game \"${game}\" without being listed in it: add it to Rules.${kind}s, as its timers and listeners are`)\n\t\tthis.name = 'UnlistedError'\n\t}\n}\n\n/** A list's entries by id, with their place: worked out once a list (`tile`, `resource`, `tunable` are asked every tick) */\nconst indexes = new WeakMap<readonly { id: string }[], Map<string, { def: never; at: number }>>()\nfunction indexOf<T extends { id: string }>(list: readonly T[]): Map<string, { def: T; at: number }> {\n\tlet index = indexes.get(list)\n\tif (!index) indexes.set(list, (index = new Map(list.map((def, at) => [def.id, { def: def as never, at }]))))\n\treturn index as Map<string, { def: T; at: number }>\n}\n\n/**\n * The registry of a game's definitions and behaviours: unit types, abilities, orders, systems, buffs and the rest, by id\n *\n * @public\n */\nexport class Registry {\n\t/** The game's unit types, buildings and resources (`Rules.units`) */\n\treadonly units = new Definitions<UnitTypeDef>('unit type', undefined, (def) => {\n\t\tif (def.kind !== 'unit' && !def.footprint) throw new Error(`Unit type \"${def.id}\" needs a footprint`)\n\t})\n\t/** The orders units can be given, the engine's and the game's, by type */\n\treadonly orders = new Definitions<OrderBehavior>('order type', (behavior) => behavior.type)\n\t/** How groups line up (`Rules.formations`) */\n\treadonly formations = new Definitions<FormationDef>('formation')\n\t/** The game's research (`Rules.upgrades`) */\n\treadonly upgrades = new Definitions<UpgradeDef>('upgrade')\n\t/** Every ability there is, of units, heroes and items alike (`Rules.abilities`) */\n\treadonly abilities = new Definitions<AbilityDef>('ability')\n\t/** The game's buffs (`Rules.buffs`) */\n\treadonly buffs = new Definitions<BuffDef>('buff')\n\t/** The game's items (`Rules.items`) */\n\treadonly items = new Definitions<ItemDef>('item')\n\t/** The tags of the game's items named and given a look (`Rules.tags`): a tag none names is its own word */\n\treadonly tags = new Definitions<TagDef>('tag')\n\t/** The game's races, in its order (`Rules.races`): none in a game without */\n\treadonly races = new Definitions<RaceDef>('race')\n\t/** The game's prefabs (`Rules.prefabs`) */\n\treadonly prefabs = new Definitions<PrefabDef>('prefab')\n\t/** The commands a world takes, the engine's and the game's, by type */\n\treadonly commands = new Definitions<CommandDef>('command', (def) => def.type)\n\t/** What each type of an ability's effect does, by type */\n\treadonly effects = new Definitions<EffectType>('effect type', (effect) => effect.type)\n\t/** A game's own ways of aiming an ability (`Rules.targetings`), by name */\n\treadonly targetings = new Definitions<Targeting>('way of aiming')\n\t/**\n\t * The kinds of definition a game's data is kept for (`DataKind`), each its collection: what the Data panel, mods,\n\t * saves and a game's reload walk, one loop each\n\t */\n\treadonly kinds: { readonly [K in DataKind]: Definitions<DataDefs[K]> } = {\n\t\tunits: this.units,\n\t\tabilities: this.abilities,\n\t\tbuffs: this.buffs,\n\t\titems: this.items,\n\t\tupgrades: this.upgrades,\n\t\traces: this.races\n\t}\n\t/** The components the game lists (`Rules.components`), and those its app keeps in its worlds, by id */\n\tprivate readonly components = new Map<string, Component<unknown>>()\n\t/** The engine's own components (`coreComponents`) and the listed, by id: what `component` finds, in one look */\n\tprivate readonly known = new Map<string, Component<unknown>>()\n\t/** The events of its own the game lists (`Rules.events`), by id */\n\tprivate readonly events = new Map<string, EventKey<unknown>>()\n\n\t/**\n\t * Takes in the engine's own components, which every game has (`coreComponents`)\n\t *\n\t * @internal\n\t */\n\tdefineCore(components: readonly Component<unknown>[]): void {\n\t\tfor (const component of components) if (!this.components.has(component.id)) this.known.set(component.id, component)\n\t}\n\n\t/** Takes in the components and events a game lists. Throws for an id that is there twice, another way */\n\tdefineParts(components: readonly Component<unknown>[], events: readonly EventKey<unknown>[]): void {\n\t\tfor (const component of components) {\n\t\t\tconst before = this.components.get(component.id)\n\t\t\tif (before && before !== component) throw new Error(`The component \"${component.id}\" is there twice`)\n\t\t\tthis.components.set(component.id, component)\n\t\t\tthis.known.set(component.id, component)\n\t\t}\n\t\tfor (const event of events) {\n\t\t\tconst before = this.events.get(event.id)\n\t\t\tif (before && before !== event) throw new Error(`The event \"${event.id}\" is there twice`)\n\t\t\tthis.events.set(event.id, event)\n\t\t}\n\t}\n\n\t/** A component of this game by its id: one the game lists, or one of the engine's own (`coreComponents`). None for any other */\n\tcomponent(id: string): Component<unknown> | undefined {\n\t\treturn this.known.get(id)\n\t}\n\n\t/** A component of this game by its id, as something of the world uses it: throws for one the game does not list (`UnlistedError`) */\n\tused(id: string): Component<unknown> {\n\t\tconst found = this.component(id)\n\t\tif (!found) throw new UnlistedError('component', id, this.game)\n\t\treturn found\n\t}\n\n\t/**\n\t * An event of the game's own by its id: listed, or the engine's (`core.`), as the engine defined it. One of a game's\n\t * that it does not list throws (`UnlistedError`). Never another game's: a process may hold more than one, each\n\t * defining an id its own way (E7)\n\t */\n\tevent(id: string): EventKey<unknown> | undefined {\n\t\tconst listed = this.events.get(id) ?? engineEventById(id)\n\t\tif (listed) return listed\n\t\tif (isGameEvent(id)) throw new UnlistedError('event', id, this.game)\n\t\treturn undefined\n\t}\n\n\t/**\n\t * The components the game lists, for what goes through them all: the map's fields they have\n\t *\n\t * @beta\n\t */\n\tlistedComponents(): Iterable<Component<unknown, unknown>> {\n\t\treturn this.components.values()\n\t}\n\n\t/** Whether the game lists a component or an event, or it is one of the engine's own */\n\tlists(kind: 'component' | 'event', id: string): boolean {\n\t\treturn kind === 'component' ? this.known.has(id) : this.events.has(id) || engineEventById(id) !== undefined\n\t}\n\n\t/** The log of the world this is the registry of, once there is one (`World.log`) */\n\tlog?: Logger\n\n\t/**\n\t * Takes the definitions of another registry of the same game over its own (`world.reload`): its unit types,\n\t * abilities, buffs, items, upgrades and races, the code of its effects and orders, its rules, and its module. Those\n\t * it has that the other has not are kept (a world may have units of them). What the game is made of otherwise (its\n\t * resources, stats, components, events) stays as it is: a world was made of it\n\t */\n\ttakeFrom(other: Registry): void {\n\t\tfor (const kind of DATA_KINDS) (this.kinds[kind] as Definitions<unknown>).takeFrom(other.kinds[kind] as Definitions<unknown>)\n\t\tthis.effects.takeFrom(other.effects)\n\t\tthis.targetings.takeFrom(other.targetings)\n\t\tthis.orders.takeFrom(other.orders)\n\t\tthis.formations.takeFrom(other.formations)\n\t\tthis.tags.takeFrom(other.tags)\n\t\tthis.settings = other.settings\n\t\tthis.score = other.score\n\t\tthis.day = other.day\n\t\tthis.report = other.report\n\t\tthis.tunables = other.tunables\n\t\tthis.files = new Map(other.files)\n\t\tthis.fileDefs = new Map(other.fileDefs)\n\t\tthis.upkeep = other.upkeep\n\t\tthis.module = other.module\n\t\t// what identifies the game is worked out again, of the module as it is now\n\t\tthis.hashed = this.dataHashed = undefined\n\t}\n\n\t/** Lowest threshold first. Empty for a game without upkeep */\n\tupkeep: UpkeepTier[] = []\n\t/** Id of the game module it was made from */\n\tgame = ''\n\t/** The game module it was made from */\n\tmodule: Rules | null = null\n\tprivate hashed?: string\n\n\t/** What identifies the game exactly, mods and code included (see `gameHash`). Worked out the first time it is asked for */\n\tget hash(): string {\n\t\treturn (this.hashed ??= this.module ? gameHash(this.module) : '')\n\t}\n\n\tprivate dataHashed?: string\n\n\t/**\n\t * What identifies the game's data: everything but how its code reads (see `gameHash`). What a server and a player\n\t * check they share: the two run builds of the same code that print it differently\n\t */\n\tget dataHash(): string {\n\t\treturn (this.dataHashed ??= this.module ? gameHash(this.module, { code: false }) : '')\n\t}\n\n\t/** The version of what the game keeps in a save (`Rules.saves.version`): 1 for a game that says none */\n\tget saveVersion(): number {\n\t\treturn this.module?.saves?.version ?? 1\n\t}\n\t/** The game's own stats, next to the engine's (`Rules.stats`) */\n\tstats: StatDef[] = []\n\t/** The game put together with its packs (`assembleGame`): set as the registry is made of it */\n\tassembly: AssembledGame | null = null\n\t/** The engine's parts and the game's that give an entity something as it is made (`Component.onSpawn`), in order */\n\tspawning: readonly Component<unknown, unknown>[] = []\n\t/** The engine's parts and the game's that call something off as an entity leaves its owner (`Component.onLeave`) */\n\tleaving: readonly Component<unknown, unknown>[] = []\n\t/** The engine's parts and the game's that may have a structure stand open, in nobody's way (`Component.passable`) */\n\tpassing: readonly Component<unknown, unknown>[] = []\n\t/** Whether a structure stands open now, in nobody's way, by its parts (`Component.passable`): a gate opened */\n\tstandsOpen(entity: Entity): boolean {\n\t\tfor (const part of this.passing) if (entity.has(part) && part.passable!(entity.get(part)!, entity)) return true\n\t\treturn false\n\t}\n\t/** What the game's packs add to a unit's stats (`GamePack.stats`): a hero's growth */\n\tstatFields: StatField[] = []\n\t/** How each event of the world is told to a player, the engine's then the packs' (`replicateEvent`), in order */\n\treplications: readonly ReplicatedEvent[] = []\n\t/** The parts of a player's snapshot, the engine's then the packs' (`SnapshotField`), in order */\n\tsnapshotFields: readonly SnapshotField[] = []\n\t/** What the game counts of its players (`RuleSettings.score`), its stats made: null for a game that counts nothing */\n\tscore: ResolvedScore | null = null\n\t/** What each of the game's own files was read as (`Rules.files`), by id */\n\tprivate files = new Map<string, unknown>()\n\t/** The game's own files (`Rules.files`), by id */\n\tprivate fileDefs = new Map<string, GameFileDef<unknown>>()\n\n\t/** What the rules read of a file of the game's own data (`Rules.files`): throws for one the game does not list */\n\tfile<T>(def: GameFileDef<T>): T {\n\t\tif (!this.files.has(def.id)) throw new Error(`The file \"${def.id}\" is not the game's: list it in Rules.files`)\n\t\treturn this.files.get(def.id) as T\n\t}\n\n\t/** Puts what a file of the game's is read as, for this registry's world alone: the editor's panel, as it is edited */\n\tsetFile<T>(def: GameFileDef<T>, value: T): void {\n\t\tthis.files.set(def.id, value)\n\t\tthis.fileDefs.set(def.id, def as GameFileDef<unknown>)\n\t}\n\n\t/** A file of the game's own data by its id (`waves.json`): what reads it, for an editor that writes it. None for one the game does not list */\n\tfileDef(id: string): GameFileDef<unknown> | undefined {\n\t\treturn this.fileDefs.get(id)\n\t}\n\n\t/** A prefab of the game's by id, for `world.spawnPrefab`; throws for one there is not */\n\tprefab(id: string): PrefabDef {\n\t\tconst def = this.prefabs.find(id)\n\t\tif (!def) throw new Error(`No prefab is called \"${id}\": list it in Rules.prefabs, or give the prefab itself`)\n\t\treturn def\n\t}\n\n\t/** What the ground can be painted with, in the order of their indices: the first is 1 (`Rules.tiles`) */\n\ttiles: TileDef[] = []\n\t/** The game's layers of cells (`Rules.cellLayers`): what `Terrain.cells` is keyed by, with what each means */\n\tcellLayers: CellLayerDef[] = []\n\t/** The numbers of the rules to be tuned while the game plays (`Rules.tunables`) */\n\ttunables: TunableDef[] = []\n\n\t/** A tunable by id, or nothing for one the game does not have */\n\ttunable(id: string): TunableDef | undefined {\n\t\treturn indexOf(this.tunables).get(id)?.def\n\t}\n\n\t/** The index of a tile of the game, for painting the ground in code: `terrain.tiles[cell] = registry.tile('road')` */\n\ttile(id: string): number {\n\t\tconst found = indexOf(this.tiles).get(id)\n\t\tif (!found) throw new Error(`Unknown tile \"${id}\"`)\n\t\treturn found.at + 1\n\t}\n\n\t/** The ids of the game's tiles, in the order of their indices */\n\tget tileIds(): string[] {\n\t\treturn this.tiles.map((tile) => tile.id)\n\t}\n\t/** Every stat there is in the game, the engine's first */\n\tstatKeys: string[] = [...CORE_STAT_KEYS]\n\t/** Every stat of the game at 0, its own at their default: what base stats start from */\n\tstatDefaults: Readonly<Stats> = noStats() as Stats\n\t/** The game's numbers that are not about any one unit (`Rules.settings`) */\n\tsettings: Readonly<RuleSettings> = defaultSettings\n\t/** Null for a game where it is always day */\n\tday: DayCycle | null = null\n\t/** What the game tells each player about itself, see `Rules.report`. Asked by the session that runs the world */\n\treport: ((world: World, player: PlayerId) => Record<string, unknown>) | null = null\n\t/** The resources of the game, in the order players are shown them */\n\tresources: ResourceDef[] = []\n\t/**\n\t * The resource prices, bounties, revives and sales are in: the game's money. Null for a game without one,\n\t * where there is nothing of that kind to pay with\n\t */\n\tcurrency: ResourceId | null = null\n\t/** The command type, or undefined for one the game does not have: commands come from outside, and may name anything */\n\tcommand(type: string): CommandDef | undefined {\n\t\treturn this.commands.find(type)\n\t}\n\n\t/** The definition of a resource, or undefined for one the game does not have */\n\tresource(id: ResourceId): ResourceDef | undefined {\n\t\treturn indexOf(this.resources).get(id)?.def\n\t}\n\n\t/** A unit type by id: throws for one the game does not have (`units`) */\n\tunit(id: string): UnitTypeDef {\n\t\treturn this.units.get(id)\n\t}\n\n\t/** An upgrade by id: throws for one the game does not have (`upgrades`) */\n\tupgrade(id: string): UpgradeDef {\n\t\treturn this.upgrades.get(id)\n\t}\n\n\t/** A race by id: throws for one the game does not have (`races`) */\n\trace(id: string): RaceDef {\n\t\treturn this.races.get(id)\n\t}\n\n\t/** An ability by id: throws for one the game does not have (`abilities`) */\n\tability(id: string): AbilityDef {\n\t\treturn this.abilities.get(id)\n\t}\n\n\t/** A buff by id: throws for one the game does not have (`buffs`) */\n\tbuff(id: string): BuffDef {\n\t\treturn this.buffs.get(id)\n\t}\n\n\t/** An item by id: throws for one the game does not have (`items`) */\n\titem(id: string): ItemDef {\n\t\treturn this.items.get(id)\n\t}\n\n\t/** What an effect type does: throws for one there is not (`effects`) */\n\teffect(type: string): EffectHandler {\n\t\treturn this.effects.get(type).run as EffectHandler\n\t}\n\n\t/** An order type's behaviour, typed by what its orders keep (`OrderStates`): throws for one there is not (`orders`) */\n\torder<Type extends string>(type: Type): OrderBehavior<OrderStateOf<Type>, OrderInitOf<Type>> {\n\t\treturn this.orders.get(type) as unknown as OrderBehavior<OrderStateOf<Type>, OrderInitOf<Type>>\n\t}\n\n\t/** A formation by id: throws for one there is not (`formations`) */\n\tformation(id: string): FormationDef {\n\t\treturn this.formations.get(id)\n\t}\n}\n"],"mappings":"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"}

package/dist/remains.d.ts

@@ -1,5 +1,5 @@
 import type { GamePack } from './packs/pack';
-import type { ResourceKind, UnitTypeDef } from './defs';
+import type { ResourceId, UnitTypeDef } from './defs';
 import type { Entity, PlayerId } from './entity';
 import type { World } from './world';
 /**
@@ -9,11 +9,13 @@ import type { World } from './world';
  * @beta
  */
 export interface RemainsSpec {
+    /** The unit type of the rubble or pile left behind, a resource-bearing type */
     type: string;
+    /** How much of the resource it holds; the type's `resource.amount` when left out */
     amount?: number;
 }
 /**
- * What the remains of a game are made of (`withRemains`)
+ * What the remains of a game are made of (`remainsPack`)
  *
  * @beta
  */
@@ -39,10 +41,10 @@ export interface RemainsOptions {
  * @beta
  */
 export declare const pileOf: import("./components").Component<{
-    kind: ResourceKind;
+    kind: ResourceId;
     amount: number;
 }, {
-    kind: ResourceKind;
+    kind: ResourceId;
     amount: number;
 }>;
 /** The piles there are and the rubble to put down once the building it is of is gone, kept with the world */
@@ -72,7 +74,7 @@ export declare const pileTaken: import("./events").EventKey<{
     pile: number;
     by: number;
     player: PlayerId;
-    kind: ResourceKind;
+    kind: ResourceId;
     amount: number;
 }>;
 /**
@@ -88,7 +90,7 @@ export declare function rubbleType(def: {
         w: number;
         d: number;
     };
-    kind: ResourceKind;
+    kind: ResourceId;
     amount?: number;
     slots?: number;
 }): UnitTypeDef;
@@ -102,11 +104,11 @@ export declare function rubbleType(def: {
 export declare function pileType(def: {
     id: string;
     name?: string;
-    kind: ResourceKind;
+    kind: ResourceId;
     amount?: number;
 }): UnitTypeDef & {
     pile: {
-        kind: ResourceKind;
+        kind: ResourceId;
         amount: number;
     };
 };
@@ -116,4 +118,4 @@ export declare function pileType(def: {
  *
  * @beta
  */
-export declare function withRemains(options?: RemainsOptions): GamePack;
+export declare function remainsPack(options?: RemainsOptions): GamePack;

package/dist/remains.js

@@ -0,0 +1,188 @@
+import { defineComponent } from "./components.js";
+import { defineEngineEvent } from "./events.js";
+import { deposit } from "./entity.js";
+import { earn } from "./player.js";
+import { defineHook } from "./hooks.js";
+import "./map/types.js";
+//#region src/remains.ts
+/**
+* What a pile holds: the resource and how much. Told to everyone, for its look and its tooltip
+*
+* @beta
+*/
+var pileOf = defineComponent({
+	id: "core.pile",
+	replicate: "everyone"
+});
+/** The piles there are and the rubble to put down once the building it is of is gone, kept with the world */
+var remains = defineComponent({
+	id: "core.remains",
+	default: () => ({
+		piles: [],
+		rubble: {}
+	})
+});
+/**
+* A pile was picked up: by whom (a unit's id and its owner), what and how much
+*
+* @beta
+*/
+var pileTaken = defineEngineEvent({
+	id: "core.pileTaken",
+	replicate: "everyone"
+});
+/** The player the map's neutral things are of: rubble and piles are */
+function neutralOf(world) {
+	for (const player of world.players.values()) if (player.neutral) return player.id;
+	return 0;
+}
+/** Spawns remains of a type, holding so much of their resource */
+function putDown(world, spec, x, z) {
+	if (!world.registry.units.has(spec.type)) return void 0;
+	const entity = world.spawn(spec.type, neutralOf(world), {
+		x,
+		z
+	});
+	if (spec.amount !== void 0 && entity.get(deposit)) entity.get(deposit).amount = spec.amount;
+	return entity;
+}
+/**
+* A type of rubble, to put in the game's units: a resource that blocks its footprint, gathered (cleared) as `kind`
+* by the game's workers, with no look of its own (the game's looks give it one)
+*
+* @beta
+*/
+function rubbleType(def) {
+	return {
+		id: def.id,
+		name: def.name ?? "Rubble",
+		kind: "resource",
+		radius: Math.max(def.footprint.w, def.footprint.d) / 2,
+		footprint: def.footprint,
+		stats: { health: 1 },
+		sight: 0,
+		resource: {
+			id: def.kind,
+			amount: def.amount ?? 100,
+			slots: def.slots ?? 3
+		}
+	};
+}
+/**
+* A type of pile, to put in the game's units: something lying on the ground that blocks nothing, is fought by nobody,
+* and is handed (`pileOf`: its kind and how much) to who walks over it. `kind` and `amount` are what it holds when the
+* death that drops it says nothing else
+*
+* @beta
+*/
+function pileType(def) {
+	return {
+		id: def.id,
+		name: def.name ?? "Pile",
+		kind: "unit",
+		radius: .2,
+		stats: {
+			health: 1,
+			moveSpeed: 0
+		},
+		sight: 0,
+		invulnerable: true,
+		ignored: true,
+		pile: {
+			kind: def.kind,
+			amount: def.amount ?? 10
+		}
+	};
+}
+/**
+* Remains that are things for a game (`RemainsOptions`): rubble where buildings fell, piles where units did. The game
+* is the same otherwise; its units list the types (`rubbleType`, `pileType`, or its own)
+*
+* @beta
+*/
+function remainsPack(options = {}) {
+	const reach = options.reach ?? .8;
+	const picksUp = options.picksUp ?? ((_world, unit) => !unit.isStructure && !unit.isResource && unit.alive && !unit.get(pileOf));
+	const deathHook = defineHook({
+		hook: "death",
+		id: "core.remains.death",
+		run(world, event) {
+			const { entity: dead, killer } = event;
+			const state = world.state(remains);
+			if (dead.isStructure && options.rubble) {
+				const said = typeof options.rubble === "function" ? options.rubble(world, dead) : options.rubble;
+				const spec = typeof said === "string" ? { type: said } : said;
+				if (spec) state.rubble[dead.id] = {
+					...spec,
+					x: dead.pos.x,
+					z: dead.pos.z
+				};
+			} else if (!dead.isStructure && !dead.isResource && options.piles) {
+				const spec = options.piles(world, dead, killer);
+				const pile = spec && putDown(world, spec, dead.pos.x, dead.pos.z);
+				if (!pile) return;
+				const kept = pile.def.pile;
+				const kind = kept?.kind ?? world.registry.resources[0]?.id ?? "gold";
+				pile.set(pileOf, {
+					kind,
+					amount: spec.amount ?? kept?.amount ?? 10
+				});
+				state.piles.push(pile.id);
+			}
+		}
+	});
+	const removeHook = defineHook({
+		hook: "remove",
+		id: "core.remains.remove",
+		run(world, entity) {
+			const state = world.state(remains);
+			const rubble = state.rubble[entity.id];
+			if (!rubble) return;
+			delete state.rubble[entity.id];
+			putDown(world, rubble, rubble.x, rubble.z);
+		}
+	});
+	const near = [];
+	return {
+		id: "remains",
+		options,
+		components: [remains, pileOf],
+		events: [pileTaken],
+		hooks: [deathHook, removeHook],
+		systems: [{
+			name: "core.remains.piles",
+			update(world) {
+				const state = world.state(remains);
+				if (!state.piles.length) return;
+				state.piles = state.piles.filter((id) => {
+					const pile = world.get(id);
+					const holds = pile?.get(pileOf);
+					if (!pile?.alive || !holds) return false;
+					for (const unit of [...world.spatial.query(pile.pos.x, pile.pos.z, reach, near)]) {
+						if (world.player(unit.owner).neutral || !picksUp(world, unit, pile)) continue;
+						const dx = unit.pos.x - pile.pos.x;
+						const dz = unit.pos.z - pile.pos.z;
+						const within = reach + unit.def.radius;
+						if (dx * dx + dz * dz > within * within) continue;
+						const { kind, amount } = holds;
+						earn(world.player(unit.owner).resources, kind, amount);
+						world.events.emit(pileTaken, {
+							pile: pile.id,
+							by: unit.id,
+							player: unit.owner,
+							kind,
+							amount
+						});
+						world.kill(pile, unit, false, "taken");
+						return false;
+					}
+					return true;
+				});
+			}
+		}]
+	};
+}
+//#endregion
+export { pileOf, pileTaken, pileType, remains, remainsPack, rubbleType };
+
+//# sourceMappingURL=remains.js.map