@v12-engine/engine 0.1.0 → 0.4.0

package/dist/shared.js

@@ -0,0 +1,166 @@
+import { at, supplyOf, supplyPoolsOf } from "./defs.js";
+import { currencyOf, shortOf } from "./player.js";
+import { engineMessage } from "./messages.js";
+//#region src/shared.ts
+/**
+* Rules the simulation and a player's screen both need, written once. Each works on plain facts that a world
+* entity and a client's view of one can both give, so the screen greys out a button for the very reason the
+* simulation would refuse it, and a game's own rules (items 9 to 11) reach both alike.
+*
+* The simulation has the last word all the same: the screen may know less than it does (a buff it is not told
+* of, a step it has not seen yet), and only uses these to say something sooner.
+*/
+/**
+* Why an ability may not be used on a target, or undefined when it may
+*
+* @beta
+*/
+function targetRefusal(ability, target) {
+	const rules = ability.targets ?? {};
+	if (target.targetableBy && !target.targetableBy.includes(ability.id)) return engineMessage("cannotTargetThat");
+	if (target.untargetable && target.relation !== "self") return engineMessage("cannotTargetThat");
+	if (!(rules.kinds ?? ["unit"]).includes(target.kind)) return engineMessage("cannotTargetThat");
+	if (rules.layers && !rules.layers.includes(target.layer)) return engineMessage(target.layer === "air" ? "cannotTargetAir" : "mustTargetAir");
+	if (rules.heroes && !target.hero) return engineMessage("mustTargetHero");
+	if (rules.heroes === false && target.hero) return engineMessage("cannotTargetHero");
+	if (rules.tags && !rules.tags.some((tag) => target.tags?.includes(tag))) return engineMessage("cannotTargetThat");
+	if (target.spellImmune && target.relation !== "self" && ability.piercesImmunity !== true) return engineMessage("targetSpellImmune");
+	switch (target.relation) {
+		case "self": return rules.self ?? rules.allies ?? false ? void 0 : engineMessage("cannotTargetSelf");
+		case "ally": return rules.allies ? void 0 : engineMessage("cannotTargetFriends");
+		case "enemy":
+		case "neutral": return rules.enemies && !target.invulnerable ? void 0 : engineMessage("cannotTargetThat");
+	}
+}
+/**
+* How far away the target of an ability may be: what it says, and for some as far as the caster's attacks reach on top
+*
+* @beta
+*/
+var abilityReach = (ability, level, attackRange) => at(ability.range, level) + (ability.attackRange ? attackRange : 0);
+/**
+* How many uses an ability with charges has left (`AbilityDef.charges`), at its level: what its state says, or all it
+* holds when that says nothing. Undefined for an ability without charges
+*
+* @beta
+*/
+function chargesLeft(ability, state) {
+	if (!ability.charges) return void 0;
+	return state.charges ?? Math.max(Math.round(at(ability.charges.count, Math.max(state.level, 1))), 1);
+}
+/**
+* Why an ability cannot be used right now, or undefined when it can
+*
+* @beta
+*/
+function abilityRefusal(ability, facts) {
+	if (facts.decided !== void 0) return facts.decided ?? void 0;
+	if (facts.level < 1) return engineMessage("cannotDoThat");
+	if (facts.cooldown > 0 || facts.charges === 0) return engineMessage("notReady");
+	if (facts.grounded) return engineMessage("grounded");
+	if (facts.item) return void 0;
+	const mana = facts.noManaCosts ? 0 : at(ability.manaCost, facts.level);
+	const inHealth = facts.healthPerMana ? mana * facts.healthPerMana : 0;
+	if (!inHealth && mana > facts.mana) return engineMessage("notEnoughMana");
+	const health = inHealth + (ability.healthCost === void 0 ? 0 : at(ability.healthCost, facts.level) * facts.maxHealth);
+	if ((ability.healthCost !== void 0 || inHealth > 0) && facts.health <= health) return engineMessage("notEnoughHealth");
+	if (!facts.spell && facts.silenced) return engineMessage("silenced");
+}
+/**
+* Whether a worker gathers a kind of resource at all (`harvester.ids`): the game's `canHarvest` hook may refuse it a
+* resource all the same (`canHarvest`)
+*
+* @beta
+*/
+var gathers = (def, kind) => !!def.harvester && (!def.harvester.ids || def.harvester.ids.includes(kind));
+/**
+* Whether something of a race (`UnitTypeDef.race`, `UpgradeDef.race`) is a player's to make as their race goes: what is
+* of no race is everyone's, and a player of none (the neutral players, the creeps, any in a game without races) may
+* make anything. The `available` hook has the last word (`isAvailable`)
+*
+* @beta
+*/
+var availableTo = (def, race) => def.race === void 0 || race === void 0 || def.race === race;
+/**
+* Whether a player may make something at all, as the simulation decided (`availability`, by `key`) or else as their
+* race goes: what is not is left off their buttons
+*
+* @beta
+*/
+function availableToPlayer(def, player, key) {
+	return player.availability?.[key] ?? availableTo(def, player.race);
+}
+/**
+* Why something may not be made as far as what it requires goes: as the simulation decided (`unlocks`), or by the finished buildings it requires
+*
+* @beta
+*/
+function requirementRefusal(requires, player, key) {
+	const decided = player.unlocks?.[key];
+	if (decided !== void 0) return decided ?? void 0;
+	const lacking = missingTech(requires, player.tech);
+	return lacking.length ? engineMessage("requires", { units: lacking }) : void 0;
+}
+/**
+* The requirements a player does not meet, by unit type
+*
+* @internal
+*/
+function missingTech(requires, tech) {
+	if (!requires?.length) return NOTHING_MISSING;
+	let lacking;
+	for (const id of requires) if (!("has" in tech ? tech.has(id) : tech.includes(id))) (lacking ??= []).push(id);
+	return lacking ?? NOTHING_MISSING;
+}
+/** What `missingTech` gives when nothing is missing: the same one every time, and frozen, so nobody adds to it */
+var NOTHING_MISSING = Object.freeze([]);
+/**
+* What stands in the way of a cost, or undefined when the player can pay it
+*
+* @beta
+*/
+function costRefusal(resources, cost) {
+	const short = shortOf(resources, cost);
+	return short ? engineMessage("notEnough", { resource: short }) : void 0;
+}
+/**
+* Why a player cannot have a unit made, or undefined when they can, as far as they and the unit type go: whether
+* the building has room, and what a game's hooks say (they can change the cost), is for the simulation. In the order the
+* player is told
+*
+* @beta
+*/
+function trainRefusal(registry, def, player, options) {
+	const locked = options?.tech === false ? void 0 : requirementRefusal(def.requires, player, def.id);
+	if (locked) return locked;
+	const { settings: rules } = registry;
+	if (def.hero) {
+		if (player.heroes.includes(def.id)) return engineMessage("alreadyHaveHero");
+		if (player.heroes.length >= registry.settings.heroes.maxHeroes) return engineMessage("tooManyHeroes");
+	}
+	const supply = supplyOf(def);
+	if (supply > 0 && player.supplyUsed + supply > player.supplyCap) return engineMessage(player.supplyCap >= rules.supply.max ? "supplyLimit" : "supplyBlocked");
+	const pools = supplyPoolsOf(def);
+	for (const name in pools) {
+		const taken = pools[name];
+		const pool = player.supplies?.[name];
+		const most = rules.supply.pools?.[name]?.max;
+		if (taken > 0 && pool && pool.used + taken > pool.cap) return engineMessage(most !== void 0 && pool.cap >= most ? "supplyLimit" : "supplyBlocked", { pool: name });
+	}
+	return options?.cost === false ? void 0 : costRefusal(player.resources, def.cost);
+}
+/**
+* What a shop pays for an item: a part of its price (the item's `sellRate`, or the game's `sellPrice`), and of what is
+* left of it for what runs out (a stack counts each of it)
+*
+* @beta
+*/
+function sellValue(registry, item, charges) {
+	const def = registry.item(item);
+	const part = def.charges ? charges / def.charges : 1;
+	return Math.round(currencyOf(registry, def.cost) * (def.sellRate ?? registry.settings.economy.sellPrice) * part);
+}
+//#endregion
+export { abilityReach, abilityRefusal, availableTo, availableToPlayer, chargesLeft, costRefusal, gathers, missingTech, requirementRefusal, sellValue, targetRefusal, trainRefusal };
+
+//# sourceMappingURL=shared.js.map

