@v12-engine/engine 0.1.0 → 0.4.0

package/dist/tomes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tomes.js","names":[],"sources":["../src/tomes.ts"],"sourcesContent":["import { defineEffect, effectTargets } from './abilities/effects'\nimport { defineComponent } from './components'\nimport type { StatChange } from './defs'\nimport type { Entity } from './entity'\nimport { grantXp, heroOf, maxLevelOf } from './hero'\nimport type { GamePack } from './packs/pack'\nimport { invalidateStats, refreshVitals, type StatField } from './stats'\nimport type { World } from './world'\n\n/*\n * Tomes, an opt-in pack (review RV95): what a unit gains for good, a point of strength a book, kept with it and in a\n * save, and the `tome` effect that gives it (an item's ability, used from the inventory or as it is picked up with the\n * runes pack). A hero's experience and levels from a book are the heroes' own (`grantXp`)\n */\n\n/**\n * The tomes pack's id\n *\n * @beta\n */\nexport const TOMES = 'core.tomes'\n\n/**\n * What a unit gained for good (`gainStats`): the stats added and the parts, everything it gained added up, and how many\n * times it gained\n *\n * @beta\n */\nexport interface GainedStats {\n\t/** What was added to each stat */\n\tstats: Record<string, number>\n\t/** The parts each stat was made bigger or smaller by */\n\tpercent: Record<string, number>\n\t/** How many times it gained: what tells the stats to be added up again */\n\ttimes: number\n}\n\n/**\n * What a unit gained for good from tomes or the game's own rules (`gainStats`): saved with it\n *\n * @beta\n */\nexport const gainedStats = defineComponent<GainedStats>({ id: 'core.gainedStats' })\n\n/**\n * Gives a unit stats for good, as a tome does: added to what it gained before, kept with it in a save, its health and\n * mana raised with them. For the tomes pack's `tome` effect and a game's own rules (a shrine that makes a unit\n * stronger); it works in a game with the tomes pack (`tomesPack`), which adds what was gained to the stats\n *\n * @beta\n */\nexport function gainStats(world: World, entity: Entity, change: StatChange): void {\n\tconst had = entity.get(gainedStats)\n\tconst next: GainedStats = { stats: { ...had?.stats }, percent: { ...had?.percent }, times: (had?.times ?? 0) + 1 }\n\tfor (const key in change.stats) next.stats[key] = (next.stats[key] ?? 0) + change.stats[key]!\n\tfor (const key in change.percent) next.percent[key] = (next.percent[key] ?? 0) + change.percent[key]!\n\tentity.set(gainedStats, next)\n\tinvalidateStats(world, entity)\n\trefreshVitals(world, entity)\n}\n\n/** A tome read: what it gives for good, the experience and the levels it gives a hero */\nconst tomeEffect = defineEffect({ type: 'tome', run: (context, effect) => {\n\t\tconst { world } = context\n\t\tfor (const entity of effectTargets(context, effect, 'allies')) {\n\t\t\tif (effect.gain) gainStats(world, entity, effect.gain)\n\t\t\tif (effect.xp) grantXp(world, entity, effect.xp)\n\t\t\tfor (let i = 0; i < (effect.levels ?? 0); i++) {\n\t\t\t\tconst hero = heroOf(entity)\n\t\t\t\tif (!hero || hero.level >= maxLevelOf(world, entity)) break\n\t\t\t\tgrantXp(world, entity, world.settings.heroes.xpForLevel(hero.level + 1) - hero.xp)\n\t\t\t}\n\t\t}\n\t}, fields: [\n\t\t\t{ path: 'xp', kind: 'integer', min: 0, hint: 'Experience a hero gains' },\n\t\t\t{ path: 'levels', kind: 'integer', min: 0, hint: 'Levels a hero gains' }\n\t\t] })\n\n/** What was gained, added to the stats: worked out again each time something is gained */\nconst gained: StatField = {\n\tid: 'tomes',\n\tstamp: (entity) => entity.get(gainedStats)?.times ?? 0,\n\tadd(_world, entity, sum) {\n\t\tconst had = entity.get(gainedStats)\n\t\tif (had) sum.add(had)\n\t}\n}\n\n/**\n * Tomes, as in classic RTS games: the `tome` effect (`EffectTypes.tome`) gives what it reaches stats for good (`gain`: a\n * point of a stat of the game's own), a hero experience (`xp`) and levels (`levels`). A tome is an item whose\n * ability has the effect, with a charge, used from the inventory, or as it is picked up with the runes pack\n * (`runesPack`). What a unit gained is kept with it and in a save (`gainedStats`), and a game gives it from its own\n * rules with `gainStats`\n *\n * @beta\n */\nexport function tomesPack(): GamePack {\n\treturn { id: TOMES, components: [gainedStats], effects: [tomeEffect], statFields: [gained] }\n}\n"],"mappings":";;;;;;;;;;AAoBA,IAAa,QAAQ;;;;;;AAsBrB,IAAa,cAAc,gBAA6B,EAAE,IAAI,mBAAmB,CAAC;;;;;;;;AASlF,SAAgB,UAAU,OAAc,QAAgB,QAA0B;CACjF,MAAM,MAAM,OAAO,IAAI,WAAW;CAClC,MAAM,OAAoB;EAAE,OAAO,EAAE,GAAG,KAAK,MAAM;EAAG,SAAS,EAAE,GAAG,KAAK,QAAQ;EAAG,QAAQ,KAAK,SAAS,KAAK;CAAE;CACjH,KAAK,MAAM,OAAO,OAAO,OAAO,KAAK,MAAM,QAAQ,KAAK,MAAM,QAAQ,KAAK,OAAO,MAAM;CACxF,KAAK,MAAM,OAAO,OAAO,SAAS,KAAK,QAAQ,QAAQ,KAAK,QAAQ,QAAQ,KAAK,OAAO,QAAQ;CAChG,OAAO,IAAI,aAAa,IAAI;CAC5B,gBAAgB,OAAO,MAAM;CAC7B,cAAc,OAAO,MAAM;AAC5B;;AAGA,IAAM,aAAa,aAAa;CAAE,MAAM;CAAQ,MAAM,SAAS,WAAW;EACxE,MAAM,EAAE,UAAU;EAClB,KAAK,MAAM,UAAU,cAAc,SAAS,QAAQ,QAAQ,GAAG;GAC9D,IAAI,OAAO,MAAM,UAAU,OAAO,QAAQ,OAAO,IAAI;GACrD,IAAI,OAAO,IAAI,QAAQ,OAAO,QAAQ,OAAO,EAAE;GAC/C,KAAK,IAAI,IAAI,GAAG,KAAK,OAAO,UAAU,IAAI,KAAK;IAC9C,MAAM,OAAO,OAAO,MAAM;IAC1B,IAAI,CAAC,QAAQ,KAAK,SAAS,WAAW,OAAO,MAAM,GAAG;IACtD,QAAQ,OAAO,QAAQ,MAAM,SAAS,OAAO,WAAW,KAAK,QAAQ,CAAC,IAAI,KAAK,EAAE;GAClF;EACD;CACD;CAAG,QAAQ,CACT;EAAE,MAAM;EAAM,MAAM;EAAW,KAAK;EAAG,MAAM;CAA0B,GACvE;EAAE,MAAM;EAAU,MAAM;EAAW,KAAK;EAAG,MAAM;CAAsB,CACxE;AAAE,CAAC;;AAGL,IAAM,SAAoB;CACzB,IAAI;CACJ,QAAQ,WAAW,OAAO,IAAI,WAAW,CAAC,EAAE,SAAS;CACrD,IAAI,QAAQ,QAAQ,KAAK;EACxB,MAAM,MAAM,OAAO,IAAI,WAAW;EAClC,IAAI,KAAK,IAAI,IAAI,GAAG;CACrB;AACD;;;;;;;;;;AAWA,SAAgB,YAAsB;CACrC,OAAO;EAAE,IAAI;EAAO,YAAY,CAAC,WAAW;EAAG,SAAS,CAAC,UAAU;EAAG,YAAY,CAAC,MAAM;CAAE;AAC5F"}

