@v12-engine/engine 0.1.1 → 0.4.0

package/dist/defs.js

@@ -0,0 +1,380 @@
+//#region src/defs.ts
+/**
+* The value at a level. Levels past the end of the list get the last one
+*
+* @beta
+*/
+function at(value, level, fallback = 0) {
+	if (value === void 0) return fallback;
+	if (typeof value === "number") return value;
+	return value[Math.min(Math.max(level, 1), value.length) - 1] ?? fallback;
+}
+/**
+* The value of an amount where there is no caster to ask its code (`EffectValue`): at the level, or `fallback` for code.
+* What the aim the screen draws and a computer player's guesses go by
+*
+* @beta
+*/
+function declaredAt(value, level, fallback = 0) {
+	return typeof value === "function" ? fallback : at(value, level, fallback);
+}
+/**
+* The keys of the engine's stats, in the order `CoreStats` lists them
+*
+* @internal
+*/
+var CORE_STAT_KEYS = [
+	"attackDamage",
+	"attackSpeed",
+	"attackRange",
+	"health",
+	"armor",
+	"magicResist",
+	"incomingDamage",
+	"incomingPhysicalDamage",
+	"incomingMagicDamage",
+	"incomingTrueDamage",
+	"outgoingDamage",
+	"incomingHealing",
+	"healthRegen",
+	"mana",
+	"manaRegen",
+	"moveSpeed",
+	"sight"
+];
+/**
+* Gives a `CoreStats` with every stat at 0
+*
+* @beta
+*/
+var noStats = () => ({
+	attackDamage: 0,
+	attackSpeed: 0,
+	attackRange: 0,
+	health: 0,
+	armor: 0,
+	magicResist: 0,
+	incomingDamage: 0,
+	incomingPhysicalDamage: 0,
+	incomingMagicDamage: 0,
+	incomingTrueDamage: 0,
+	outgoingDamage: 0,
+	incomingHealing: 0,
+	healthRegen: 0,
+	mana: 0,
+	manaRegen: 0,
+	moveSpeed: 0,
+	sight: 0
+});
+/**
+* Hour of the day after so many seconds of play. Noon in a game without days
+*
+* @beta
+*/
+function hourOf(day, seconds) {
+	if (!day) return 12;
+	return (day.start + seconds / day.length * 24) % 24;
+}
+/**
+* Whether the hour (0..24) is night under the day cycle, before its dawn or from its dusk; never night without a day cycle
+*
+* @beta
+*/
+var isNight = (day, hour) => !!day && (hour < day.dawn || hour >= day.dusk);
+/**
+* How a type goes up once it is put down (`UnitTypeDef.construction`): `builder`, `self` (also `buildsItself`) or
+* `instant`
+*
+* @internal
+*/
+function constructionOf(def) {
+	return def.construction ?? (def.buildsItself ? "self" : "builder");
+}
+/**
+* What an effect waiting for a moment waits on (`EffectCommon.when`): the types that come to it, and the list of
+* theirs it goes into
+*
+* @beta
+*/
+var EFFECT_MOMENTS = {
+	hit: {
+		types: ["missile"],
+		into: "effects"
+	},
+	arrived: {
+		types: ["pull"],
+		into: "effects"
+	},
+	landed: {
+		types: ["dash"],
+		into: "effects"
+	},
+	end: {
+		types: ["missile", "zone"],
+		into: "onEnd"
+	}
+};
+/**
+* An effect as any type may be (`AnyEffect`), its fields by name
+*
+* @beta
+*/
+var anyEffect = (effect) => effect;
+/**
+* The effects inside an effect, whatever its type: what it does to what it hits (`effects`), when it is not charged
+* (`otherwise`), and at its end (`onEnd`)
+*
+* @internal
+*/
+function innerEffects(effect) {
+	const { effects, otherwise, onEnd } = anyEffect(effect);
+	return [
+		...effects ?? [],
+		...otherwise ?? [],
+		...onEnd ?? []
+	];
+}
+/** The effects a chain made (`lowerChain`), each to the effect it was made from as the list has it: what the screen is told */
+var loweredFrom = /* @__PURE__ */ new WeakMap();
+/** The lists a chain made, each to the effect whose it is as the list has it */
+var loweredLists = /* @__PURE__ */ new WeakMap();
+/**
+* The effect a list a chain made is of (`lowerChain`), as its ability has it: none for a list as written
+*
+* @internal
+*/
+var loweredListOf = (list) => loweredLists.get(list);
+/**
+* The effect as its ability has it, for one a chain made (`lowerChain` copies what waits, and what it waits on): the
+* effect itself otherwise
+*
+* @internal
+*/
+var writtenEffect = (effect) => loweredFrom.get(effect) ?? effect;
+/**
+* A list of effects as it runs (`EffectCommon.when`): every effect that waits for a moment taken out of the list and
+* put at the end of the list of the nearest one before it that comes to that moment (a missile's `effects` for `hit`,
+* its `onEnd` for `end`), copied; what waits on what waits itself goes in there. The list itself when nothing in it
+* waits, so the nested shape (`{ type: 'missile', effects: [...] }`) and a chain are one thing by the time they run.
+* One with nothing to wait on is dropped, and `orphan` told of it by its index in the list
+*
+* @beta
+*/
+function lowerChain(effects, orphan) {
+	if (!effects.some((effect) => effect.when)) return effects;
+	const top = [];
+	const seen = [];
+	effects.forEach((effect, index) => {
+		const link = {
+			effect,
+			written: effect
+		};
+		if (!effect.when) {
+			top.push(link);
+			seen.push(link);
+			return;
+		}
+		const moment = Object.hasOwn(EFFECT_MOMENTS, effect.when) ? EFFECT_MOMENTS[effect.when] : void 0;
+		let on;
+		for (let i = seen.length - 1; i >= 0 && moment && !on; i--) if (moment.types.includes(seen[i].effect.type)) on = seen[i];
+		if (!on || !moment) {
+			orphan?.(index, effect);
+			return;
+		}
+		const { when: _, ...now } = effect;
+		link.effect = now;
+		on.waiting ??= {};
+		(on.waiting[moment.into] ??= []).push(link);
+		seen.push(link);
+	});
+	const made = (link) => {
+		if (link.effect !== link.written) loweredFrom.set(link.effect, link.written);
+		if (!link.waiting) return link.effect;
+		const copy = { ...anyEffect(link.effect) };
+		for (const [into, links] of Object.entries(link.waiting)) copy[into] = [...copy[into] ?? [], ...links.map(made)];
+		loweredFrom.set(copy, link.written);
+		for (const into of Object.keys(link.waiting)) loweredLists.set(copy[into], link.written);
+		return copy;
+	};
+	return top.map(made);
+}
+/**
+* What an ability does all the time: all of a passive one, and the passive part of the others
+*
+* @internal
+*/
+var passiveEffects = (ability) => ability.target === "passive" ? ability.effects : ability.passive ?? [];
+/**
+* The types a building can be upgraded into (`UnitTypeDef.upgradesTo`), as a list: one for most, none for one that
+* turns into nothing
+*
+* @beta
+*/
+var upgradesOf = (def) => def.upgradesTo === void 0 ? [] : typeof def.upgradesTo === "string" ? [def.upgradesTo] : def.upgradesTo;
+/**
+* Gives the footprint of a unit type: its own, or a square the width of its collision diameter, rounded up
+*
+* @beta
+*/
+var footprintOf = (def) => def.footprint ?? {
+	w: Math.ceil(def.radius * 2),
+	d: Math.ceil(def.radius * 2)
+};
+/**
+* Whether things of this type only stand there, like trees and gold mines: they never move, act or change by
+* themselves, so the systems that run every tick have nothing to do for them. A map can have thousands of
+* them and they cost nothing per tick. Only things that belong to nobody (the neutral player) are treated
+* as scenery, see `World.spawn`: a player's building counts for supply, sight and victory.
+*
+* @internal
+*/
+function isScenery(def) {
+	return def.kind !== "unit" && !def.attacks?.length && !def.hero && !def.abilities?.length && !def.inventory && !def.sells?.length && !def.trains?.length && !def.researches?.length && !upgradesOf(def).length && def.lifetime === void 0 && !def.invisible && def.recovers === void 0 && !def.stats.healthRegen && !def.stats.manaRegen;
+}
+/** The one pool of supply there always is, in a supply said by pool (`UnitTypeDef.supply`) @beta */
+var MAIN_SUPPLY = "supply";
+/** What a type takes of the one pool of supply there always is (`UnitTypeDef.supply`, a number or its `supply`) @beta */
+function supplyOf(def) {
+	const { supply } = def;
+	return typeof supply === "number" ? supply : supply?.["supply"] ?? 0;
+}
+/** What a type takes of the game's own pools of supply, by name (`UnitTypeDef.supply` said by pool, the one pool left out) @beta */
+function supplyPoolsOf(def) {
+	return poolsIn(def.supply);
+}
+/** What a finished building of a type provides of the one pool of supply (`UnitTypeDef.supplyGiven`) @beta */
+function supplyGivenOf(def) {
+	const { supplyGiven } = def;
+	return typeof supplyGiven === "number" ? supplyGiven : supplyGiven?.["supply"] ?? 0;
+}
+/** What a finished building of a type provides of the game's own pools, by name (`UnitTypeDef.supplyGiven` said by pool) @beta */
+function supplyPoolsGivenOf(def) {
+	return poolsIn(def.supplyGiven);
+}
+function poolsIn(said) {
+	if (!said || typeof said === "number") return {};
+	const out = {};
+	for (const name in said) if (name !== "supply") out[name] = said[name];
+	return out;
+}
+/** Base stats worked out before, by the game they were worked out for (a unit type may be in more than one game) */
+var cache = /* @__PURE__ */ new WeakMap();
+/**
+* The stats a unit type starts with, all of them, in a game: `world.registry`, or `session.registry` on a player's
+* screen. By day unless it says otherwise
+*
+* @beta
+*/
+function baseStats(def, game, night = false) {
+	const { settings: rules } = game;
+	let cached = cache.get(game);
+	if (!cached) cache.set(game, cached = {
+		days: /* @__PURE__ */ new WeakMap(),
+		nights: /* @__PURE__ */ new WeakMap()
+	});
+	const bases = night ? cached.nights : cached.days;
+	let stats = bases.get(def);
+	if (!stats) {
+		const sight = night ? def.sightNight ?? Math.round(def.sight * rules.fog.nightSight) : def.sight;
+		stats = Object.freeze({
+			...game.statDefaults,
+			sight,
+			...def.stats,
+			...def.uses ? { health: def.uses } : void 0
+		});
+		bases.set(def, stats);
+	}
+	return stats;
+}
+/**
+* The ground an ability covers at a level: a line for what it sends on its way, a circle for what hits an area.
+* Undefined for abilities that are about one unit, or about nothing in particular.
+*
+* @beta
+*/
+function aimOf(ability, level) {
+	const { aim } = ability;
+	if (aim) {
+		if (aim.shape === "circle") return {
+			shape: "circle",
+			radius: at(aim.radius, level)
+		};
+		if (aim.shape === "cone") return {
+			shape: "cone",
+			length: at(aim.length, level),
+			angle: aim.angle
+		};
+		if (aim.shape === "ring") return {
+			shape: "ring",
+			radius: at(aim.radius, level),
+			width: at(aim.width, level)
+		};
+		if (aim.shape === "arc") return {
+			shape: "arc",
+			radius: at(aim.radius, level),
+			angle: aim.angle,
+			width: at(aim.width, level)
+		};
+		return {
+			shape: aim.shape,
+			length: at(aim.length, level),
+			width: at(aim.width, level)
+		};
+	}
+	const missile = ability.effects.find((effect) => effect.type === "missile");
+	if (missile) return {
+		shape: "line",
+		length: at(missile.distance, level, 10),
+		width: declaredAt(missile.radius, level, 1)
+	};
+	const shapedAim = shapeAim(ability.effects, level);
+	if (shapedAim) return shapedAim;
+	let radius = 0;
+	for (const effect of lowerChain(ability.effects)) if (effect.type !== "aura") radius = Math.max(radius, declaredAt(effect.radius, level));
+	return radius > 0 ? {
+		shape: "circle",
+		radius
+	} : void 0;
+}
+/** The ground of the first effect with a shape other than a circle, of a list or of a zone or delay in it, as an aim */
+function shapeAim(effects, level) {
+	for (const each of lowerChain(effects ?? [])) {
+		const effect = anyEffect(each);
+		const { shape } = effect;
+		const size = (value, fallback = 0) => declaredAt(value, level, fallback);
+		const width = size(effect.width, 1);
+		switch (shape) {
+			case "cone": return {
+				shape,
+				length: size(effect.length),
+				angle: size(effect.angle)
+			};
+			case "line":
+			case "rect":
+			case "cross": return {
+				shape,
+				length: size(effect.length),
+				width
+			};
+			case "ring": return {
+				shape,
+				radius: size(effect.radius),
+				width
+			};
+			case "arc": return {
+				shape,
+				radius: size(effect.radius),
+				angle: size(effect.angle),
+				width
+			};
+		}
+		if (effect.type === "zone" || effect.type === "after") {
+			const inner = shapeAim(effect.effects, level);
+			if (inner) return inner;
+		}
+	}
+}
+//#endregion
+export { CORE_STAT_KEYS, EFFECT_MOMENTS, MAIN_SUPPLY, aimOf, anyEffect, at, baseStats, constructionOf, declaredAt, footprintOf, hourOf, innerEffects, isNight, isScenery, lowerChain, loweredListOf, noStats, passiveEffects, supplyGivenOf, supplyOf, supplyPoolsGivenOf, supplyPoolsOf, upgradesOf, writtenEffect };
+
+//# sourceMappingURL=defs.js.map