package/dist/shared.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.js","names":[],"sources":["../src/shared.ts"],"sourcesContent":["/**\n * Rules the simulation and a player's screen both need, written once. Each works on plain facts that a world\n * entity and a client's view of one can both give, so the screen greys out a button for the very reason the\n * simulation would refuse it, and a game's own rules (items 9 to 11) reach both alike.\n *\n * The simulation has the last word all the same: the screen may know less than it does (a buff it is not told\n * of, a step it has not seen yet), and only uses these to say something sooner.\n */\nimport { type AbilityDef, at, type Cost, type EntityKind, type Layer, supplyOf, supplyPoolsOf, type UnitTypeDef } from './defs'\nimport { currencyOf } from './player'\nimport { engineMessage, type Message } from './messages'\nimport { type Purse, shortOf } from './player'\nimport type { Registry } from './registry'\n\n// ---- targets\n\n/**\n * Who a target is to the one using an ability on it\n *\n * @beta\n */\nexport type Relation = 'self' | 'ally' | 'enemy' | 'neutral'\n\n/**\n * What there is to know about a target, for whether an ability may be used on it\n *\n * @beta\n */\nexport interface TargetFacts {\n\t/** The target's entity kind, such as unit or structure */\n\tkind: EntityKind\n\t/** The layer the target is on (ground, air, water), which an ability's `targets` may name */\n\tlayer: Layer\n\t/** Whether the target is a hero */\n\thero: boolean\n\t/** Whether the target cannot be hurt: its type (`UnitTypeDef.invulnerable`) or a buff on it (`BuffDef.invulnerable`) */\n\tinvulnerable: boolean\n\t/** The abilities that alone may target it (`UnitTypeDef.targetableBy`) */\n\ttargetableBy?: readonly string[]\n\t/** A buff puts it out of everyone else's reach (`BuffDef.untargetable`): nothing but its own abilities is cast on it @beta */\n\tuntargetable?: boolean\n\t/** The tags of its type (`UnitTypeDef.tags`), for an ability that targets only some (`targets.tags`) @beta */\n\ttags?: readonly string[]\n\t/** What the target is to the caster: self, ally, enemy or neutral */\n\trelation: Relation\n\t/** Immune to spells (see `UnitTypeDef.spellImmune`): no ability touches it but its own, and those that get through */\n\tspellImmune?: boolean\n}\n\n/**\n * Why an ability may not be used on a target, or undefined when it may\n *\n * @beta\n */\nexport function targetRefusal(ability: AbilityDef, target: TargetFacts): Message | undefined {\n\tconst rules = ability.targets ?? {}\n\tif (target.targetableBy && !target.targetableBy.includes(ability.id)) return engineMessage('cannotTargetThat')\n\tif (target.untargetable && target.relation !== 'self') return engineMessage('cannotTargetThat')\n\tif (!(rules.kinds ?? ['unit']).includes(target.kind)) return engineMessage('cannotTargetThat')\n\tif (rules.layers && !rules.layers.includes(target.layer)) return engineMessage(target.layer === 'air' ? 'cannotTargetAir' : 'mustTargetAir')\n\tif (rules.heroes && !target.hero) return engineMessage('mustTargetHero')\n\tif (rules.heroes === false && target.hero) return engineMessage('cannotTargetHero')\n\tif (rules.tags && !rules.tags.some((tag) => target.tags?.includes(tag))) return engineMessage('cannotTargetThat')\n\t// one that gets through in code: the simulation knows it, and says so in its facts of the target\n\tif (target.spellImmune && target.relation !== 'self' && ability.piercesImmunity !== true) return engineMessage('targetSpellImmune')\n\tswitch (target.relation) {\n\t\tcase 'self':\n\t\t\treturn (rules.self ?? rules.allies ?? false) ? undefined : engineMessage('cannotTargetSelf')\n\t\tcase 'ally':\n\t\t\treturn rules.allies ? undefined : engineMessage('cannotTargetFriends')\n\t\t// neutral things are fair game for whatever can hit enemies\n\t\tcase 'enemy':\n\t\tcase 'neutral':\n\t\t\treturn rules.enemies && !target.invulnerable ? undefined : engineMessage('cannotTargetThat')\n\t}\n}\n\n/**\n * How far away the target of an ability may be: what it says, and for some as far as the caster's attacks reach on top\n *\n * @beta\n */\nexport const abilityReach = (ability: AbilityDef, level: number, attackRange: number): number =>\n\tat(ability.range, level) + (ability.attackRange ? attackRange : 0)\n\n// ---- abilities\n\n/**\n * What there is to know about an ability and its user, for whether it can be used right now\n *\n * @beta\n */\nexport interface ReadyFacts {\n\t/** 0 for one not learned yet */\n\tlevel: number\n\t/** Seconds until it can be used again */\n\tcooldown: number\n\t/** Uses left, of an ability with charges (`chargesLeft`): none, and it is not ready */\n\tcharges?: number\n\t/** The caster's mana now, to meet the ability's mana cost */\n\tmana: number\n\t/** The caster's health now, for abilities that cost health */\n\thealth: number\n\t/** The caster's largest health, which a health cost may not take below */\n\tmaxHealth: number\n\t/** It comes from something carried: items ask for no mana, and silence does not stop them */\n\titem?: boolean\n\t/** One of the spells the hero brought along rather than learned: silence does not stop those either */\n\tspell?: boolean\n\t/** Whether the caster is silenced, which stops its spells but not items or brought-along spells */\n\tsilenced?: boolean\n\t/** A buff keeps it from rushing or jumping of its own (`BuffDef.grounded`), and the ability would (a `dash`, a `blink`) */\n\tgrounded?: boolean\n\t/** The debug switch that makes abilities cost nothing */\n\tnoManaCosts?: boolean\n\t/**\n\t * Health it pays for each point of mana an ability costs, in place of the mana (`BuffDef.paysWithHealth`): none, or\n\t * left out, for one that pays with mana\n\t */\n\thealthPerMana?: number\n\t/** What the simulation's `canCast` hook decided instead, when it told the screen: a reason, or null for none */\n\tdecided?: Message | null\n}\n\n/**\n * How many uses an ability with charges has left (`AbilityDef.charges`), at its level: what its state says, or all it\n * holds when that says nothing. Undefined for an ability without charges\n *\n * @beta\n */\nexport function chargesLeft(ability: AbilityDef, state: { level: number; charges?: number }): number | undefined {\n\tif (!ability.charges) return undefined\n\treturn state.charges ?? Math.max(Math.round(at(ability.charges.count, Math.max(state.level, 1))), 1)\n}\n\n/**\n * Why an ability cannot be used right now, or undefined when it can\n *\n * @beta\n */\nexport function abilityRefusal(ability: AbilityDef, facts: ReadyFacts): Message | undefined {\n\tif (facts.decided !== undefined) return facts.decided ?? undefined\n\tif (facts.level < 1) return engineMessage('cannotDoThat')\n\tif (facts.cooldown > 0 || facts.charges === 0) return engineMessage('notReady')\n\tif (facts.grounded) return engineMessage('grounded')\n\tif (facts.item) return undefined\n\tconst mana = facts.noManaCosts ? 0 : at(ability.manaCost, facts.level)\n\t// one that pays with health (`BuffDef.paysWithHealth`) pays the mana in health too, and needs more than it all left\n\tconst inHealth = facts.healthPerMana ? mana * facts.healthPerMana : 0\n\tif (!inHealth && mana > facts.mana) return engineMessage('notEnoughMana')\n\tconst health = inHealth + (ability.healthCost === undefined ? 0 : at(ability.healthCost, facts.level) * facts.maxHealth)\n\tif ((ability.healthCost !== undefined || inHealth > 0) && facts.health <= health) return engineMessage('notEnoughHealth')\n\tif (!facts.spell && facts.silenced) return engineMessage('silenced')\n\treturn undefined\n}\n\n// ---- making things\n\n/**\n * What there is to know about a player, for whether they can make something\n *\n * @beta\n */\nexport interface PlayerFacts {\n\t/** What the player has of each resource, to meet a cost */\n\tresources: Readonly<Purse>\n\t/** Supply the player's units and queued units take up now */\n\tsupplyUsed: number\n\t/** The most supply the player may use */\n\tsupplyCap: number\n\t/** The game's other pools of supply, by name (`RuleSettings.supply.pools`): left out in a game with none */\n\tsupplies?: Readonly<Record<string, { used: number; cap: number }>>\n\t/** Unit types they have, finished, which is what requirements ask for */\n\ttech: ReadonlySet<string> | readonly string[]\n\t/** Types of the heroes they have, fallen ones and ones being made included */\n\theroes: readonly string[]\n\t/**\n\t * What the simulation's `requirement` hook decided, where it differs from what the requirements say: by unit or\n\t * structure type, and `upgrade:<id>` for the next level of research. A reason, or null for \"may, for all that\"\n\t */\n\tunlocks?: Record<string, Message | null>\n\t/** The race they play (`raceOf`): left out in a game without races */\n\trace?: string\n\t/**\n\t * What the simulation's `available` hook decided, where it differs from what their race says (`availableTo`): by\n\t * unit or structure type, and `upgrade:<id>`\n\t */\n\tavailability?: Record<string, boolean>\n}\n\n/**\n * Whether a worker gathers a kind of resource at all (`harvester.ids`): the game's `canHarvest` hook may refuse it a\n * resource all the same (`canHarvest`)\n *\n * @beta\n */\nexport const gathers = (def: Pick<UnitTypeDef, 'harvester'>, kind: string): boolean =>\n\t!!def.harvester && (!def.harvester.ids || def.harvester.ids.includes(kind))\n\n/**\n * Whether something of a race (`UnitTypeDef.race`, `UpgradeDef.race`) is a player's to make as their race goes: what is\n * of no race is everyone's, and a player of none (the neutral players, the creeps, any in a game without races) may\n * make anything. The `available` hook has the last word (`isAvailable`)\n *\n * @beta\n */\nexport const availableTo = (def: { readonly race?: string }, race: string | undefined): boolean =>\n\tdef.race === undefined || race === undefined || def.race === race\n\n/**\n * Whether a player may make something at all, as the simulation decided (`availability`, by `key`) or else as their\n * race goes: what is not is left off their buttons\n *\n * @beta\n */\nexport function availableToPlayer(def: { readonly race?: string }, player: Pick<PlayerFacts, 'race' | 'availability'>, key: string): boolean {\n\treturn player.availability?.[key] ?? availableTo(def, player.race)\n}\n\n/**\n * Why something may not be made as far as what it requires goes: as the simulation decided (`unlocks`), or by the finished buildings it requires\n *\n * @beta\n */\nexport function requirementRefusal(\n\trequires: readonly string[] | undefined,\n\tplayer: Pick<PlayerFacts, 'tech' | 'unlocks'>,\n\tkey: string\n): Message | undefined {\n\tconst decided = player.unlocks?.[key]\n\tif (decided !== undefined) return decided ?? undefined\n\tconst lacking = missingTech(requires, player.tech)\n\treturn lacking.length ? engineMessage('requires', { units: lacking }) : undefined\n}\n\n/**\n * The requirements a player does not meet, by unit type\n *\n * @internal\n */\nexport function missingTech(requires: readonly string[] | undefined, tech: PlayerFacts['tech']): string[] {\n\t// asked about every button of a card, ten times a second, and nearly always nothing is missing: nothing is made then\n\tif (!requires?.length) return NOTHING_MISSING\n\tlet lacking: string[] | undefined\n\tfor (const id of requires) if (!('has' in tech ? tech.has(id) : tech.includes(id))) (lacking ??= []).push(id)\n\treturn lacking ?? NOTHING_MISSING\n}\n\n/** What `missingTech` gives when nothing is missing: the same one every time, and frozen, so nobody adds to it */\nconst NOTHING_MISSING = Object.freeze([]) as unknown as string[]\n\n/**\n * What stands in the way of a cost, or undefined when the player can pay it\n *\n * @beta\n */\nexport function costRefusal(resources: Readonly<Purse>, cost: Cost | undefined): Message | undefined {\n\tconst short = shortOf(resources, cost)\n\treturn short ? engineMessage('notEnough', { resource: short }) : undefined\n}\n\n/**\n * Why a player cannot have a unit made, or undefined when they can, as far as they and the unit type go: whether\n * the building has room, and what a game's hooks say (they can change the cost), is for the simulation. In the order the\n * player is told\n *\n * @beta\n */\nexport function trainRefusal(\n\tregistry: Registry,\n\tdef: UnitTypeDef,\n\tplayer: PlayerFacts,\n\toptions?: { cost?: boolean; tech?: boolean }\n): Message | undefined {\n\tconst locked = options?.tech === false ? undefined : requirementRefusal(def.requires, player, def.id)\n\tif (locked) return locked\n\tconst { settings: rules } = registry\n\tif (def.hero) {\n\t\tif (player.heroes.includes(def.id)) return engineMessage('alreadyHaveHero')\n\t\tif (player.heroes.length >= registry.settings.heroes.maxHeroes) return engineMessage('tooManyHeroes')\n\t}\n\tconst supply = supplyOf(def)\n\tif (supply > 0 && player.supplyUsed + supply > player.supplyCap) {\n\t\treturn engineMessage(player.supplyCap >= rules.supply.max ? 'supplyLimit' : 'supplyBlocked')\n\t}\n\t// and of each of the game's other pools it takes of\n\tconst pools = supplyPoolsOf(def)\n\tfor (const name in pools) {\n\t\tconst taken = pools[name]\n\t\tconst pool = player.supplies?.[name]\n\t\tconst most = rules.supply.pools?.[name]?.max\n\t\tif (taken > 0 && pool && pool.used + taken > pool.cap)\n\t\t\treturn engineMessage(most !== undefined && pool.cap >= most ? 'supplyLimit' : 'supplyBlocked', { pool: name })\n\t}\n\t// the simulation checks the cost itself, once the game's hooks have had their say about it\n\treturn options?.cost === false ? undefined : costRefusal(player.resources, def.cost)\n}\n\n// ---- items and attacks\n\n/**\n * What a shop pays for an item: a part of its price (the item's `sellRate`, or the game's `sellPrice`), and of what is\n * left of it for what runs out (a stack counts each of it)\n *\n * @beta\n */\nexport function sellValue(registry: Registry, item: string, charges: number): number {\n\tconst def = registry.item(item)\n\tconst part = def.charges ? charges / def.charges : 1\n\treturn Math.round(currencyOf(registry, def.cost) * (def.sellRate ?? registry.settings.economy.sellPrice) * part)\n}\n"],"mappings":"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"}