package/dist/trade.js

@@ -0,0 +1,103 @@
+import { exchanged, traded } from "./engineEvents.js";
+import { earn, spend } from "./player.js";
+import { engineMessage } from "./messages.js";
+//#region src/trade.ts
+/**
+* Gives `amount` of a resource from one player to an ally (`traded`), both told. Nothing to who is not an ally, more
+* than the giver has, or a resource the game does not have; and as the `beforeTrade` hook says: how much arrives, or not
+*
+* @beta
+*/
+function give(world, from, to, resource, amount) {
+	if (from === to || !world.players.has(to) || !world.registry.resource(resource)) return;
+	const receiver = world.player(to);
+	if (receiver.neutral || !world.areAllies(from, to)) return world.message(from, engineMessage("notAnAlly"));
+	const sent = Math.floor(amount);
+	if (sent <= 0) return;
+	const purse = world.player(from).resources;
+	if ((purse[resource] ?? 0) < sent) return world.message(from, engineMessage("notEnough", { resource }));
+	const trade = {
+		from,
+		to,
+		resource,
+		sent,
+		received: Math.floor(sent * (1 - (world.settings.economy.tradeTax ?? 0))),
+		cancelled: false
+	};
+	if (world.hooks.has("beforeTrade")) world.hooks.run("beforeTrade", trade);
+	if (trade.cancelled) return world.message(from, trade.reason ?? engineMessage("cannotDoThat"));
+	const received = Math.max(Math.floor(trade.received), 0);
+	purse[resource] = (purse[resource] ?? 0) - sent;
+	earn(receiver.resources, resource, received);
+	world.events.emit(traded, {
+		from,
+		to,
+		resource,
+		sent,
+		received
+	});
+	world.message(from, engineMessage("sent", {
+		amount: sent,
+		resource,
+		player: receiver.name
+	}), "info");
+	world.message(to, engineMessage("received", {
+		amount: received,
+		resource,
+		player: world.player(from).name
+	}), "info");
+}
+/**
+* Shares with an ally, or no longer: control of the player's units (`shareControl`), and what the player's team sees
+* (`shareVision`, when the ally is of another team: a team sees as one already). Nothing for who is not an ally
+*
+* @beta
+*/
+function shareWith(world, player, ally, what) {
+	if (player === ally || !world.players.has(ally)) return;
+	if (world.player(ally).neutral || !world.areAllies(player, ally)) return world.message(player, engineMessage("notAnAlly"));
+	const sameTeam = world.player(player).team === world.player(ally).team;
+	world.sides.share(player, ally, {
+		control: what.control,
+		vision: sameTeam ? void 0 : what.vision
+	});
+}
+/**
+* Trades `amount` of one resource of a player's (`sold`) for another (`bought`) at a rate: `rate` of it for each one
+* sold, rounded down (`exchanged`), the player told. What the `exchange` effect does (a marketplace's ability,
+* `presetMarket`), for a game's own rules. Nothing of a resource the game does not have, of one for itself, or more
+* than the player has. Gives back how much came
+*
+* @beta
+*/
+function exchange(world, player, sold, bought, amount, rate) {
+	if (sold === bought || !world.players.has(player) || !world.registry.resource(sold) || !world.registry.resource(bought)) return 0;
+	const sent = Math.floor(amount);
+	if (sent <= 0 || !(rate > 0)) return 0;
+	const purse = world.player(player).resources;
+	if ((purse[sold] ?? 0) < sent) {
+		world.message(player, engineMessage("notEnough", { resource: sold }));
+		return 0;
+	}
+	const received = Math.floor(sent * rate + 1e-9);
+	spend(world, player, { [sold]: sent }, "trade", bought);
+	earn(purse, bought, received);
+	world.events.emit(exchanged, {
+		player,
+		sold,
+		sent,
+		bought,
+		received
+	});
+	world.message(player, engineMessage("exchanged", {
+		amount: sent,
+		resource: sold,
+		received,
+		for: bought
+	}), "info");
+	return received;
+}
+//#endregion
+export { exchange, give, shareWith };
+
+//# sourceMappingURL=trade.js.map

package/dist/trade.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"trade.js","names":["tradedEvent","exchangedEvent"],"sources":["../src/trade.ts"],"sourcesContent":["import { exchanged as exchangedEvent, traded as tradedEvent } from '#engine/engineEvents'\nimport type { PlayerId } from './entity'\nimport { engineMessage } from './messages'\nimport { earn, spend } from './player'\nimport type { BeforeTrade } from './hooks'\nimport type { World } from './world'\n\n/*\n * Allies helping each other: a player gives some of what they have to an ally, less what the game's rules take\n * (`RuleSettings.economy.tradeTax`), as the classic allies menu does. A command like any other. And a market: a player\n * trades one resource of theirs for another at a rate (`exchange`, the `exchange` effect, `presetMarket`)\n */\n\n/**\n * Gives `amount` of a resource from one player to an ally (`traded`), both told. Nothing to who is not an ally, more\n * than the giver has, or a resource the game does not have; and as the `beforeTrade` hook says: how much arrives, or not\n *\n * @beta\n */\nexport function give(world: World, from: PlayerId, to: PlayerId, resource: string, amount: number): void {\n\tif (from === to || !world.players.has(to) || !world.registry.resource(resource)) return\n\tconst receiver = world.player(to)\n\tif (receiver.neutral || !world.areAllies(from, to)) return world.message(from, engineMessage('notAnAlly'))\n\tconst sent = Math.floor(amount)\n\tif (sent <= 0) return\n\tconst purse = world.player(from).resources\n\tif ((purse[resource] ?? 0) < sent) return world.message(from, engineMessage('notEnough', { resource }))\n\t// the game's say: how much arrives, or none of it\n\tconst trade = { from, to, resource, sent, received: Math.floor(sent * (1 - (world.settings.economy.tradeTax ?? 0))), cancelled: false } as BeforeTrade\n\tif (world.hooks.has('beforeTrade')) world.hooks.run('beforeTrade', trade)\n\tif (trade.cancelled) return world.message(from, trade.reason ?? engineMessage('cannotDoThat'))\n\tconst received = Math.max(Math.floor(trade.received), 0)\n\tpurse[resource] = (purse[resource] ?? 0) - sent\n\tearn(receiver.resources, resource, received)\n\tworld.events.emit(tradedEvent, { from, to, resource, sent, received })\n\tworld.message(from, engineMessage('sent', { amount: sent, resource, player: receiver.name }), 'info')\n\tworld.message(to, engineMessage('received', { amount: received, resource, player: world.player(from).name }), 'info')\n}\n\n/**\n * Shares with an ally, or no longer: control of the player's units (`shareControl`), and what the player's team sees\n * (`shareVision`, when the ally is of another team: a team sees as one already). Nothing for who is not an ally\n *\n * @beta\n */\nexport function shareWith(world: World, player: PlayerId, ally: PlayerId, what: { vision?: boolean; control?: boolean }): void {\n\tif (player === ally || !world.players.has(ally)) return\n\tif (world.player(ally).neutral || !world.areAllies(player, ally)) return world.message(player, engineMessage('notAnAlly'))\n\tconst sameTeam = world.player(player).team === world.player(ally).team\n\tworld.sides.share(player, ally, { control: what.control, vision: sameTeam ? undefined : what.vision })\n}\n\n/**\n * Trades `amount` of one resource of a player's (`sold`) for another (`bought`) at a rate: `rate` of it for each one\n * sold, rounded down (`exchanged`), the player told. What the `exchange` effect does (a marketplace's ability,\n * `presetMarket`), for a game's own rules. Nothing of a resource the game does not have, of one for itself, or more\n * than the player has. Gives back how much came\n *\n * @beta\n */\nexport function exchange(world: World, player: PlayerId, sold: string, bought: string, amount: number, rate: number): number {\n\tif (sold === bought || !world.players.has(player) || !world.registry.resource(sold) || !world.registry.resource(bought)) return 0\n\tconst sent = Math.floor(amount)\n\tif (sent <= 0 || !(rate > 0)) return 0\n\tconst purse = world.player(player).resources\n\tif ((purse[sold] ?? 0) < sent) {\n\t\tworld.message(player, engineMessage('notEnough', { resource: sold }))\n\t\treturn 0\n\t}\n\t// a hair over, so that a rate written as a decimal (100 at 0.29) comes to what it says and not one under\n\tconst received = Math.floor(sent * rate + 1e-9)\n\t// what was sold counts as spent, as the score has it\n\tspend(world, player, { [sold]: sent }, 'trade', bought)\n\tearn(purse, bought, received)\n\tworld.events.emit(exchangedEvent, { player, sold, sent, bought, received })\n\tworld.message(player, engineMessage('exchanged', { amount: sent, resource: sold, received, for: bought }), 'info')\n\treturn received\n}\n"],"mappings":";;;;;;;;;;AAmBA,SAAgB,KAAK,OAAc,MAAgB,IAAc,UAAkB,QAAsB;CACxG,IAAI,SAAS,MAAM,CAAC,MAAM,QAAQ,IAAI,EAAE,KAAK,CAAC,MAAM,SAAS,SAAS,QAAQ,GAAG;CACjF,MAAM,WAAW,MAAM,OAAO,EAAE;CAChC,IAAI,SAAS,WAAW,CAAC,MAAM,UAAU,MAAM,EAAE,GAAG,OAAO,MAAM,QAAQ,MAAM,cAAc,WAAW,CAAC;CACzG,MAAM,OAAO,KAAK,MAAM,MAAM;CAC9B,IAAI,QAAQ,GAAG;CACf,MAAM,QAAQ,MAAM,OAAO,IAAI,CAAC,CAAC;CACjC,KAAK,MAAM,aAAa,KAAK,MAAM,OAAO,MAAM,QAAQ,MAAM,cAAc,aAAa,EAAE,SAAS,CAAC,CAAC;CAEtG,MAAM,QAAQ;EAAE;EAAM;EAAI;EAAU;EAAM,UAAU,KAAK,MAAM,QAAQ,KAAK,MAAM,SAAS,QAAQ,YAAY,GAAG;EAAG,WAAW;CAAM;CACtI,IAAI,MAAM,MAAM,IAAI,aAAa,GAAG,MAAM,MAAM,IAAI,eAAe,KAAK;CACxE,IAAI,MAAM,WAAW,OAAO,MAAM,QAAQ,MAAM,MAAM,UAAU,cAAc,cAAc,CAAC;CAC7F,MAAM,WAAW,KAAK,IAAI,KAAK,MAAM,MAAM,QAAQ,GAAG,CAAC;CACvD,MAAM,aAAa,MAAM,aAAa,KAAK;CAC3C,KAAK,SAAS,WAAW,UAAU,QAAQ;CAC3C,MAAM,OAAO,KAAKA,QAAa;EAAE;EAAM;EAAI;EAAU;EAAM;CAAS,CAAC;CACrE,MAAM,QAAQ,MAAM,cAAc,QAAQ;EAAE,QAAQ;EAAM;EAAU,QAAQ,SAAS;CAAK,CAAC,GAAG,MAAM;CACpG,MAAM,QAAQ,IAAI,cAAc,YAAY;EAAE,QAAQ;EAAU;EAAU,QAAQ,MAAM,OAAO,IAAI,CAAC,CAAC;CAAK,CAAC,GAAG,MAAM;AACrH;;;;;;;AAQA,SAAgB,UAAU,OAAc,QAAkB,MAAgB,MAAqD;CAC9H,IAAI,WAAW,QAAQ,CAAC,MAAM,QAAQ,IAAI,IAAI,GAAG;CACjD,IAAI,MAAM,OAAO,IAAI,CAAC,CAAC,WAAW,CAAC,MAAM,UAAU,QAAQ,IAAI,GAAG,OAAO,MAAM,QAAQ,QAAQ,cAAc,WAAW,CAAC;CACzH,MAAM,WAAW,MAAM,OAAO,MAAM,CAAC,CAAC,SAAS,MAAM,OAAO,IAAI,CAAC,CAAC;CAClE,MAAM,MAAM,MAAM,QAAQ,MAAM;EAAE,SAAS,KAAK;EAAS,QAAQ,WAAW,KAAA,IAAY,KAAK;CAAO,CAAC;AACtG;;;;;;;;;AAUA,SAAgB,SAAS,OAAc,QAAkB,MAAc,QAAgB,QAAgB,MAAsB;CAC5H,IAAI,SAAS,UAAU,CAAC,MAAM,QAAQ,IAAI,MAAM,KAAK,CAAC,MAAM,SAAS,SAAS,IAAI,KAAK,CAAC,MAAM,SAAS,SAAS,MAAM,GAAG,OAAO;CAChI,MAAM,OAAO,KAAK,MAAM,MAAM;CAC9B,IAAI,QAAQ,KAAK,EAAE,OAAO,IAAI,OAAO;CACrC,MAAM,QAAQ,MAAM,OAAO,MAAM,CAAC,CAAC;CACnC,KAAK,MAAM,SAAS,KAAK,MAAM;EAC9B,MAAM,QAAQ,QAAQ,cAAc,aAAa,EAAE,UAAU,KAAK,CAAC,CAAC;EACpE,OAAO;CACR;CAEA,MAAM,WAAW,KAAK,MAAM,OAAO,OAAO,IAAI;CAE9C,MAAM,OAAO,QAAQ,GAAG,OAAO,KAAK,GAAG,SAAS,MAAM;CACtD,KAAK,OAAO,QAAQ,QAAQ;CAC5B,MAAM,OAAO,KAAKC,WAAgB;EAAE;EAAQ;EAAM;EAAM;EAAQ;CAAS,CAAC;CAC1E,MAAM,QAAQ,QAAQ,cAAc,aAAa;EAAE,QAAQ;EAAM,UAAU;EAAM;EAAU,KAAK;CAAO,CAAC,GAAG,MAAM;CACjH,OAAO;AACR"}