package/dist/sides.d.ts

@@ -27,7 +27,13 @@ export declare class Sides {
     constructor(world: World);
     /** Whether everyone on a team is out */
     teamDefeated(team: number): boolean;
-    /** Whether two players fight each other: their teams, or what they were set to be (`setRelation`) */
+    /**
+     * Whether two players fight each other: their teams, or what they were set to be (`setRelation`). What every attack,
+     * cleave, area, zone, aura and missile of a player's asks of whom it may hurt. The creeps' player (`PlayerInit.creeps`,
+     * a team of its own) is everyone's enemy, so a camp is struck by all of it; the neutral player (a shop, a critter, a
+     * mine) is no one's, and is left alone. A player set apart from the creeps (`setRelation(player, creeps, 'neutral')`)
+     * reaches them with none of it
+     */
     enemies(a: PlayerId, b: PlayerId): boolean;
     /**
      * What two players are to each other from now on, whatever their teams: `ally`, `enemy`, or `neutral` (neither).
@@ -52,7 +58,7 @@ export declare class Sides {
     /**
      * Lets a player command another's units, from now on, or no longer: shared control, as allies in a melee game give
      * each other (a map's force with `sharedControl` gives it to every player of the force). Kept in the world. Who may
-     * command what is `mayCommand`, which the rules may widen or narrow (`GameRules.mayCommand`)
+     * command what is `mayCommand`, which the rules may widen or narrow (`RuleSettings.mayCommand`)
      */
     shareControl(owner: PlayerId, withPlayer: PlayerId, shared?: boolean): void;
     /** The players who may command this one's units, besides the owner (`shareControl`) */
@@ -67,7 +73,7 @@ export declare class Sides {
     }): void;
     /**
      * Whether a player may command an entity: its owner, whoever the owner shares control with, and whatever else the
-     * rules say (`GameRules.mayCommand`). What every command of the player's is checked against
+     * rules say (`RuleSettings.mayCommand`). What every command of the player's is checked against
      */
     mayCommand(player: PlayerId, entity: Entity): boolean;
     /** Whether two players are on one side: one player, a team, or what they were set to be (`setRelation`) */