package/dist/transport.d.ts

@@ -9,11 +9,16 @@ import type { World } from './world';
  * @beta
  */
 export interface Cargo {
+    /** Ids of the units inside the transport */
     passengers: number[];
     /** There is land within reach to let them out on */
     ashore: boolean;
 }
-/** @beta */
+/**
+ * The component holding a transport's passengers, replicated to allies; set on spawn for types with `transport`
+ *
+ * @beta
+ */
 export declare const cargo: import("./components").Component<Cargo, Cargo>;
 /**
  * How many more a transport has room for

package/dist/transport.js

@@ -0,0 +1,281 @@
+import { cos, hypot, sin } from "./exactMath.js";
+import { defineComponent } from "./components.js";
+import { invalidateStats } from "./stats.js";
+import { defineListener } from "./events.js";
+import { boarded, entityDied, unloaded } from "./engineEvents.js";
+import { edgeDistance, moving } from "./entity.js";
+import { defineHook } from "./hooks.js";
+import { halt, moveTo, moveToEntity } from "./systems/movement.js";
+import { createOrder, giveOrder } from "./orders/queue.js";
+//#region src/transport.ts
+/**
+* The component holding a transport's passengers, replicated to allies; set on spawn for types with `transport`
+*
+* @beta
+*/
+var cargo = defineComponent({
+	id: "core.cargo",
+	replicate: "allies",
+	onSpawn: (entity) => {
+		if (entity.def.transport) entity.set(cargo, {
+			passengers: [],
+			ashore: false
+		});
+	}
+});
+/**
+* How far from its edge a transport reaches to take someone in, and to let them out on the land
+*
+* @internal
+*/
+var BOARD_REACH = 1.5;
+/**
+* How far from its edge a transport reaches to let passengers out onto land, in world units
+*
+* @internal
+*/
+var UNLOAD_REACH = 3.5;
+/** How much further a boat reaches: the walkable bank stops short of the deep water it floats on */
+var SHORE_GAP = 2.5;
+/** How far from its edge a transport takes someone in */
+var boardReach = (transport) => BOARD_REACH + (transport.def.naval ? SHORE_GAP : 0);
+var passengersOf = (transport) => transport.get(cargo)?.passengers ?? [];
+/**
+* How many more a transport has room for
+*
+* @beta
+*/
+function roomIn(transport) {
+	const capacity = transport.def.transport?.capacity ?? 0;
+	return Math.max(capacity - passengersOf(transport).length, 0);
+}
+/**
+* Whether a unit can get into a transport: one of its side's that has room, and a unit that walks. What flies, what
+* sails and what carries others do not get in
+*
+* @beta
+*/
+function canBoard(world, passenger, transport) {
+	if (passenger === transport || !transport.def.transport || !transport.alive || passenger.hidden) return false;
+	if (passenger.def.kind !== "unit" || !passenger.get(moving) || passenger.flying || passenger.def.naval || passenger.def.transport) return false;
+	if (!world.areAllies(passenger.owner, transport.owner)) return false;
+	const takes = transport.def.transport.takes;
+	if (takes && !takes(passenger.def)) return false;
+	return roomIn(transport) > 0;
+}
+/**
+* Puts a unit into a transport at once, wherever the two are. False when it cannot get in
+*
+* @beta
+*/
+function board(world, passenger, transport) {
+	if (!canBoard(world, passenger, transport)) return false;
+	halt(world, passenger);
+	world.setHidden(passenger, true);
+	transport.set(cargo, {
+		passengers: [...passengersOf(transport), passenger.id],
+		ashore: transport.get(cargo)?.ashore ?? false
+	});
+	invalidateStats(world, transport);
+	world.events.emit(boarded, {
+		passenger,
+		transport
+	});
+	return true;
+}
+/**
+* The land nearest a point, within reach of it: where what is carried gets out. Nothing out on open water
+*
+* @internal
+*/
+function shoreNear(world, at, reach = UNLOAD_REACH) {
+	return world.nav.closestPoint(at, reach);
+}
+/**
+* Lets out what a transport carries, on the land nearest it (or nearest `near`, within reach of the transport), spread
+* around it. How many got out: none when there is no land in reach
+*
+* @beta
+*/
+function unload(world, transport, near) {
+	const passengers = passengersOf(transport);
+	if (!passengers.length) return 0;
+	const reach = UNLOAD_REACH + transport.def.radius;
+	const land = (near && hypot(near.x - transport.pos.x, near.z - transport.pos.z) <= reach ? shoreNear(world, near, 2) : null) ?? shoreNear(world, transport.pos, reach);
+	if (!land) return 0;
+	let out = 0;
+	passengers.forEach((id, i) => {
+		const passenger = world.entities.get(id);
+		if (!passenger) return;
+		const turn = i / Math.max(passengers.length, 1) * Math.PI * 2;
+		const spread = i === 0 ? 0 : .9 + Math.floor(i / 6) * .8;
+		world.setHidden(passenger, false, {
+			x: land.x + cos(turn) * spread,
+			z: land.z + sin(turn) * spread
+		});
+		world.events.emit(unloaded, {
+			passenger,
+			transport
+		});
+		out++;
+	});
+	transport.set(cargo, {
+		passengers: [],
+		ashore: true
+	});
+	invalidateStats(world, transport);
+	return out;
+}
+/**
+* Getting into a transport: the unit walks to it, as near as the land goes when it is on the water, and gets in once
+* it is within reach. Done when it is in; failed when there is no room, or no way to it
+*
+* @internal
+*/
+var boardOrder = {
+	type: "board",
+	accepts(world, entity, init) {
+		const transport = world.get(init.target);
+		return !!transport && canBoard(world, entity, transport);
+	},
+	update(world, entity, order) {
+		const transport = world.get(order.init.target);
+		if (!transport || !canBoard(world, entity, transport)) return "failed";
+		if (edgeDistance(entity, transport) <= boardReach(transport)) return board(world, entity, transport) ? "done" : "failed";
+		const m = entity.get(moving);
+		if (m.status === "moving") return "running";
+		if (m.status === "failed" && order.state.tried === world.tick - 1) return "failed";
+		order.state.tried = world.tick;
+		if (transport.def.naval) {
+			const shore = shoreNear(world, transport.pos, transport.def.radius + boardReach(transport) + 4);
+			if (!shore) return "failed";
+			if (hypot(shore.x - entity.pos.x, shore.z - entity.pos.z) < .5) return "failed";
+			moveTo(world, entity, shore);
+		} else moveToEntity(world, entity, transport, BOARD_REACH * .5);
+		return "running";
+	}
+};
+/**
+* Taking a unit in, from the transport's side: it goes to the unit and takes it in once it is within reach. A boat
+* goes as near as the water does; when it can get no nearer, a passenger of its own side is told to come aboard
+* (`board`), and that is done. Failed when there is no room, or the unit cannot get in
+*
+* @internal
+*/
+var loadOrder = {
+	type: "load",
+	accepts(world, entity, init) {
+		const passenger = world.get(init.target);
+		return !!passenger && canBoard(world, passenger, entity);
+	},
+	update(world, entity, order) {
+		const passenger = world.get(order.init.target);
+		if (!passenger || !canBoard(world, passenger, entity)) return "failed";
+		if (edgeDistance(entity, passenger) <= boardReach(entity)) return board(world, passenger, entity) ? "done" : "failed";
+		const m = entity.get(moving);
+		if (!m) return "failed";
+		if (m.status === "moving") return "running";
+		const from = order.state.from;
+		if (order.state.tried !== void 0 && from && hypot(from.x - entity.pos.x, from.z - entity.pos.z) < .5) {
+			if (!entity.def.naval || passenger.owner !== entity.owner) return "failed";
+			giveOrder(world, passenger, createOrder(world, {
+				type: "board",
+				target: entity.id
+			}));
+			return "done";
+		}
+		order.state.tried = world.tick;
+		order.state.from = {
+			x: entity.pos.x,
+			z: entity.pos.z
+		};
+		moveToEntity(world, entity, passenger, BOARD_REACH * .5);
+		return "running";
+	}
+};
+/**
+* Letting out what a transport carries: where it is, when there is land in reach; or at a point, sailing (or driving)
+* as near it as it goes first, and letting them out on the land nearest it. Failed when there is no land to let them
+* out on
+*
+* @internal
+*/
+var unloadOrder = {
+	type: "unload",
+	accepts(_world, entity) {
+		return !!entity.def.transport && passengersOf(entity).length > 0;
+	},
+	update(world, entity, order) {
+		if (!passengersOf(entity).length) return "done";
+		const point = order.init.point;
+		if (!point || !entity.get(moving)) return unload(world, entity) ? "done" : "failed";
+		if (hypot(point.x - entity.pos.x, point.z - entity.pos.z) <= 3.5 + entity.def.radius) return unload(world, entity, point) ? "done" : "failed";
+		if (entity.get(moving).status === "moving") return "running";
+		if (order.state.sent) return unload(world, entity, point) ? "done" : "failed";
+		order.state.sent = true;
+		moveTo(world, entity, point);
+		return "running";
+	}
+};
+/** Keeps each transport's word of whether it is near the land, for its card. A few times a second */
+var transportSystem = {
+	name: "transports",
+	phase: "cleanup",
+	every: 6,
+	over: cargo,
+	each(world, entity) {
+		if (!entity.def.transport || !entity.alive || entity.scenery) return;
+		const held = entity.get(cargo);
+		const ashore = !!shoreNear(world, entity.pos, UNLOAD_REACH + entity.def.radius);
+		if (held.ashore !== ashore) entity.set(cargo, {
+			passengers: held.passengers,
+			ashore
+		});
+		if (held.passengers.some((id) => !world.entities.get(id)?.hidden)) entity.set(cargo, {
+			passengers: held.passengers.filter((id) => world.entities.get(id)?.hidden),
+			ashore
+		});
+	}
+};
+/** A transport that dies takes down what it carries with it: a boat. A building that falls lets them out */
+var transportSank = defineListener({
+	id: "core.transportSank",
+	event: entityDied,
+	run(world, { entity, killer }) {
+		if (entity.isStructure) {
+			unload(world, entity);
+			return;
+		}
+		for (const id of passengersOf(entity)) {
+			const passenger = world.entities.get(id);
+			if (passenger?.alive) world.kill(passenger, killer);
+		}
+	}
+});
+/**
+* An armed garrison (`transport.armed`): it attacks only while someone is inside, and each one inside adds to its attack
+* damage
+*
+* @internal
+*/
+var garrisonHooks = [defineHook({
+	hook: "canAttack",
+	id: "emptyGarrison",
+	run(_world, event) {
+		if (!event.cancelled && event.attacker.def.transport?.armed !== void 0 && !passengersOf(event.attacker).length) event.cancelled = true;
+	}
+}), defineHook({
+	hook: "stats",
+	id: "garrisonDamage",
+	run(world, { entity, add }) {
+		const armed = entity.def.transport?.armed;
+		const inside = armed === void 0 ? [] : passengersOf(entity);
+		if (!inside.length) return;
+		if (typeof armed === "function") add({ stats: { attackDamage: armed(world, entity, inside.map((id) => world.entities.get(id)).filter((passenger) => !!passenger)) } });
+		else if (armed) add({ stats: { attackDamage: armed } }, inside.length);
+	}
+})];
+//#endregion
+export { BOARD_REACH, UNLOAD_REACH, board, boardOrder, canBoard, cargo, garrisonHooks, loadOrder, roomIn, shoreNear, transportSank, transportSystem, unload, unloadOrder };
+
+//# sourceMappingURL=transport.js.map

package/dist/transport.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport.js","names":[],"sources":["../src/transport.ts"],"sourcesContent":["import { boarded, entityDied, unloaded } from '#engine/engineEvents'\nimport { defineComponent } from './components'\nimport { defineListener } from './events'\nimport { edgeDistance, type Entity, moving } from './entity'\nimport type { Vec2 } from './math'\nimport type { OrderBehavior, OrderInits, System } from './registry'\nimport { defineHook, type HookDef } from './hooks'\nimport { invalidateStats } from './stats'\nimport { halt, moveTo, moveToEntity } from './systems/movement'\nimport type { World } from './world'\nimport { cos, hypot, sin } from './exactMath'\nimport { createOrder, giveOrder } from './orders/queue'\n\n/**\n * What a transport carries, and whether it is near enough the land to let them out: kept for its side to see, the\n * card's unload button reads it (see `UnitTypeDef.transport`)\n *\n * @beta\n */\nexport interface Cargo {\n\t/** Ids of the units inside the transport */\n\tpassengers: number[]\n\t/** There is land within reach to let them out on */\n\tashore: boolean\n}\n\n/**\n * The component holding a transport's passengers, replicated to allies; set on spawn for types with `transport`\n *\n * @beta\n */\nexport const cargo = defineComponent<Cargo>({ id: 'core.cargo', replicate: 'allies',\n\t// a hold, empty, for what carries: what the transports' system goes through (OB5)\n\tonSpawn: (entity) => {\n\t\tif (entity.def.transport) entity.set(cargo, { passengers: [], ashore: false })\n\t} })\n\n/**\n * How far from its edge a transport reaches to take someone in, and to let them out on the land\n *\n * @internal\n */\nexport const BOARD_REACH = 1.5\n/**\n * How far from its edge a transport reaches to let passengers out onto land, in world units\n *\n * @internal\n */\nexport const UNLOAD_REACH = 3.5\n/** How much further a boat reaches: the walkable bank stops short of the deep water it floats on */\nconst SHORE_GAP = 2.5\n\n/** How far from its edge a transport takes someone in */\nconst boardReach = (transport: Entity) => BOARD_REACH + (transport.def.naval ? SHORE_GAP : 0)\n\nconst passengersOf = (transport: Entity): number[] => transport.get(cargo)?.passengers ?? []\n\n/**\n * How many more a transport has room for\n *\n * @beta\n */\nexport function roomIn(transport: Entity): number {\n\tconst capacity = transport.def.transport?.capacity ?? 0\n\treturn Math.max(capacity - passengersOf(transport).length, 0)\n}\n\n/**\n * Whether a unit can get into a transport: one of its side's that has room, and a unit that walks. What flies, what\n * sails and what carries others do not get in\n *\n * @beta\n */\nexport function canBoard(world: World, passenger: Entity, transport: Entity): boolean {\n\tif (passenger === transport || !transport.def.transport || !transport.alive || passenger.hidden) return false\n\tif (passenger.def.kind !== 'unit' || !passenger.get(moving) || passenger.flying || passenger.def.naval || passenger.def.transport) return false\n\tif (!world.areAllies(passenger.owner, transport.owner)) return false\n\tconst takes = transport.def.transport.takes\n\tif (takes && !takes(passenger.def)) return false\n\treturn roomIn(transport) > 0\n}\n\n/**\n * Puts a unit into a transport at once, wherever the two are. False when it cannot get in\n *\n * @beta\n */\nexport function board(world: World, passenger: Entity, transport: Entity): boolean {\n\tif (!canBoard(world, passenger, transport)) return false\n\thalt(world, passenger)\n\tworld.setHidden(passenger, true)\n\ttransport.set(cargo, { passengers: [...passengersOf(transport), passenger.id], ashore: transport.get(cargo)?.ashore ?? false })\n\t// one more inside: an armed garrison hits harder\n\tinvalidateStats(world, transport)\n\tworld.events.emit(boarded, { passenger, transport })\n\treturn true\n}\n\n/**\n * The land nearest a point, within reach of it: where what is carried gets out. Nothing out on open water\n *\n * @internal\n */\nexport function shoreNear(world: World, at: Vec2, reach = UNLOAD_REACH): Vec2 | null {\n\treturn world.nav.closestPoint(at, reach)\n}\n\n/**\n * Lets out what a transport carries, on the land nearest it (or nearest `near`, within reach of the transport), spread\n * around it. How many got out: none when there is no land in reach\n *\n * @beta\n */\nexport function unload(world: World, transport: Entity, near?: Vec2): number {\n\tconst passengers = passengersOf(transport)\n\tif (!passengers.length) return 0\n\tconst reach = UNLOAD_REACH + transport.def.radius\n\tconst land =\n\t\t(near && hypot(near.x - transport.pos.x, near.z - transport.pos.z) <= reach ? shoreNear(world, near, 2) : null) ??\n\t\tshoreNear(world, transport.pos, reach)\n\tif (!land) return 0\n\tlet out = 0\n\tpassengers.forEach((id, i) => {\n\t\tconst passenger = world.entities.get(id)\n\t\tif (!passenger) return\n\t\t// a ring around where they come ashore, so they do not all stand on one spot\n\t\tconst turn = (i / Math.max(passengers.length, 1)) * Math.PI * 2\n\t\tconst spread = i === 0 ? 0 : 0.9 + Math.floor(i / 6) * 0.8\n\t\tworld.setHidden(passenger, false, { x: land.x + cos(turn) * spread, z: land.z + sin(turn) * spread })\n\t\tworld.events.emit(unloaded, { passenger, transport })\n\t\tout++\n\t})\n\ttransport.set(cargo, { passengers: [], ashore: true })\n\tinvalidateStats(world, transport)\n\treturn out\n}\n\n/**\n * What `board` keeps: the tick it last set out for its transport\n *\n * @beta\n */\nexport interface BoardState {\n\t/** The tick it last set out for its transport */\n\ttried?: number\n}\n\n/**\n * What `unload` keeps: whether it set its passengers down already\n *\n * @beta\n */\nexport interface UnloadState {\n\t/** It set them down already */\n\tsent?: boolean\n}\n\n/**\n * Getting into a transport: the unit walks to it, as near as the land goes when it is on the water, and gets in once\n * it is within reach. Done when it is in; failed when there is no room, or no way to it\n *\n * @internal\n */\nexport const boardOrder: OrderBehavior<BoardState, OrderInits['board']> = {\n\ttype: 'board',\n\taccepts(world, entity, init) {\n\t\tconst transport = world.get(init.target)\n\t\treturn !!transport && canBoard(world, entity, transport)\n\t},\n\tupdate(world, entity, order) {\n\t\tconst transport = world.get(order.init.target)\n\t\tif (!transport || !canBoard(world, entity, transport)) return 'failed'\n\t\tif (edgeDistance(entity, transport) <= boardReach(transport)) return board(world, entity, transport) ? 'done' : 'failed'\n\t\tconst m = entity.get(moving)!\n\t\tif (m.status === 'moving') return 'running'\n\t\tif (m.status === 'failed' && order.state.tried === world.tick - 1) return 'failed'\n\t\torder.state.tried = world.tick\n\t\t// a boat out on the water: to the shore nearest it\n\t\tif (transport.def.naval) {\n\t\t\tconst shore = shoreNear(world, transport.pos, transport.def.radius + boardReach(transport) + 4)\n\t\t\tif (!shore) return 'failed'\n\t\t\tif (hypot(shore.x - entity.pos.x, shore.z - entity.pos.z) < 0.5) return 'failed'\n\t\t\tmoveTo(world, entity, shore)\n\t\t} else moveToEntity(world, entity, transport, BOARD_REACH * 0.5)\n\t\treturn 'running'\n\t}\n}\n\n/**\n * What `load` keeps: the tick it last set out for its passenger, and where it was then\n *\n * @beta\n */\nexport interface LoadState {\n\t/** The tick it last set out for its passenger */\n\ttried?: number\n\t/** Where it was when it last set out */\n\tfrom?: Vec2\n}\n\n/**\n * Taking a unit in, from the transport's side: it goes to the unit and takes it in once it is within reach. A boat\n * goes as near as the water does; when it can get no nearer, a passenger of its own side is told to come aboard\n * (`board`), and that is done. Failed when there is no room, or the unit cannot get in\n *\n * @internal\n */\nexport const loadOrder: OrderBehavior<LoadState, OrderInits['load']> = {\n\ttype: 'load',\n\taccepts(world, entity, init) {\n\t\tconst passenger = world.get(init.target)\n\t\treturn !!passenger && canBoard(world, passenger, entity)\n\t},\n\tupdate(world, entity, order) {\n\t\tconst passenger = world.get(order.init.target)\n\t\tif (!passenger || !canBoard(world, passenger, entity)) return 'failed'\n\t\tif (edgeDistance(entity, passenger) <= boardReach(entity)) return board(world, passenger, entity) ? 'done' : 'failed'\n\t\tconst m = entity.get(moving)\n\t\tif (!m) return 'failed'\n\t\tif (m.status === 'moving') return 'running'\n\t\tconst from = order.state.from\n\t\t// stopped where it stopped last time: it gets no nearer\n\t\tif (order.state.tried !== undefined && from && hypot(from.x - entity.pos.x, from.z - entity.pos.z) < 0.5) {\n\t\t\tif (!entity.def.naval || passenger.owner !== entity.owner) return 'failed'\n\t\t\tgiveOrder(world, passenger, createOrder(world, { type: 'board', target: entity.id }))\n\t\t\treturn 'done'\n\t\t}\n\t\torder.state.tried = world.tick\n\t\torder.state.from = { x: entity.pos.x, z: entity.pos.z }\n\t\tmoveToEntity(world, entity, passenger, BOARD_REACH * 0.5)\n\t\treturn 'running'\n\t}\n}\n\n/**\n * Letting out what a transport carries: where it is, when there is land in reach; or at a point, sailing (or driving)\n * as near it as it goes first, and letting them out on the land nearest it. Failed when there is no land to let them\n * out on\n *\n * @internal\n */\nexport const unloadOrder: OrderBehavior<UnloadState, OrderInits['unload']> = {\n\ttype: 'unload',\n\taccepts(_world, entity) {\n\t\treturn !!entity.def.transport && passengersOf(entity).length > 0\n\t},\n\tupdate(world, entity, order) {\n\t\tif (!passengersOf(entity).length) return 'done'\n\t\tconst point = order.init.point\n\t\tif (!point || !entity.get(moving)) return unload(world, entity) ? 'done' : 'failed'\n\t\tif (hypot(point.x - entity.pos.x, point.z - entity.pos.z) <= UNLOAD_REACH + entity.def.radius)\n\t\t\treturn unload(world, entity, point) ? 'done' : 'failed'\n\t\tconst m = entity.get(moving)!\n\t\tif (m.status === 'moving') return 'running'\n\t\tif (order.state.sent) return unload(world, entity, point) ? 'done' : 'failed'\n\t\torder.state.sent = true\n\t\tmoveTo(world, entity, point)\n\t\treturn 'running'\n\t}\n}\n\n/** Keeps each transport's word of whether it is near the land, for its card. A few times a second */\nexport const transportSystem: System = {\n\tname: 'transports',\n\tphase: 'cleanup',\n\tevery: 6,\n\t// only what carries (given its hold as it is made: `World.spawn`, `morph`), not every unit and tree (OB5)\n\tover: cargo,\n\teach(world, entity) {\n\t\tif (!entity.def.transport || !entity.alive || entity.scenery) return\n\t\tconst held = entity.get(cargo)!\n\t\tconst ashore = !!shoreNear(world, entity.pos, UNLOAD_REACH + entity.def.radius)\n\t\tif (held.ashore !== ashore) entity.set(cargo, { passengers: held.passengers, ashore })\n\t\t// what got out some other way, or is gone\n\t\tif (held.passengers.some((id) => !world.entities.get(id)?.hidden)) {\n\t\t\tentity.set(cargo, { passengers: held.passengers.filter((id) => world.entities.get(id)?.hidden), ashore })\n\t\t}\n\t}\n}\n\n/** A transport that dies takes down what it carries with it: a boat. A building that falls lets them out */\nexport const transportSank = defineListener({\n\tid: 'core.transportSank',\n\tevent: entityDied,\n\trun(world, { entity, killer }) {\n\t\tif (entity.isStructure) {\n\t\t\tunload(world, entity)\n\t\t\treturn\n\t\t}\n\t\tfor (const id of passengersOf(entity)) {\n\t\t\tconst passenger = world.entities.get(id)\n\t\t\tif (passenger?.alive) world.kill(passenger, killer)\n\t\t}\n\t}\n})\n\n/**\n * An armed garrison (`transport.armed`): it attacks only while someone is inside, and each one inside adds to its attack\n * damage\n *\n * @internal\n */\nexport const garrisonHooks: HookDef[] = [\n\tdefineHook({\n\t\thook: 'canAttack',\n\t\tid: 'emptyGarrison',\n\t\trun(_world, event) {\n\t\t\tif (!event.cancelled && event.attacker.def.transport?.armed !== undefined && !passengersOf(event.attacker).length) event.cancelled = true\n\t\t}\n\t}),\n\tdefineHook({\n\t\thook: 'stats',\n\t\tid: 'garrisonDamage',\n\t\trun(world, { entity, add }) {\n\t\t\tconst armed = entity.def.transport?.armed\n\t\t\tconst inside = armed === undefined ? [] : passengersOf(entity)\n\t\t\tif (!inside.length) return\n\t\t\t// as declared, so much for each; or as the game works it out, from who is inside\n\t\t\tif (typeof armed === 'function') {\n\t\t\t\tconst passengers = inside.map((id) => world.entities.get(id)).filter((passenger): passenger is Entity => !!passenger)\n\t\t\t\tadd({ stats: { attackDamage: armed(world, entity, passengers) } })\n\t\t\t} else if (armed) add({ stats: { attackDamage: armed } }, inside.length)\n\t\t}\n\t})\n]\n"],"mappings":"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"}

package/dist/tunables.d.ts

@@ -1,7 +1,7 @@
 /**
  * A number of a game's rules to be tuned while it plays: the seconds between waves, how much a kill pays. Read in the
  * rules with `world.tunable(id)`, and changed while the game runs from the editor's play mode (`debug.tune`), in the
- * world itself, so that a save and a screen over a wire have the same. Given in `GameModule.tunables`
+ * world itself, so that a save and a screen over a wire have the same. Given in `Rules.tunables`
  *
  * @beta
  */
@@ -10,13 +10,20 @@ export interface TunableDef {
     id: string;
     /** What the tuning panel calls it */
     name?: string;
+    /** The value the tunable starts with */
     default: number;
+    /** The lowest value the tuning panel offers */
     min: number;
+    /** The highest value the tuning panel offers */
     max: number;
     /** What the slider steps by. A hundredth of the way from min to max when left out */
     step?: number;
 }
-/** @beta */
+/**
+ * Typed help for writing a tunable: returns the definition as given
+ *
+ * @beta
+ */
 export declare const defineTunable: (def: TunableDef) => TunableDef;
 /**
  * The tunables of a game with what a file says over their defaults: the values kept from the tuning panel, in the
@@ -24,7 +31,7 @@ export declare const defineTunable: (def: TunableDef) => TunableDef;
  *
  * @beta
  */
-export declare function withTuning(defs: readonly TunableDef[], file?: Readonly<Record<string, unknown>>): TunableDef[];
+export declare function layTuning(defs: readonly TunableDef[], file?: Readonly<Record<string, unknown>>): TunableDef[];
 /**
  * A tunable changed while the game runs: for what has to be worked out again from it
  *

package/dist/tunables.js

@@ -0,0 +1,56 @@
+import { defineComponent } from "./components.js";
+import { defineEngineEvent } from "./events.js";
+import { number, string } from "./fields.js";
+import { defineDebugCommand } from "./debugCommands.js";
+//#region src/tunables.ts
+/**
+* Typed help for writing a tunable: returns the definition as given
+*
+* @beta
+*/
+var defineTunable = (def) => def;
+/**
+* The tunables of a game with what a file says over their defaults: the values kept from the tuning panel, in the
+* game's `tuning.json` (`{ "td.betweenWaves": 12 }`). Code can still set any of them as it likes
+*
+* @beta
+*/
+function layTuning(defs, file = {}) {
+	return defs.map((def) => {
+		const value = file[def.id];
+		return typeof value === "number" && Number.isFinite(value) ? {
+			...def,
+			default: Math.min(Math.max(value, def.min), def.max)
+		} : def;
+	});
+}
+/**
+* The values the tunables of a world were set to, where they are not their defaults: kept with the world and in its save
+*
+* @internal
+*/
+var tunings = defineComponent({
+	id: "core.tunings",
+	default: () => ({})
+});
+/**
+* A tunable changed while the game runs: for what has to be worked out again from it
+*
+* @beta
+*/
+var tunableChanged = defineEngineEvent({ id: "core.tunableChanged" });
+/**
+* Sets a tunable while the game runs: for players allowed the debug tools
+*
+* @beta
+*/
+var tuneCommand = defineDebugCommand("debug.tune", {
+	id: string,
+	value: number
+}, (world, _player, command) => {
+	world.setTunable(command.id, command.value);
+});
+//#endregion
+export { defineTunable, layTuning, tunableChanged, tuneCommand, tunings };
+
+//# sourceMappingURL=tunables.js.map

package/dist/tunables.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tunables.js","names":[],"sources":["../src/tunables.ts"],"sourcesContent":["import { defineComponent } from './components'\nimport { defineDebugCommand } from './debugCommands'\nimport { defineEngineEvent } from './events'\nimport { number, string } from './fields'\n\n/**\n * A number of a game's rules to be tuned while it plays: the seconds between waves, how much a kill pays. Read in the\n * rules with `world.tunable(id)`, and changed while the game runs from the editor's play mode (`debug.tune`), in the\n * world itself, so that a save and a screen over a wire have the same. Given in `Rules.tunables`\n *\n * @beta\n */\nexport interface TunableDef {\n\t/** Shared by every game: give it a prefix of the game's */\n\tid: string\n\t/** What the tuning panel calls it */\n\tname?: string\n\t/** The value the tunable starts with */\n\tdefault: number\n\t/** The lowest value the tuning panel offers */\n\tmin: number\n\t/** The highest value the tuning panel offers */\n\tmax: number\n\t/** What the slider steps by. A hundredth of the way from min to max when left out */\n\tstep?: number\n}\n\n/**\n * Typed help for writing a tunable: returns the definition as given\n *\n * @beta\n */\nexport const defineTunable = (def: TunableDef): TunableDef => def\n\n/**\n * The tunables of a game with what a file says over their defaults: the values kept from the tuning panel, in the\n * game's `tuning.json` (`{ \"td.betweenWaves\": 12 }`). Code can still set any of them as it likes\n *\n * @beta\n */\nexport function layTuning(defs: readonly TunableDef[], file: Readonly<Record<string, unknown>> = {}): TunableDef[] {\n\treturn defs.map((def) => {\n\t\tconst value = file[def.id]\n\t\treturn typeof value === 'number' && Number.isFinite(value) ? { ...def, default: Math.min(Math.max(value, def.min), def.max) } : def\n\t})\n}\n\n/**\n * The values the tunables of a world were set to, where they are not their defaults: kept with the world and in its save\n *\n * @internal\n */\nexport const tunings = defineComponent<Record<string, number>>({ id: 'core.tunings', default: () => ({}) })\n\n/**\n * A tunable changed while the game runs: for what has to be worked out again from it\n *\n * @beta\n */\nexport const tunableChanged = defineEngineEvent<{ id: string; value: number }>({ id: 'core.tunableChanged' })\n\n/**\n * Sets a tunable while the game runs: for players allowed the debug tools\n *\n * @beta\n */\nexport const tuneCommand = defineDebugCommand('debug.tune', { id: string, value: number }, (world, _player, command) => {\n\tworld.setTunable(command.id, command.value)\n})\n"],"mappings":";;;;;;;;;;AAgCA,IAAa,iBAAiB,QAAgC;;;;;;;AAQ9D,SAAgB,UAAU,MAA6B,OAA0C,CAAC,GAAiB;CAClH,OAAO,KAAK,KAAK,QAAQ;EACxB,MAAM,QAAQ,KAAK,IAAI;EACvB,OAAO,OAAO,UAAU,YAAY,OAAO,SAAS,KAAK,IAAI;GAAE,GAAG;GAAK,SAAS,KAAK,IAAI,KAAK,IAAI,OAAO,IAAI,GAAG,GAAG,IAAI,GAAG;EAAE,IAAI;CACjI,CAAC;AACF;;;;;;AAOA,IAAa,UAAU,gBAAwC;CAAE,IAAI;CAAgB,gBAAgB,CAAC;AAAG,CAAC;;;;;;AAO1G,IAAa,iBAAiB,kBAAiD,EAAE,IAAI,sBAAsB,CAAC;;;;;;AAO5G,IAAa,cAAc,mBAAmB,cAAc;CAAE,IAAI;CAAQ,OAAO;AAAO,IAAI,OAAO,SAAS,YAAY;CACvH,MAAM,WAAW,QAAQ,IAAI,QAAQ,KAAK;AAC3C,CAAC"}

package/dist/unitResources.d.ts

@@ -0,0 +1,67 @@
+import { type AbilityDef } from './defs';
+import type { Entity } from './entity';
+import type { Vec2 } from './math';
+import type { GamePack } from './packs/pack';
+import type { World } from './world';
+/**
+ * The resources pack's id
+ *
+ * @beta
+ */
+export declare const RESOURCES = "core.resources";
+/**
+ * What a unit holds of its pools (`UnitTypeDef.pools`): how much of each (`values`), the seconds since each was last
+ * spent or given (`quiet`, for its `decay`), the seconds each has been empty (`empty`, for its `reload`) and where the
+ * unit stood a tick ago (`at`, for what fills by walking)
+ *
+ * @beta
+ */
+export interface UnitPools {
+    /** How much it holds of each, by pool */
+    values: Record<string, number>;
+    /** Seconds since each was last spent or given, by pool */
+    quiet?: Record<string, number>;
+    /** Seconds each has been empty, for one that reloads */
+    empty?: Record<string, number>;
+    /** Where it stood a tick ago, for a pool that fills by walking */
+    at?: Vec2;
+}
+/**
+ * What a unit holds of its pools (`UnitPools`): on every unit whose type has `pools`, from the moment it is made. Its
+ * players are told how much of each it holds (`values`, whole numbers), as they are of its mana
+ *
+ * @beta
+ */
+export declare const pools: import("./components").Component<UnitPools, Record<string, number>>;
+/**
+ * How much a unit holds of one of its pools (`UnitTypeDef.pools`): 0 where it has none
+ *
+ * @beta
+ */
+export declare const poolOf: (entity: Entity, pool: string) => number;
+/**
+ * Fills a pool of a unit by `amount` (empties it, under 0), as far as its bounds go, its thresholds' buffs put on and
+ * taken off, the time it decays after started over: what the `gain` effect does, and an ability's `cost` and `gain`.
+ * Nothing while a threshold's buff that `empties` it holds it still. How much it changed
+ *
+ * @beta
+ */
+export declare function changePool(world: World, entity: Entity, pool: string, amount: number): number;
+/**
+ * What an ability costs a caster of its pools now (`AbilityDef.cost`, grown by `costGrowth`), by pool: none for an ability
+ * that costs nothing of them
+ *
+ * @beta
+ */
+export declare function poolCosts(caster: Entity, ability: AbilityDef, level: number): Record<string, number> | undefined;
+/**
+ * Unit resources: what a game with it (`Rules.packs`) gets for pools beside mana. A unit type's `pools` (`PoolDef`: energy
+ * back each second, fury that decays when unused, heat that overheats at a threshold, flow filled by walking, ammo that
+ * reloads), an ability's `cost` of them (not ready with less, paid as it goes off) and `gain` (given as it goes off), costs
+ * that grow by a buff's stacks (`costGrowth`, mana too), an attack's cost (`attackCost`: no attack with less), buffs
+ * that drain a pool or mana each second while they last (`BuffDef.drain`), and the `gain` effect. `changePool`, `poolOf`
+ * and `poolCosts` in code
+ *
+ * @beta
+ */
+export declare function resourcesPack(): GamePack;