package/dist/sides.js

@@ -0,0 +1,149 @@
+import { defineComponent } from "./components.js";
+import { teamChanged } from "./engineEvents.js";
+//#region src/sides.ts
+/**
+* Who is on whose side in a world (`world.sides`): teams, what two players were set to be to each other, which teams see
+* what others see, who may command whose units. What every target, every command and every player's fog asks
+*/
+/** Pairs of players set apart from their teams, by `a * RELATION_KEY + b` with a < b */
+var RELATION_KEY = 65536;
+var relations = defineComponent({
+	id: "core.relations",
+	default: () => ({ pairs: {} })
+});
+/** Teams that see what others see: by the team that sees, those it shares with */
+var vision = defineComponent({
+	id: "core.vision",
+	default: () => ({ teams: {} })
+});
+/** Who may command whose units besides their owner (`shareControl`): by the owner, the players given control. Kept in the world */
+var control = defineComponent({
+	id: "core.control",
+	default: () => ({ players: {} })
+});
+var NONE = [];
+/**
+* Who is on whose side: kept in the world's state, so a save has it
+*
+* @beta
+*/
+var Sides = class {
+	world;
+	constructor(world) {
+		this.world = world;
+	}
+	/** Whether everyone on a team is out */
+	teamDefeated(team) {
+		for (const player of this.world.players.values()) if (player.team === team && !player.neutral && !player.defeated) return false;
+		return true;
+	}
+	/**
+	* Whether two players fight each other: their teams, or what they were set to be (`setRelation`). What every attack,
+	* cleave, area, zone, aura and missile of a player's asks of whom it may hurt. The creeps' player (`PlayerInit.creeps`,
+	* a team of its own) is everyone's enemy, so a camp is struck by all of it; the neutral player (a shop, a critter, a
+	* mine) is no one's, and is left alone. A player set apart from the creeps (`setRelation(player, creeps, 'neutral')`)
+	* reaches them with none of it
+	*/
+	enemies(a, b) {
+		if (a === b) return false;
+		const set = this.relationOf(a, b);
+		if (set) return set === "enemy";
+		const pa = this.world.player(a);
+		const pb = this.world.player(b);
+		return !pa.neutral && !pb.neutral && pa.team !== pb.team;
+	}
+	/**
+	* What two players are to each other from now on, whatever their teams: `ally`, `enemy`, or `neutral` (neither).
+	* Null goes back to what their teams say. Creeps that turn friendly to one player; a ceasefire. Kept in the world:
+	* a save has it. Sight stays the teams' (see `shareVision`)
+	*/
+	setRelation(a, b, relation) {
+		if (a === b) return;
+		const key = a < b ? a * RELATION_KEY + b : b * RELATION_KEY + a;
+		const { pairs } = this.world.state(relations);
+		if (relation) pairs[key] = relation;
+		else delete pairs[key];
+	}
+	/** What two players were set to be to each other (`setRelation`), if anything */
+	relationOf(a, b) {
+		const set = this.world.states.values[relations.id];
+		if (!set) return void 0;
+		return set.pairs[a < b ? a * RELATION_KEY + b : b * RELATION_KEY + a];
+	}
+	/**
+	* Moves a player to another team, one there is or a new one: whom they fight and see with follows. What their units
+	* were doing goes on; what they fought that is now a friend, they stop fighting on their own
+	*/
+	setTeam(player, team) {
+		const moved = this.world.player(player);
+		if (moved.team === team) return;
+		const from = moved.team;
+		this.world.fog.addTeam(team);
+		moved.team = team;
+		this.world.events.emit(teamChanged, {
+			player,
+			from,
+			to: team
+		});
+	}
+	/**
+	* Lets one team see what another sees, from now on, or no longer: shared vision without an alliance. Kept in the
+	* world. A team sees what its own units see as ever
+	*/
+	shareVision(from, to, shared = true) {
+		const { teams } = this.world.state(vision);
+		const list = teams[from] ??= [];
+		const index = list.indexOf(to);
+		if (shared && index < 0 && from !== to) list.push(to);
+		if (!shared && index >= 0) list.splice(index, 1);
+		this.world.fog.addTeam(to);
+	}
+	/** The teams that see what this one sees, besides itself */
+	visionOf(team) {
+		return this.world.states.values[vision.id]?.teams[team] ?? NONE;
+	}
+	/**
+	* Lets a player command another's units, from now on, or no longer: shared control, as allies in a melee game give
+	* each other (a map's force with `sharedControl` gives it to every player of the force). Kept in the world. Who may
+	* command what is `mayCommand`, which the rules may widen or narrow (`RuleSettings.mayCommand`)
+	*/
+	shareControl(owner, withPlayer, shared = true) {
+		const { players } = this.world.state(control);
+		const list = players[owner] ??= [];
+		const index = list.indexOf(withPlayer);
+		if (shared && index < 0 && owner !== withPlayer) list.push(withPlayer);
+		if (!shared && index >= 0) list.splice(index, 1);
+	}
+	/** The players who may command this one's units, besides the owner (`shareControl`) */
+	controlOf(owner) {
+		return this.world.states.values[control.id]?.players[owner] ?? NONE;
+	}
+	/**
+	* Shares what a player has with another, from now on, or no longer: their units' control (`shareControl`) and
+	* what their team sees (`shareVision`, team to team)
+	*/
+	share(player, withPlayer, what) {
+		if (what.control !== void 0) this.shareControl(player, withPlayer, what.control);
+		if (what.vision !== void 0) this.shareVision(this.world.player(player).team, this.world.player(withPlayer).team, what.vision);
+	}
+	/**
+	* Whether a player may command an entity: its owner, whoever the owner shares control with, and whatever else the
+	* rules say (`RuleSettings.mayCommand`). What every command of the player's is checked against
+	*/
+	mayCommand(player, entity) {
+		return this.world.settings.mayCommand(this.world, player, entity);
+	}
+	/** Whether two players are on one side: one player, a team, or what they were set to be (`setRelation`) */
+	allies(a, b) {
+		if (a === b) return true;
+		const set = this.relationOf(a, b);
+		if (set) return set === "ally";
+		const pa = this.world.player(a);
+		const pb = this.world.player(b);
+		return !pa.neutral && !pb.neutral && pa.team === pb.team;
+	}
+};
+//#endregion
+export { Sides, control, relations, vision };
+
+//# sourceMappingURL=sides.js.map

package/dist/sides.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sides.js","names":[],"sources":["../src/sides.ts"],"sourcesContent":["/**\n * Who is on whose side in a world (`world.sides`): teams, what two players were set to be to each other, which teams see\n * what others see, who may command whose units. What every target, every command and every player's fog asks\n */\nimport { teamChanged } from '#engine/engineEvents'\nimport { defineComponent } from './components'\nimport type { Entity, PlayerId } from './entity'\nimport type { PlayerRelation, World } from './world'\n\n/** Pairs of players set apart from their teams, by `a * RELATION_KEY + b` with a < b */\nconst RELATION_KEY = 65536\nexport const relations = defineComponent<{ pairs: Record<number, PlayerRelation> }>({ id: 'core.relations', default: () => ({ pairs: {} }) })\n/** Teams that see what others see: by the team that sees, those it shares with */\nexport const vision = defineComponent<{ teams: Record<number, number[]> }>({ id: 'core.vision', default: () => ({ teams: {} }) })\n/** Who may command whose units besides their owner (`shareControl`): by the owner, the players given control. Kept in the world */\nexport const control = defineComponent<{ players: Record<number, number[]> }>({ id: 'core.control', default: () => ({ players: {} }) })\nconst NONE: readonly number[] = []\n\n/**\n * Who is on whose side: kept in the world's state, so a save has it\n *\n * @beta\n */\nexport class Sides {\n\tconstructor(private readonly world: World) {}\n\n\t/** Whether everyone on a team is out */\n\tteamDefeated(team: number): boolean {\n\t\tfor (const player of this.world.players.values()) if (player.team === team && !player.neutral && !player.defeated) return false\n\t\treturn true\n\t}\n\n\t/**\n\t * Whether two players fight each other: their teams, or what they were set to be (`setRelation`). What every attack,\n\t * cleave, area, zone, aura and missile of a player's asks of whom it may hurt. The creeps' player (`PlayerInit.creeps`,\n\t * a team of its own) is everyone's enemy, so a camp is struck by all of it; the neutral player (a shop, a critter, a\n\t * mine) is no one's, and is left alone. A player set apart from the creeps (`setRelation(player, creeps, 'neutral')`)\n\t * reaches them with none of it\n\t */\n\tenemies(a: PlayerId, b: PlayerId): boolean {\n\t\tif (a === b) return false\n\t\tconst set = this.relationOf(a, b)\n\t\tif (set) return set === 'enemy'\n\t\tconst pa = this.world.player(a)\n\t\tconst pb = this.world.player(b)\n\t\treturn !pa.neutral && !pb.neutral && pa.team !== pb.team\n\t}\n\n\t/**\n\t * What two players are to each other from now on, whatever their teams: `ally`, `enemy`, or `neutral` (neither).\n\t * Null goes back to what their teams say. Creeps that turn friendly to one player; a ceasefire. Kept in the world:\n\t * a save has it. Sight stays the teams' (see `shareVision`)\n\t */\n\tsetRelation(a: PlayerId, b: PlayerId, relation: PlayerRelation | null): void {\n\t\tif (a === b) return\n\t\tconst key = a < b ? a * RELATION_KEY + b : b * RELATION_KEY + a\n\t\tconst { pairs } = this.world.state(relations)\n\t\tif (relation) pairs[key] = relation\n\t\telse delete pairs[key]\n\t}\n\n\t/** What two players were set to be to each other (`setRelation`), if anything */\n\trelationOf(a: PlayerId, b: PlayerId): PlayerRelation | undefined {\n\t\t// read without making the state: a game that sets none pays nothing for it\n\t\tconst set = this.world.states.values[relations.id] as { pairs: Record<number, PlayerRelation> } | undefined\n\t\tif (!set) return undefined\n\t\treturn set.pairs[a < b ? a * RELATION_KEY + b : b * RELATION_KEY + a]\n\t}\n\n\t/**\n\t * Moves a player to another team, one there is or a new one: whom they fight and see with follows. What their units\n\t * were doing goes on; what they fought that is now a friend, they stop fighting on their own\n\t */\n\tsetTeam(player: PlayerId, team: number): void {\n\t\tconst moved = this.world.player(player)\n\t\tif (moved.team === team) return\n\t\tconst from = moved.team\n\t\tthis.world.fog.addTeam(team)\n\t\tmoved.team = team\n\t\tthis.world.events.emit(teamChanged, { player, from, to: team })\n\t}\n\n\t/**\n\t * Lets one team see what another sees, from now on, or no longer: shared vision without an alliance. Kept in the\n\t * world. A team sees what its own units see as ever\n\t */\n\tshareVision(from: number, to: number, shared = true): void {\n\t\tconst { teams } = this.world.state(vision)\n\t\tconst list = (teams[from] ??= [])\n\t\tconst index = list.indexOf(to)\n\t\tif (shared && index < 0 && from !== to) list.push(to)\n\t\tif (!shared && index >= 0) list.splice(index, 1)\n\t\tthis.world.fog.addTeam(to)\n\t}\n\n\t/** The teams that see what this one sees, besides itself */\n\tvisionOf(team: number): readonly number[] {\n\t\tconst set = this.world.states.values[vision.id] as { teams: Record<number, number[]> } | undefined\n\t\treturn set?.teams[team] ?? NONE\n\t}\n\n\t/**\n\t * Lets a player command another's units, from now on, or no longer: shared control, as allies in a melee game give\n\t * each other (a map's force with `sharedControl` gives it to every player of the force). Kept in the world. Who may\n\t * command what is `mayCommand`, which the rules may widen or narrow (`RuleSettings.mayCommand`)\n\t */\n\tshareControl(owner: PlayerId, withPlayer: PlayerId, shared = true): void {\n\t\tconst { players } = this.world.state(control)\n\t\tconst list = (players[owner] ??= [])\n\t\tconst index = list.indexOf(withPlayer)\n\t\tif (shared && index < 0 && owner !== withPlayer) list.push(withPlayer)\n\t\tif (!shared && index >= 0) list.splice(index, 1)\n\t}\n\n\t/** The players who may command this one's units, besides the owner (`shareControl`) */\n\tcontrolOf(owner: PlayerId): readonly PlayerId[] {\n\t\tconst set = this.world.states.values[control.id] as { players: Record<number, number[]> } | undefined\n\t\treturn set?.players[owner] ?? NONE\n\t}\n\n\t/**\n\t * Shares what a player has with another, from now on, or no longer: their units' control (`shareControl`) and\n\t * what their team sees (`shareVision`, team to team)\n\t */\n\tshare(player: PlayerId, withPlayer: PlayerId, what: { control?: boolean; vision?: boolean }): void {\n\t\tif (what.control !== undefined) this.shareControl(player, withPlayer, what.control)\n\t\tif (what.vision !== undefined) this.shareVision(this.world.player(player).team, this.world.player(withPlayer).team, what.vision)\n\t}\n\n\t/**\n\t * Whether a player may command an entity: its owner, whoever the owner shares control with, and whatever else the\n\t * rules say (`RuleSettings.mayCommand`). What every command of the player's is checked against\n\t */\n\tmayCommand(player: PlayerId, entity: Entity): boolean {\n\t\treturn this.world.settings.mayCommand(this.world, player, entity)\n\t}\n\n\t/** Whether two players are on one side: one player, a team, or what they were set to be (`setRelation`) */\n\tallies(a: PlayerId, b: PlayerId): boolean {\n\t\tif (a === b) return true\n\t\tconst set = this.relationOf(a, b)\n\t\tif (set) return set === 'ally'\n\t\tconst pa = this.world.player(a)\n\t\tconst pb = this.world.player(b)\n\t\treturn !pa.neutral && !pb.neutral && pa.team === pb.team\n\t}\n}\n"],"mappings":"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"}

package/dist/sight.js

@@ -0,0 +1,85 @@
+import { detection } from "./entity.js";
+import { BuffFlag, buffFlags } from "./abilities/buffs.js";
+import "./fog.js";
+//#region src/sight.ts
+/**
+* What each team of a world sees of its entities (`world.sight`): by the fog, what is invisible and who detects it, and
+* what the game makes of it (the `visible` hook: units in a bush)
+*/
+/**
+* What each team sees of a world's entities
+*
+* @beta
+*/
+var Sight = class {
+	world;
+	/**
+	* What is handed to the `visible` handlers, again and again, so that asking allocates nothing: the world's own, a
+	* handler that asks again getting an object of its own
+	*/
+	asking = {
+		entity: void 0,
+		team: 0,
+		visible: false
+	};
+	constructor(world) {
+		this.world = world;
+	}
+	/** Whether a team currently sees the entity */
+	sees(entity, team) {
+		if (entity.hidden) return false;
+		const owner = this.world.player(entity.owner);
+		if (!owner.neutral && owner.team === team) return true;
+		const seen = this.inSight(entity, team);
+		if (!this.world.hooks.has("visible")) return seen;
+		const shared = this.asking.entity === void 0;
+		const asking = shared ? this.asking : {
+			entity,
+			team,
+			visible: seen
+		};
+		asking.entity = entity;
+		asking.team = team;
+		asking.visible = seen;
+		const visible = this.world.hooks.run("visible", asking).visible;
+		if (shared) this.asking.entity = void 0;
+		return visible;
+	}
+	/** Whether an entity is invisible right now: by its type (`invisible`), or a buff that says so */
+	isInvisible(entity) {
+		if (entity.unseen) return true;
+		if (!entity.buffs.length || !(buffFlags(this.world, entity) & BuffFlag.invisible)) return false;
+		for (const instance of entity.buffs) {
+			const flag = this.world.registry.buff(instance.id).invisible;
+			if (typeof flag === "function" ? flag(this.world, entity, instance) : flag) return true;
+		}
+		return false;
+	}
+	/** Whether a team sees an entity of someone else's, by the fog and what is invisible */
+	inSight(entity, team) {
+		if (this.isInvisible(entity) && !entity.get(detection)?.has(team)) return false;
+		const { fog } = this.world;
+		const { x, z } = entity.pos;
+		if (entity.def.footprint) {
+			const hw = entity.halfWidth;
+			const hd = entity.halfDepth;
+			const left = Math.floor(x - hw + .5);
+			const right = Math.floor(x + hw - .5);
+			const front = Math.floor(z - hd + .5);
+			const back = Math.floor(z + hd - .5);
+			return fog.stateAt(team, Math.floor(x), Math.floor(z)) === 2 || fog.stateAt(team, left, front) === 2 || fog.stateAt(team, right, front) === 2 || fog.stateAt(team, left, back) === 2 || fog.stateAt(team, right, back) === 2;
+		}
+		return fog.stateAt(team, Math.floor(x), Math.floor(z)) === 2;
+	}
+	/**
+	* Whether a team has ever laid eyes on the entity. Kept up to date for structures only, see the fog system.
+	* A team that sees the whole map (out of the game, or a debug switch) has seen everything there is
+	*/
+	hasSeen(entity, team) {
+		return this.world.fog.isRevealed(team) || (entity.seenBy & this.world.fog.teamBit(team)) !== 0;
+	}
+};
+//#endregion
+export { Sight };
+
+//# sourceMappingURL=sight.js.map

package/dist/sight.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sight.js","names":[],"sources":["../src/sight.ts"],"sourcesContent":["/**\n * What each team of a world sees of its entities (`world.sight`): by the fog, what is invisible and who detects it, and\n * what the game makes of it (the `visible` hook: units in a bush)\n */\nimport { BuffFlag, buffFlags } from './abilities/buffs'\nimport { detection } from './entity'\nimport type { Entity } from './entity'\nimport { FOG_VISIBLE } from './fog'\nimport type { World } from './world'\n\n/**\n * What each team sees of a world's entities\n *\n * @beta\n */\nexport class Sight {\n\t/**\n\t * What is handed to the `visible` handlers, again and again, so that asking allocates nothing: the world's own, a\n\t * handler that asks again getting an object of its own\n\t */\n\tprivate readonly asking: { entity: Entity; team: number; visible: boolean } = { entity: undefined!, team: 0, visible: false }\n\n\tconstructor(private readonly world: World) {}\n\n\t/** Whether a team currently sees the entity */\n\tsees(entity: Entity, team: number): boolean {\n\t\tif (entity.hidden) return false\n\t\tconst owner = this.world.player(entity.owner)\n\t\tif (!owner.neutral && owner.team === team) return true\n\t\tconst seen = this.inSight(entity, team)\n\t\t// what the game makes of it: units in brush, a tower that sees everything near it. Asked for every entity, team\n\t\t// and snapshot: the one object handed out again and again, so that asking allocates nothing\n\t\tif (!this.world.hooks.has('visible')) return seen\n\t\t// a handler that asks again, as it decides (a game's `seenBy`): an object of its own then\n\t\tconst shared = this.asking.entity === undefined\n\t\tconst asking = shared ? this.asking : { entity, team, visible: seen }\n\t\tasking.entity = entity\n\t\tasking.team = team\n\t\tasking.visible = seen\n\t\tconst visible = this.world.hooks.run('visible', asking).visible\n\t\tif (shared) this.asking.entity = undefined!\n\t\treturn visible\n\t}\n\n\t/** Whether an entity is invisible right now: by its type (`invisible`), or a buff that says so */\n\tisInvisible(entity: Entity): boolean {\n\t\tif (entity.unseen) return true\n\t\tif (!entity.buffs.length || !(buffFlags(this.world, entity) & BuffFlag.invisible)) return false\n\t\tfor (const instance of entity.buffs) {\n\t\t\tconst flag = this.world.registry.buff(instance.id).invisible\n\t\t\tif (typeof flag === 'function' ? flag(this.world, entity, instance) : flag) return true\n\t\t}\n\t\treturn false\n\t}\n\n\t/** Whether a team sees an entity of someone else's, by the fog and what is invisible */\n\tprivate inSight(entity: Entity, team: number): boolean {\n\t\tif (this.isInvisible(entity) && !entity.get(detection)?.has(team)) return false\n\t\t// by whole cells, as the fog has them: a whole number is handed on as it is, where a fraction would be boxed for\n\t\t// each ask (every structure in every lit circle, every fog update)\n\t\tconst { fog } = this.world\n\t\tconst { x, z } = entity.pos\n\t\tif (entity.def.footprint) {\n\t\t\t// structures are visible as soon as any part of them is\n\t\t\tconst hw = entity.halfWidth\n\t\t\tconst hd = entity.halfDepth\n\t\t\tconst left = Math.floor(x - hw + 0.5)\n\t\t\tconst right = Math.floor(x + hw - 0.5)\n\t\t\tconst front = Math.floor(z - hd + 0.5)\n\t\t\tconst back = Math.floor(z + hd - 0.5)\n\t\t\treturn (\n\t\t\t\tfog.stateAt(team, Math.floor(x), Math.floor(z)) === FOG_VISIBLE ||\n\t\t\t\tfog.stateAt(team, left, front) === FOG_VISIBLE ||\n\t\t\t\tfog.stateAt(team, right, front) === FOG_VISIBLE ||\n\t\t\t\tfog.stateAt(team, left, back) === FOG_VISIBLE ||\n\t\t\t\tfog.stateAt(team, right, back) === FOG_VISIBLE\n\t\t\t)\n\t\t}\n\t\treturn fog.stateAt(team, Math.floor(x), Math.floor(z)) === FOG_VISIBLE\n\t}\n\n\t/**\n\t * Whether a team has ever laid eyes on the entity. Kept up to date for structures only, see the fog system.\n\t * A team that sees the whole map (out of the game, or a debug switch) has seen everything there is\n\t */\n\thasSeen(entity: Entity, team: number): boolean {\n\t\treturn this.world.fog.isRevealed(team) || (entity.seenBy & this.world.fog.teamBit(team)) !== 0\n\t}\n}\n"],"mappings":";;;;;;;;;;;;;AAeA,IAAa,QAAb,MAAmB;CAOW;;;;;CAF7B,SAA8E;EAAE,QAAQ,KAAA;EAAY,MAAM;EAAG,SAAS;CAAM;CAE5H,YAAY,OAA+B;EAAd,KAAA,QAAA;CAAe;;CAG5C,KAAK,QAAgB,MAAuB;EAC3C,IAAI,OAAO,QAAQ,OAAO;EAC1B,MAAM,QAAQ,KAAK,MAAM,OAAO,OAAO,KAAK;EAC5C,IAAI,CAAC,MAAM,WAAW,MAAM,SAAS,MAAM,OAAO;EAClD,MAAM,OAAO,KAAK,QAAQ,QAAQ,IAAI;EAGtC,IAAI,CAAC,KAAK,MAAM,MAAM,IAAI,SAAS,GAAG,OAAO;EAE7C,MAAM,SAAS,KAAK,OAAO,WAAW,KAAA;EACtC,MAAM,SAAS,SAAS,KAAK,SAAS;GAAE;GAAQ;GAAM,SAAS;EAAK;EACpE,OAAO,SAAS;EAChB,OAAO,OAAO;EACd,OAAO,UAAU;EACjB,MAAM,UAAU,KAAK,MAAM,MAAM,IAAI,WAAW,MAAM,CAAC,CAAC;EACxD,IAAI,QAAQ,KAAK,OAAO,SAAS,KAAA;EACjC,OAAO;CACR;;CAGA,YAAY,QAAyB;EACpC,IAAI,OAAO,QAAQ,OAAO;EAC1B,IAAI,CAAC,OAAO,MAAM,UAAU,EAAE,UAAU,KAAK,OAAO,MAAM,IAAI,SAAS,YAAY,OAAO;EAC1F,KAAK,MAAM,YAAY,OAAO,OAAO;GACpC,MAAM,OAAO,KAAK,MAAM,SAAS,KAAK,SAAS,EAAE,CAAC,CAAC;GACnD,IAAI,OAAO,SAAS,aAAa,KAAK,KAAK,OAAO,QAAQ,QAAQ,IAAI,MAAM,OAAO;EACpF;EACA,OAAO;CACR;;CAGA,QAAgB,QAAgB,MAAuB;EACtD,IAAI,KAAK,YAAY,MAAM,KAAK,CAAC,OAAO,IAAI,SAAS,CAAC,EAAE,IAAI,IAAI,GAAG,OAAO;EAG1E,MAAM,EAAE,QAAQ,KAAK;EACrB,MAAM,EAAE,GAAG,MAAM,OAAO;EACxB,IAAI,OAAO,IAAI,WAAW;GAEzB,MAAM,KAAK,OAAO;GAClB,MAAM,KAAK,OAAO;GAClB,MAAM,OAAO,KAAK,MAAM,IAAI,KAAK,EAAG;GACpC,MAAM,QAAQ,KAAK,MAAM,IAAI,KAAK,EAAG;GACrC,MAAM,QAAQ,KAAK,MAAM,IAAI,KAAK,EAAG;GACrC,MAAM,OAAO,KAAK,MAAM,IAAI,KAAK,EAAG;GACpC,OACC,IAAI,QAAQ,MAAM,KAAK,MAAM,CAAC,GAAG,KAAK,MAAM,CAAC,CAAC,MAAA,KAC9C,IAAI,QAAQ,MAAM,MAAM,KAAK,MAAA,KAC7B,IAAI,QAAQ,MAAM,OAAO,KAAK,MAAA,KAC9B,IAAI,QAAQ,MAAM,MAAM,IAAI,MAAA,KAC5B,IAAI,QAAQ,MAAM,OAAO,IAAI,MAAA;EAE/B;EACA,OAAO,IAAI,QAAQ,MAAM,KAAK,MAAM,CAAC,GAAG,KAAK,MAAM,CAAC,CAAC,MAAA;CACtD;;;;;CAMA,QAAQ,QAAgB,MAAuB;EAC9C,OAAO,KAAK,MAAM,IAAI,WAAW,IAAI,MAAM,OAAO,SAAS,KAAK,MAAM,IAAI,QAAQ,IAAI,OAAO;CAC9F;AACD"}

package/dist/simulate-worker.js

@@ -1,4 +1,4 @@
-import { n as playGame } from "./simulate-oXBiw1Ff.js";
+import { playGame } from "./simulate.js";
 import { parentPort } from "node:worker_threads";
 //#region src/simulate-worker.ts
 /**

package/dist/simulate.d.ts

@@ -1,7 +1,7 @@
 import type { AiOptions } from './ai/options';
 import type { BrainDef } from './ai/brain';
 import type { PlayerId } from './entity';
-import { type GameModule } from './game';
+import { type Rules } from './game';
 import { type GameMap } from './map';
 import type { World } from './world';
 /**
@@ -13,10 +13,12 @@ export type Counted = number | string | boolean | null;
 /**
  * A game to play many times (`simulate`): the rules, the map, who the computer plays and how, and what to count
  *
- * @beta
+ * @public
  */
 export interface Simulation {
-    game: GameModule;
+    /** The game module's rules each simulated game is played with */
+    rules: Rules;
+    /** The map each simulated game is made from */
     map: GameMap;
     /**
      * The players the computer plays: every player of the map with a start, the creeps apart, when left out. One left
@@ -24,7 +26,7 @@ export interface Simulation {
      */
     computers?: PlayerId[];
     /**
-     * The brain each player is played by, or its id (one the game lists in `GameModule.brains`, or the engine's
+     * The brain each player is played by, or its id (one the game lists in `Rules.brains`, or the engine's
      * `core.melee`): two brains against each other, for a balance run. A player not named here is played by the first
      * brain the game lists
      */
@@ -36,7 +38,7 @@ export interface Simulation {
     /** How the computer plays a player, over what it is given (`enemyBases`: where the others start) */
     ai?: (player: PlayerId, world: World) => Partial<AiOptions>;
     /** What the game does once a world is made, before the first tick: units of its own, a rule turned on */
-    start?: (world: World) => void;
+    onStart?: (world: World) => void;
     /** Seconds of the game at most: twenty minutes when left out */
     seconds?: number;
     /** Whether the game is over before that: once there is a winner, when left out */
@@ -76,11 +78,13 @@ export interface ComputerMeasures {
  * @beta
  */
 export interface SimulatedGame {
+    /** The seed the game was played with */
     seed: number;
     /** The winning team, or null for none in the time given */
     winner: number | null;
     /** Seconds of the game it lasted, and ticks */
     seconds: number;
+    /** How many ticks the game lasted */
     ticks: number;
     /** Why it stopped on an error of its rules, where it did (`World.failure`) */
     failed?: string;
@@ -94,7 +98,6 @@ export interface SimulatedGame {
 /** A simulation, as a module that a worker imports gives it: as it is written, for its type *
  * @beta
  */
-export declare const defineSimulation: (simulation: Simulation) => Simulation;
 /** Plays one game of a simulation from a seed, in this thread *
  * @beta
  */
@@ -107,6 +110,7 @@ export declare function playGame(simulation: Simulation, seed: number): Promise<
 export interface BrainResults {
     /** Seats it played */
     games: number;
+    /** Seats whose team won */
     wins: number;
     /** Seats whose team another team beat */
     losses: number;
@@ -146,9 +150,9 @@ export interface SimulateOptions {
 /**
  * Plays games of a simulation, one from each seed, and gives what each ended in, in the order of the seeds. Given as
  * it is, they are played in this thread. Given as the address of a file (a module whose `default`, or `simulation`, is
- * one: `defineSimulation`), each worker thread imports it and plays its share: in Node, from the built packages (a
+ * one: a `Simulation`), each worker thread imports it and plays its share: in Node, from the built packages (a
  * worker loads JavaScript, not the TypeScript of this repository)
  *
- * @beta
+ * @public
  */
 export declare function simulate(simulation: Simulation | string | URL, options: SimulateOptions): Promise<SimulatedGame[]>;