@v12-engine/engine 0.1.1 → 0.4.0

package/dist/lanes.d.ts

@@ -36,6 +36,7 @@ export declare const LANE_SPAWNER_KIND: {
 export interface Lane {
     /** The name of its path (`world.map.path(name)`), what orders that follow it are given */
     path: string;
+    /** The points of the lane's path, in order from its first end to its last */
     points: readonly Vec2[];
     /** Its spawners, by the end of the lane they are at: the first point's, then the last's. Either is missing on a map not finished */
     ends: [LaneEnd | undefined, LaneEnd | undefined];
@@ -46,8 +47,11 @@ export interface Lane {
  * @beta
  */
 export interface LaneEnd {
+    /** The map's spawner object at this end of the lane */
     spawner: MapThing;
+    /** The player whose waves start at this end */
     player: PlayerId;
+    /** The point the spawner stands at */
     at: Vec2;
 }
 /**
@@ -79,13 +83,17 @@ export declare function checkLanes(map: GameMap): MapProblem[];
  * @beta
  */
 export interface LaneWave {
+    /** The wave's number at its spawner, counting from 1 */
     number: number;
+    /** The lane the wave walks */
     lane: Lane;
+    /** Which end of the lane it starts from: 0 the first point's, 1 the last's */
     from: 0 | 1;
+    /** The player whose wave it is */
     player: PlayerId;
 }
 /**
- * What a game's lanes do (`withLanes`). Every part has the engine's own when left out
+ * What a game's lanes do (`lanesPack`). Every part has the engine's own when left out
  *
  * @beta
  */
@@ -104,6 +112,7 @@ export interface LanesOptions {
     wave?: (world: World, wave: LaneWave) => string[];
     /** Seconds from the start to the first wave, and between waves: 20 and 30 when left out */
     firstWave?: number;
+    /** Seconds between one wave and the next; 30 when left out */
     every?: number;
     /**
      * Where a minion goes once it is at the far end of its lane, fighting on the way: the nearest structure of another
@@ -118,7 +127,7 @@ export interface LanesOptions {
     /**
      * What the cores are: the unit type's id, or a test of a unit. A side whose cores have all fallen has lost, and the
      * last side with one wins. Said by the game (the engine names none); `false` keeps the game's own way of winning
-     * (`GameModule.victory`)
+     * (`Rules.victory`)
      */
     cores: string | ((world: World, entity: Entity) => boolean) | false;
     /** Seconds a hero who hit a hero is the towers' first target for: 3 when left out */
@@ -192,7 +201,7 @@ export declare const wavesSent: (world: World, spawner: number) => number;
  *
  * @beta
  */
-export declare function withLanes(options: LanesOptions): GamePack;
+export declare function lanesPack(options: LanesOptions): GamePack;
 /**
  * When a hero last hit a hero of another side, in seconds of the game's time: what the lane towers of the side it hit
  * go for first, for a while (`LanesOptions.towerAggro`)

package/dist/lanes.js

@@ -0,0 +1,496 @@
+import { atan2, hypot } from "./exactMath.js";
+import { distSq } from "./math.js";
+import { defineComponent } from "./components.js";
+import { defineListener } from "./events.js";
+import { damaged, gameOver } from "./engineEvents.js";
+import { fighting } from "./entity.js";
+import { defineHook } from "./hooks.js";
+import { engageWith } from "./engagement.js";
+import { disengage } from "./systems/combat.js";
+import { mapThings } from "./mapFields.js";
+import { defineTimer } from "./timers.js";
+import { defeat } from "./systems/victory.js";
+//#region src/lanes.ts
+/**
+* The kind of thing a spawner is: where it is kept in the map's data, by this id
+*
+* @beta
+*/
+var LANE_SPAWNERS = "lanes.spawners";
+/**
+* How near the end of its lane a spawner is to be that end's: in cells
+*
+* @internal
+*/
+var LANE_END_REACH = 6;
+/**
+* The fields of a spawner: whose waves come out of it, and the lane they walk
+*
+* @internal
+*/
+var LANE_SPAWNER_FIELDS = [{
+	id: "player",
+	name: "Player",
+	kind: "player",
+	default: 1,
+	hint: "Whose waves come out of it"
+}, {
+	id: "lane",
+	name: "Lane",
+	kind: "path",
+	hint: "The path its waves walk, from the end it stands at to the other"
+}];
+/**
+* A spawner as the editor offers it (a `MapKindDef` of `@v12-engine/client`): its tool, its fields, a ring at each, in
+* the scene's `kinds`
+*
+* @beta
+*/
+var LANE_SPAWNER_KIND = {
+	id: LANE_SPAWNERS,
+	name: "Spawner",
+	plural: "Spawners",
+	hint: "Where a side’s waves of minions come out, at one end of a lane: its player, and the path it is the end of",
+	icon: "tool.circle",
+	color: [
+		.95,
+		.75,
+		.25
+	],
+	fields: LANE_SPAWNER_FIELDS,
+	reach: 3
+};
+/** The path a spawner is on, by the id its field keeps */
+var pathOf = (paths, spawner) => {
+	const id = spawner.data?.lane;
+	return typeof id === "number" ? paths.find((path) => path.id === id) : typeof id === "string" ? paths.find((path) => path.name === id) : void 0;
+};
+/** Which end of a path a place is at: 0 the first point's, 1 the last's, or none when it is near neither */
+function endOf(path, at) {
+	const first = path.points[0];
+	const last = path.points[path.points.length - 1];
+	if (!first || !last) return void 0;
+	const d0 = hypot(at.x - first.x, at.z - first.z);
+	const d1 = hypot(at.x - last.x, at.z - last.z);
+	if (Math.min(d0, d1) > 6) return void 0;
+	return d0 <= d1 ? 0 : 1;
+}
+/**
+* The lanes of a map: every path a spawner is on, with what stands at each end
+*
+* @beta
+*/
+function mapLanes(map) {
+	const lanes = /* @__PURE__ */ new Map();
+	for (const spawner of mapThings(map, LANE_SPAWNERS)) {
+		const path = pathOf(map.paths, spawner);
+		if (!path) continue;
+		let lane = lanes.get(path.id);
+		if (!lane) lanes.set(path.id, lane = {
+			path: path.name,
+			points: path.points,
+			ends: [void 0, void 0]
+		});
+		const end = endOf(path, spawner);
+		if (end === void 0) continue;
+		lane.ends[end] = {
+			spawner,
+			player: Number(spawner.data?.player ?? 1),
+			at: {
+				x: spawner.x,
+				z: spawner.z
+			}
+		};
+	}
+	return [...lanes.values()];
+}
+/**
+* The lanes of a world's map (`mapLanes`): what waves walk
+*
+* @beta
+*/
+var lanesOf = (world) => mapLanes({
+	paths: world.map.paths,
+	data: world.map.data
+});
+/**
+* What is wrong with the lanes of a map, for the editor's checks (`MapEditorDef.check`): a spawner on no lane or away
+* from its ends, a lane without a spawner at each end, or with the same side at both
+*
+* @beta
+*/
+function checkLanes(map) {
+	const problems = [];
+	const teamOf = (player) => map.players.find((each) => each.id === player)?.team ?? player;
+	for (const spawner of mapThings(map, LANE_SPAWNERS)) {
+		const path = pathOf(map.paths, spawner);
+		const about = {
+			thing: spawner.id,
+			kind: LANE_SPAWNERS
+		};
+		if (!path) problems.push({
+			message: "A spawner is on no lane: pick the path its waves walk",
+			error: true,
+			rule: "lanes.spawner",
+			at: spawner,
+			about
+		});
+		else if (endOf(path, spawner) === void 0) problems.push({
+			message: `A spawner of "${path.name}" is at neither end of it`,
+			error: true,
+			rule: "lanes.spawner",
+			at: spawner,
+			about
+		});
+	}
+	for (const lane of mapLanes(map)) {
+		const path = map.paths.find((each) => each.name === lane.path);
+		const about = { path: path.id };
+		const [first, last] = lane.ends;
+		if (!first || !last) {
+			const missing = !first ? path.points[0] : path.points[path.points.length - 1];
+			problems.push({
+				message: `The lane "${lane.path}" has no spawner at one end: its waves start at both`,
+				error: true,
+				rule: "lanes.ends",
+				at: missing,
+				about
+			});
+		} else if (teamOf(first.player) === teamOf(last.player)) problems.push({
+			message: `The lane "${lane.path}" has the same side at both ends`,
+			error: true,
+			rule: "lanes.sides",
+			at: first.at,
+			about
+		});
+	}
+	return problems;
+}
+/**
+* A minion of a lane: the lane it walks (its path's name), from which end. On every unit a wave brings
+*
+* @beta
+*/
+var laneMinion = defineComponent({ id: "lanes.minion" });
+/** How many waves each spawner has sent, by its id, and whether the waves were set going */
+var lanesState = defineComponent({
+	id: "lanes.state",
+	default: () => ({
+		started: false,
+		waves: {}
+	})
+});
+/**
+* The engine's waves: three close and two that shoot, one more close every fourth wave and one more that shoots every
+* sixth, a siege every third wave (two from the twelfth). Of the types a game has
+*
+* @beta
+*/
+function defaultWave(world, wave, minions) {
+	const { melee, ranged, siege } = minions;
+	const n = wave.number;
+	return [
+		...Array(3 + Math.floor((n - 1) / 4)).fill(melee),
+		...Array(2 + Math.floor((n - 1) / 6)).fill(ranged),
+		...Array(siege && n % 3 === 0 ? 1 + Math.floor(n / 12) : 0).fill(siege ?? "")
+	].filter((type) => world.registry.units.has(type));
+}
+/** The nearest structure of another team to a lane's far end, within reach of it: what a wave goes for once there */
+function defaultGoal(world, minion, lane, from) {
+	const end = lane.points[from === 0 ? lane.points.length - 1 : 0];
+	let best;
+	let bestDistance = 576;
+	for (const entity of world.entities.values()) {
+		if (!entity.alive || !entity.isStructure || !world.areEnemies(entity.owner, minion.owner)) continue;
+		const d = distSq(entity.pos, end);
+		if (d < bestDistance) {
+			bestDistance = d;
+			best = entity;
+		}
+	}
+	return best ? {
+		x: best.pos.x,
+		z: best.pos.z
+	} : end;
+}
+/**
+* Sends a spawner's next wave now, whatever its timer, as the game's lanes say (`LanesOptions`): for scripts, tests and debug tools. Its units come out by the
+* spawner, walk the lane fighting what they meet (`attackPath`), then go for the goal at its far end. Gives back the
+* units, none for a spawner on no lane
+*
+* @beta
+*/
+function sendWave(world, spawner, options) {
+	for (const lane of lanesOf(world)) {
+		const from = lane.ends[0]?.spawner.id === spawner ? 0 : lane.ends[1]?.spawner.id === spawner ? 1 : void 0;
+		if (from === void 0) continue;
+		const end = lane.ends[from];
+		const state = world.state(lanesState);
+		const number = (state.waves[spawner] ?? 0) + 1;
+		state.waves[spawner] = number;
+		const wave = {
+			number,
+			lane,
+			from,
+			player: end.player
+		};
+		if (!options.wave && !options.minions) throw new Error("sendWave needs the wave (`wave`) or the unit types of its minions (`minions`)");
+		const types = options.wave ? options.wave(world, wave) : defaultWave(world, wave, options.minions);
+		const next = lane.points[from === 0 ? 1 : lane.points.length - 2] ?? end.at;
+		const length = hypot(next.x - end.at.x, next.z - end.at.z) || 1;
+		const ahead = {
+			x: (next.x - end.at.x) / length,
+			z: (next.z - end.at.z) / length
+		};
+		const units = types.map((type, i) => {
+			const row = Math.floor(i / 3);
+			const side = i % 3 - 1;
+			const at = {
+				x: end.at.x - ahead.x * row * 1.2 - ahead.z * side * 1.2,
+				z: end.at.z - ahead.z * row * 1.2 + ahead.x * side * 1.2
+			};
+			const unit = world.spawn(type, end.player, at, { facing: atan2(ahead.x, ahead.z) });
+			unit.set(laneMinion, {
+				lane: lane.path,
+				from
+			});
+			return unit;
+		});
+		if (!units.length) return units;
+		alongLane(world, units, lane, from, options);
+		return units;
+	}
+	return [];
+}
+/** Minions sent along their lane from where they are, the way they go (away from their end), then to the goal */
+function alongLane(world, units, lane, from, options) {
+	const entities = units.map((unit) => unit.id);
+	const player = units[0].owner;
+	world.issue({
+		type: "order",
+		player,
+		entities,
+		order: {
+			type: "attackPath",
+			path: lane.path,
+			towards: from === 0 ? "last" : "first"
+		}
+	});
+	const goal = (options.goal ?? defaultGoal)(world, units[0], lane, from);
+	if (goal) world.issue({
+		type: "order",
+		player,
+		entities,
+		order: {
+			type: "attackMove",
+			point: goal
+		},
+		queue: true
+	});
+}
+/** How far a place is from a lane's line */
+function offLane(lane, at) {
+	let best = Infinity;
+	const { points } = lane;
+	for (let i = 1; i < points.length; i++) {
+		const a = points[i - 1];
+		const dx = points[i].x - a.x;
+		const dz = points[i].z - a.z;
+		const length = dx * dx + dz * dz;
+		const t = length > 0 ? Math.min(Math.max(((at.x - a.x) * dx + (at.z - a.z) * dz) / length, 0), 1) : 0;
+		best = Math.min(best, hypot(at.x - (a.x + dx * t), at.z - (a.z + dz * t)));
+	}
+	return best;
+}
+/**
+* How many waves a spawner has sent
+*
+* @beta
+*/
+var wavesSent = (world, spawner) => world.state(lanesState).waves[spawner] ?? 0;
+/**
+* A game with lanes: its maps' lanes checked in the editor, and waves of minions sent along them from every spawner,
+* the first `firstWave` seconds in and one every `every` seconds after, each from the `wave` of its number (see
+* `LanesOptions`). What it adds goes with what the game has: its timers and components saved, its check after its own
+*
+* @beta
+*/
+function lanesPack(options) {
+	if (!options.wave && !(options.minions?.melee && options.minions.ranged)) throw new Error("lanesPack needs the unit types of its waves (`minions: { melee, ranged }`) or a `wave` of its own");
+	if (options.cores === void 0) throw new Error("lanesPack needs to be told what the cores are (`cores`: a unit type's id, a test, or false)");
+	const firstWave = options.firstWave ?? 20;
+	const every = options.every ?? 30;
+	const waveDue = defineTimer({
+		id: "lanes.wave",
+		run: (world, data) => {
+			if (world.winner === null) sendWave(world, data.spawner, options);
+		}
+	});
+	const start = {
+		name: "lanes.start",
+		every: 15,
+		update(world) {
+			const state = world.state(lanesState);
+			if (state.started) return;
+			state.started = true;
+			for (const lane of lanesOf(world)) for (const end of lane.ends) if (end) world.timers.every(every, waveDue, {
+				first: firstWave,
+				data: { spawner: end.spawner.id }
+			});
+		}
+	};
+	const { hooks, listeners, systems } = towerRules(options);
+	return {
+		id: "lanes",
+		options,
+		components: [
+			laneMinion,
+			lanesState,
+			heroStrike
+		],
+		timers: [waveDue],
+		systems: [start, ...systems],
+		hooks,
+		listeners,
+		...options.cores !== false && { victory: coreVictory(coresOf(options.cores)) },
+		settings: (rules) => ({ supply: { of: (world, unit) => "has" in unit && unit.has(laneMinion) ? 0 : rules.supply.of(world, unit) } }),
+		check: (map) => checkLanes(map)
+	};
+}
+/**
+* When a hero last hit a hero of another side, in seconds of the game's time: what the lane towers of the side it hit
+* go for first, for a while (`LanesOptions.towerAggro`)
+*
+* @beta
+*/
+var heroStrike = defineComponent({ id: "lanes.heroStrike" });
+/** The engine's lane towers: structures that attack, other than cores */
+var isTower = (world, entity, cores) => entity.isStructure && !!entity.def.attacks?.length && !(cores && coresOf(cores)(world, entity));
+/** What the cores are, as a test of a unit: the unit type's id said, or the game's own test */
+var coresOf = (cores) => typeof cores === "string" ? (_world, entity) => entity.def.id === cores : cores;
+/**
+* The rule of a lanes game: a side whose cores have all fallen is out, and the last side with a core wins. A side
+* takes part once it has had a core
+*
+* @beta
+*/
+function coreVictory(cores) {
+	return {
+		name: "victory",
+		phase: "cleanup",
+		every: 15,
+		update(world) {
+			if (world.winner !== null) return;
+			const standing = /* @__PURE__ */ new Set();
+			for (const entity of world.entities.values()) if (entity.alive && cores(world, entity)) standing.add(world.player(entity.owner).team);
+			const sides = /* @__PURE__ */ new Set();
+			for (const player of world.players.values()) {
+				if (player.neutral || player.creeps) continue;
+				if (standing.has(player.team)) player.established = true;
+				if (!player.established) continue;
+				sides.add(player.team);
+				if (!standing.has(player.team) && !player.defeated) defeat(world, player.id);
+			}
+			if (sides.size < 2 || standing.size !== 1) return;
+			const [winner] = standing;
+			world.winner = winner;
+			world.events.emit(gameOver, { winner });
+		}
+	};
+}
+/** The hooks and listeners of the lane towers: minions first, and a hero who hits one of theirs before that */
+function towerRules(options) {
+	const towers = options.towers ?? ((world, entity) => isTower(world, entity, options.cores));
+	const aggro = options.towerAggro ?? 3;
+	const struckHero = (world, entity) => {
+		const strike = entity.get(heroStrike);
+		return !!strike && world.time - strike.at <= aggro;
+	};
+	const targetScore = defineHook({
+		hook: "targetScore",
+		id: "lanes.towers",
+		run(world, event) {
+			if (!towers(world, event.attacker)) return;
+			if (event.target.def.hero && struckHero(world, event.target)) event.score += 2e5;
+			else if (event.target.has(laneMinion)) event.score += 1e5;
+		}
+	});
+	const minions = options.minionAggro === false ? void 0 : {
+		radius: 7,
+		chase: 2.5,
+		leash: 10,
+		...options.minionAggro
+	};
+	const heroHitHero = defineListener({
+		id: "lanes.heroHitHero",
+		event: damaged,
+		run(world, { target, source }) {
+			if (!source?.alive || !source.def.hero || !target.def.hero || !world.areEnemies(source.owner, target.owner)) return;
+			source.set(heroStrike, { at: world.time });
+			if (minions) {
+				const state = world.state(lanesState);
+				const turned = [];
+				for (const minion of world.spatial.query(target.pos.x, target.pos.z, minions.radius)) {
+					const lane = minion.get(laneMinion);
+					if (!lane || !minion.alive || lane.chase?.target === source.id || !world.areAllies(minion.owner, target.owner)) continue;
+					if (!world.isVisibleTo(source, world.player(minion.owner).team)) continue;
+					lane.chase = {
+						target: source.id,
+						until: world.time + minions.chase
+					};
+					turned.push(minion);
+					if (!(state.chasing ??= []).includes(minion.id)) state.chasing.push(minion.id);
+				}
+				for (const owner of new Set(turned.map((minion) => minion.owner))) {
+					const entities = turned.filter((minion) => minion.owner === owner).map((minion) => minion.id);
+					world.issue({
+						type: "order",
+						player: owner,
+						entities,
+						order: {
+							type: "attack",
+							target: source.id
+						}
+					});
+				}
+			}
+			for (const tower of world.spatial.query(source.pos.x, source.pos.z, 16)) {
+				if (!tower.alive || !tower.get(fighting) || !towers(world, tower) || !world.areAllies(tower.owner, target.owner)) continue;
+				const reach = world.settings.combat.acquisitionRange(world, tower) + tower.def.radius;
+				if (hypot(tower.pos.x - source.pos.x, tower.pos.z - source.pos.z) > reach) continue;
+				if (tower.get(fighting).autoTarget === source.id || !world.isVisibleTo(source, world.player(tower.owner).team)) continue;
+				disengage(world, tower);
+				engageWith(world, tower, source);
+				tower.get(fighting).autoTarget = source.id;
+			}
+		}
+	});
+	return {
+		hooks: [targetScore],
+		listeners: [heroHitHero],
+		systems: [{
+			name: "lanes.minions",
+			every: 6,
+			update(world) {
+				const state = world.state(lanesState);
+				if (!minions || !state.chasing?.length) return;
+				const lanes = lanesOf(world);
+				state.chasing = state.chasing.filter((id) => {
+					const minion = world.get(id);
+					const lane = minion?.get(laneMinion);
+					if (!minion?.alive || !lane?.chase) return false;
+					const path = lanes.find((each) => each.path === lane.lane);
+					const target = world.get(lane.chase.target);
+					if (!(world.time > lane.chase.until || !target?.alive || !world.isVisibleTo(target, world.player(minion.owner).team) || !!path && offLane(path, minion.pos) > minions.leash)) return true;
+					lane.chase = void 0;
+					if (path) alongLane(world, [minion], path, lane.from, options);
+					return false;
+				});
+			}
+		}]
+	};
+}
+//#endregion
+export { LANE_END_REACH, LANE_SPAWNERS, LANE_SPAWNER_FIELDS, LANE_SPAWNER_KIND, checkLanes, coreVictory, defaultWave, heroStrike, laneMinion, lanesOf, lanesPack, lanesState, mapLanes, sendWave, wavesSent };
+
+//# sourceMappingURL=lanes.js.map

package/dist/lanes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lanes.js","names":[],"sources":["../src/lanes.ts"],"sourcesContent":["import { damaged, gameOver } from '#engine/engineEvents'\nimport { defineComponent } from './components'\nimport type { GamePack } from './packs/pack'\nimport { distSq } from './math'\nimport type { Entity } from './entity'\nimport { engageWith } from './engagement'\nimport { defineListener } from './events'\nimport { defineHook } from './hooks'\nimport { disengage } from './systems/combat'\nimport { defeat } from './systems/victory'\nimport type { GameMap, MapPath } from './map'\nimport { type MapFieldDef, type MapProblem, mapThings, type MapThing } from './mapFields'\nimport type { Vec2 } from './math'\nimport type { PlayerId } from './entity'\nimport type { System } from './registry'\nimport { defineTimer } from './timers'\nimport type { World } from './world'\nimport { atan2, hypot } from './exactMath'\nimport { fighting } from './entity'\n\n/*\n * Lanes (features-plan D): the roads of a MOBA, along which each side's waves of minions walk to the other's base,\n * fighting what they meet. A lane is one of the map's paths (`MapPath`) with a spawner at each end, of two sides: where\n * each side's waves come out. A spawner is a thing of the map's (`MapThing`, kind `lanes.spawners`), of a player, on\n * one lane: the editor puts them down (`LANE_SPAWNER_KIND`), and checks every lane has its two (`checkLanes`)\n */\n\n/**\n * The kind of thing a spawner is: where it is kept in the map's data, by this id\n *\n * @beta\n */\nexport const LANE_SPAWNERS = 'lanes.spawners'\n\n/**\n * How near the end of its lane a spawner is to be that end's: in cells\n *\n * @internal\n */\nexport const LANE_END_REACH = 6\n\n/**\n * The fields of a spawner: whose waves come out of it, and the lane they walk\n *\n * @internal\n */\nexport const LANE_SPAWNER_FIELDS: Omit<MapFieldDef, 'for'>[] = [\n\t{ id: 'player', name: 'Player', kind: 'player', default: 1, hint: 'Whose waves come out of it' },\n\t{ id: 'lane', name: 'Lane', kind: 'path', hint: 'The path its waves walk, from the end it stands at to the other' }\n]\n\n/**\n * A spawner as the editor offers it (a `MapKindDef` of `@v12-engine/client`): its tool, its fields, a ring at each, in\n * the scene's `kinds`\n *\n * @beta\n */\nexport const LANE_SPAWNER_KIND = {\n\tid: LANE_SPAWNERS,\n\tname: 'Spawner',\n\tplural: 'Spawners',\n\thint: 'Where a side’s waves of minions come out, at one end of a lane: its player, and the path it is the end of',\n\ticon: 'tool.circle',\n\tcolor: [0.95, 0.75, 0.25] as [number, number, number],\n\tfields: LANE_SPAWNER_FIELDS,\n\treach: LANE_END_REACH / 2\n}\n\n/**\n * A lane, as the rules read it: the path, and its two ends, each with the spawner of the side whose waves start there\n *\n * @beta\n */\nexport interface Lane {\n\t/** The name of its path (`world.map.path(name)`), what orders that follow it are given */\n\tpath: string\n\t/** The points of the lane's path, in order from its first end to its last */\n\tpoints: readonly Vec2[]\n\t/** Its spawners, by the end of the lane they are at: the first point's, then the last's. Either is missing on a map not finished */\n\tends: [LaneEnd | undefined, LaneEnd | undefined]\n}\n\n/**\n * One end of a lane: the spawner there, and whose\n *\n * @beta\n */\nexport interface LaneEnd {\n\t/** The map's spawner object at this end of the lane */\n\tspawner: MapThing\n\t/** The player whose waves start at this end */\n\tplayer: PlayerId\n\t/** The point the spawner stands at */\n\tat: Vec2\n}\n\n/** The path a spawner is on, by the id its field keeps */\nconst pathOf = (paths: readonly MapPath[], spawner: MapThing): MapPath | undefined => {\n\tconst id = spawner.data?.lane\n\treturn typeof id === 'number' ? paths.find((path) => path.id === id) : typeof id === 'string' ? paths.find((path) => path.name === id) : undefined\n}\n\n/** Which end of a path a place is at: 0 the first point's, 1 the last's, or none when it is near neither */\nfunction endOf(path: MapPath, at: Vec2): 0 | 1 | undefined {\n\tconst first = path.points[0]\n\tconst last = path.points[path.points.length - 1]\n\tif (!first || !last) return undefined\n\tconst d0 = hypot(at.x - first.x, at.z - first.z)\n\tconst d1 = hypot(at.x - last.x, at.z - last.z)\n\tif (Math.min(d0, d1) > LANE_END_REACH) return undefined\n\treturn d0 <= d1 ? 0 : 1\n}\n\n/**\n * The lanes of a map: every path a spawner is on, with what stands at each end\n *\n * @beta\n */\nexport function mapLanes(map: { paths: readonly MapPath[]; data: Record<string, unknown> }): Lane[] {\n\tconst lanes = new Map<number, Lane>()\n\tfor (const spawner of mapThings(map, LANE_SPAWNERS)) {\n\t\tconst path = pathOf(map.paths, spawner)\n\t\tif (!path) continue\n\t\tlet lane = lanes.get(path.id)\n\t\tif (!lane) lanes.set(path.id, (lane = { path: path.name, points: path.points, ends: [undefined, undefined] }))\n\t\tconst end = endOf(path, spawner)\n\t\tif (end === undefined) continue\n\t\tlane.ends[end] = { spawner, player: Number(spawner.data?.player ?? 1), at: { x: spawner.x, z: spawner.z } }\n\t}\n\treturn [...lanes.values()]\n}\n\n/**\n * The lanes of a world's map (`mapLanes`): what waves walk\n *\n * @beta\n */\nexport const lanesOf = (world: World): Lane[] => mapLanes({ paths: world.map.paths, data: world.map.data })\n\n/**\n * What is wrong with the lanes of a map, for the editor's checks (`MapEditorDef.check`): a spawner on no lane or away\n * from its ends, a lane without a spawner at each end, or with the same side at both\n *\n * @beta\n */\nexport function checkLanes(map: GameMap): MapProblem[] {\n\tconst problems: MapProblem[] = []\n\tconst teamOf = (player: number) => map.players.find((each) => each.id === player)?.team ?? player\n\tfor (const spawner of mapThings(map, LANE_SPAWNERS)) {\n\t\tconst path = pathOf(map.paths, spawner)\n\t\tconst about = { thing: spawner.id, kind: LANE_SPAWNERS }\n\t\tif (!path)\n\t\t\tproblems.push({ message: 'A spawner is on no lane: pick the path its waves walk', error: true, rule: 'lanes.spawner', at: spawner, about })\n\t\telse if (endOf(path, spawner) === undefined)\n\t\t\tproblems.push({ message: `A spawner of \"${path.name}\" is at neither end of it`, error: true, rule: 'lanes.spawner', at: spawner, about })\n\t}\n\tfor (const lane of mapLanes(map)) {\n\t\tconst path = map.paths.find((each) => each.name === lane.path)!\n\t\tconst about = { path: path.id }\n\t\tconst [first, last] = lane.ends\n\t\tif (!first || !last) {\n\t\t\tconst missing = !first ? path.points[0] : path.points[path.points.length - 1]\n\t\t\tproblems.push({\n\t\t\t\tmessage: `The lane \"${lane.path}\" has no spawner at one end: its waves start at both`,\n\t\t\t\terror: true,\n\t\t\t\trule: 'lanes.ends',\n\t\t\t\tat: missing,\n\t\t\t\tabout\n\t\t\t})\n\t\t} else if (teamOf(first.player) === teamOf(last.player))\n\t\t\tproblems.push({ message: `The lane \"${lane.path}\" has the same side at both ends`, error: true, rule: 'lanes.sides', at: first.at, about })\n\t}\n\treturn problems\n}\n\n// ---- waves (features-plan D2)\n\n/**\n * A wave about to come out of a spawner: which of that spawner's it is (1 and up), the lane and the end it walks from,\n * and whose. What `LanesOptions.wave` makes the units of\n *\n * @beta\n */\nexport interface LaneWave {\n\t/** The wave's number at its spawner, counting from 1 */\n\tnumber: number\n\t/** The lane the wave walks */\n\tlane: Lane\n\t/** Which end of the lane it starts from: 0 the first point's, 1 the last's */\n\tfrom: 0 | 1\n\t/** The player whose wave it is */\n\tplayer: PlayerId\n}\n\n/**\n * What a game's lanes do (`lanesPack`). Every part has the engine's own when left out\n *\n * @beta\n */\nexport interface LanesOptions {\n\t/**\n\t * The unit types of the engine's waves, by role: three to five close, two or three that shoot, a siege now and then\n\t * (`melee` and `ranged` are needed, `siege` is left out of the waves when it is). The engine names none: a game that\n\t * gives no `wave` of its own says these\n\t */\n\tminions?: { melee: string; ranged: string; siege?: string }\n\t/** The unit types of a wave, in the order they come out: the engine's grow with time, from `minions` */\n\twave?: (world: World, wave: LaneWave) => string[]\n\t/** Seconds from the start to the first wave, and between waves: 20 and 30 when left out */\n\tfirstWave?: number\n\t/** Seconds between one wave and the next; 30 when left out */\n\tevery?: number\n\t/**\n\t * Where a minion goes once it is at the far end of its lane, fighting on the way: the nearest structure of another\n\t * team to that end when left out (their core), the end itself when there is none\n\t */\n\tgoal?: (world: World, minion: Entity, lane: Lane, from: 0 | 1) => Vec2 | undefined\n\t/**\n\t * What the lane towers are: they hit minions before anything else, and a hero who hits a hero of their side within\n\t * their reach before minions (as in a MOBA). Structures that attack, other than cores, when left out\n\t */\n\ttowers?: (world: World, entity: Entity) => boolean\n\t/**\n\t * What the cores are: the unit type's id, or a test of a unit. A side whose cores have all fallen has lost, and the\n\t * last side with one wins. Said by the game (the engine names none); `false` keeps the game's own way of winning\n\t * (`Rules.victory`)\n\t */\n\tcores: string | ((world: World, entity: Entity) => boolean) | false\n\t/** Seconds a hero who hit a hero is the towers' first target for: 3 when left out */\n\ttowerAggro?: number\n\t/**\n\t * Minions turn on a hero who hits a hero of their side near them (within `radius` cells of it), chase it for `chase`\n\t * seconds at most and no further than `leash` cells from their lane, then go back to it the way they were going:\n\t * 7, 2.5 and 10 when left out. `false` for minions that keep to their lane\n\t */\n\tminionAggro?: { radius?: number; chase?: number; leash?: number } | false\n}\n\n/**\n * A minion of a lane: the lane it walks (its path's name), from which end. On every unit a wave brings\n *\n * @beta\n */\nexport const laneMinion = defineComponent<{ lane: string; from: 0 | 1; chase?: { target: number; until: number } }>({ id: 'lanes.minion' })\n\n/** How many waves each spawner has sent, by its id, and whether the waves were set going */\nexport const lanesState = defineComponent<{ started: boolean; waves: Record<string, number>; chasing?: number[] }>({ id: 'lanes.state', default: () => ({ started: false, waves: {} }) })\n\n/**\n * The engine's waves: three close and two that shoot, one more close every fourth wave and one more that shoots every\n * sixth, a siege every third wave (two from the twelfth). Of the types a game has\n *\n * @beta\n */\nexport function defaultWave(world: World, wave: LaneWave, minions: NonNullable<LanesOptions['minions']>): string[] {\n\tconst { melee, ranged, siege } = minions\n\tconst n = wave.number\n\tconst types = [\n\t\t...Array<string>(3 + Math.floor((n - 1) / 4)).fill(melee),\n\t\t...Array<string>(2 + Math.floor((n - 1) / 6)).fill(ranged),\n\t\t...Array<string>(siege && n % 3 === 0 ? 1 + Math.floor(n / 12) : 0).fill(siege ?? '')\n\t]\n\treturn types.filter((type) => world.registry.units.has(type))\n}\n\n/** The nearest structure of another team to a lane's far end, within reach of it: what a wave goes for once there */\nfunction defaultGoal(world: World, minion: Entity, lane: Lane, from: 0 | 1): Vec2 | undefined {\n\tconst end = lane.points[from === 0 ? lane.points.length - 1 : 0]\n\tlet best: Entity | undefined\n\tlet bestDistance = 24 * 24\n\tfor (const entity of world.entities.values()) {\n\t\tif (!entity.alive || !entity.isStructure || !world.areEnemies(entity.owner, minion.owner)) continue\n\t\tconst d = distSq(entity.pos, end)\n\t\tif (d < bestDistance) {\n\t\t\tbestDistance = d\n\t\t\tbest = entity\n\t\t}\n\t}\n\treturn best ? { x: best.pos.x, z: best.pos.z } : end\n}\n\n/**\n * Sends a spawner's next wave now, whatever its timer, as the game's lanes say (`LanesOptions`): for scripts, tests and debug tools. Its units come out by the\n * spawner, walk the lane fighting what they meet (`attackPath`), then go for the goal at its far end. Gives back the\n * units, none for a spawner on no lane\n *\n * @beta\n */\nexport function sendWave(world: World, spawner: number, options: Partial<LanesOptions>): Entity[] {\n\tfor (const lane of lanesOf(world)) {\n\t\tconst from = lane.ends[0]?.spawner.id === spawner ? 0 : lane.ends[1]?.spawner.id === spawner ? 1 : undefined\n\t\tif (from === undefined) continue\n\t\tconst end = lane.ends[from]!\n\t\tconst state = world.state(lanesState)\n\t\tconst number = (state.waves[spawner] ?? 0) + 1\n\t\tstate.waves[spawner] = number\n\t\tconst wave: LaneWave = { number, lane, from, player: end.player }\n\t\tif (!options.wave && !options.minions) throw new Error('sendWave needs the wave (`wave`) or the unit types of its minions (`minions`)')\n\t\tconst types = options.wave ? options.wave(world, wave) : defaultWave(world, wave, options.minions!)\n\t\t// in a block behind the spawner, along the lane: the first out in front\n\t\tconst next = lane.points[from === 0 ? 1 : lane.points.length - 2] ?? end.at\n\t\tconst length = hypot(next.x - end.at.x, next.z - end.at.z) || 1\n\t\tconst ahead = { x: (next.x - end.at.x) / length, z: (next.z - end.at.z) / length }\n\t\tconst units = types.map((type, i) => {\n\t\t\tconst row = Math.floor(i / 3)\n\t\t\tconst side = (i % 3) - 1\n\t\t\tconst at = { x: end.at.x - ahead.x * row * 1.2 - ahead.z * side * 1.2, z: end.at.z - ahead.z * row * 1.2 + ahead.x * side * 1.2 }\n\t\t\tconst unit = world.spawn(type, end.player, at, { facing: atan2(ahead.x, ahead.z) })\n\t\t\tunit.set(laneMinion, { lane: lane.path, from })\n\t\t\treturn unit\n\t\t})\n\t\tif (!units.length) return units\n\t\talongLane(world, units, lane, from, options)\n\t\treturn units\n\t}\n\treturn []\n}\n\n/** Minions sent along their lane from where they are, the way they go (away from their end), then to the goal */\nfunction alongLane(world: World, units: Entity[], lane: Lane, from: 0 | 1, options: Partial<LanesOptions>): void {\n\tconst entities = units.map((unit) => unit.id)\n\tconst player = units[0].owner\n\tworld.issue({ type: 'order', player, entities, order: { type: 'attackPath', path: lane.path, towards: from === 0 ? 'last' : 'first' } })\n\tconst goal = (options.goal ?? defaultGoal)(world, units[0], lane, from)\n\tif (goal) world.issue({ type: 'order', player, entities, order: { type: 'attackMove', point: goal }, queue: true })\n}\n\n/** How far a place is from a lane's line */\nfunction offLane(lane: Lane, at: Vec2): number {\n\tlet best = Infinity\n\tconst { points } = lane\n\tfor (let i = 1; i < points.length; i++) {\n\t\tconst a = points[i - 1]\n\t\tconst dx = points[i].x - a.x\n\t\tconst dz = points[i].z - a.z\n\t\tconst length = dx * dx + dz * dz\n\t\tconst t = length > 0 ? Math.min(Math.max(((at.x - a.x) * dx + (at.z - a.z) * dz) / length, 0), 1) : 0\n\t\tbest = Math.min(best, hypot(at.x - (a.x + dx * t), at.z - (a.z + dz * t)))\n\t}\n\treturn best\n}\n\n/**\n * How many waves a spawner has sent\n *\n * @beta\n */\nexport const wavesSent = (world: World, spawner: number): number => world.state(lanesState).waves[spawner] ?? 0\n\n/**\n * A game with lanes: its maps' lanes checked in the editor, and waves of minions sent along them from every spawner,\n * the first `firstWave` seconds in and one every `every` seconds after, each from the `wave` of its number (see\n * `LanesOptions`). What it adds goes with what the game has: its timers and components saved, its check after its own\n *\n * @beta\n */\nexport function lanesPack(options: LanesOptions): GamePack {\n\t// the engine names no unit type: the game says what its minions and its cores are\n\tif (!options.wave && !(options.minions?.melee && options.minions.ranged))\n\t\tthrow new Error('lanesPack needs the unit types of its waves (`minions: { melee, ranged }`) or a `wave` of its own')\n\tif (options.cores === undefined) throw new Error(\"lanesPack needs to be told what the cores are (`cores`: a unit type's id, a test, or false)\")\n\tconst firstWave = options.firstWave ?? 20\n\tconst every = options.every ?? 30\n\tconst waveDue = defineTimer<{ spawner: number }>({ id: 'lanes.wave', run: (world, data) => {\n\t\tif (world.winner === null) sendWave(world, data.spawner, options)\n\t} })\n\t// the waves are set going once, as the game starts: a timer for every spawner, saved with the game from then on\n\tconst start: System = {\n\t\tname: 'lanes.start',\n\t\tevery: 15,\n\t\tupdate(world) {\n\t\t\tconst state = world.state(lanesState)\n\t\t\tif (state.started) return\n\t\t\tstate.started = true\n\t\t\tfor (const lane of lanesOf(world)) {\n\t\t\t\tfor (const end of lane.ends) if (end) world.timers.every(every, waveDue, { first: firstWave, data: { spawner: end.spawner.id } })\n\t\t\t}\n\t\t}\n\t}\n\tconst { hooks, listeners, systems } = towerRules(options)\n\treturn {\n\t\tid: 'lanes',\n\t\toptions,\n\t\tcomponents: [laneMinion, lanesState, heroStrike],\n\t\ttimers: [waveDue],\n\t\tsystems: [start, ...systems],\n\t\thooks,\n\t\tlisteners,\n\t\t...(options.cores !== false && { victory: coreVictory(coresOf(options.cores)) }),\n\t\t// minions are the lanes', not a player's army: they take no supply; the rest what the game says\n\t\tsettings: (rules) => ({ supply: { of: (world, unit) => ('has' in unit && unit.has(laneMinion) ? 0 : rules.supply.of(world, unit)) } }),\n\t\tcheck: (map) => checkLanes(map)\n\t}\n}\n\n// ---- towers and cores (features-plan D3)\n\n/**\n * When a hero last hit a hero of another side, in seconds of the game's time: what the lane towers of the side it hit\n * go for first, for a while (`LanesOptions.towerAggro`)\n *\n * @beta\n */\nexport const heroStrike = defineComponent<{ at: number }>({ id: 'lanes.heroStrike' })\n\n/** The engine's lane towers: structures that attack, other than cores */\nconst isTower = (world: World, entity: Entity, cores: LanesOptions['cores']) =>\n\tentity.isStructure && !!entity.def.attacks?.length && !(cores && coresOf(cores)(world, entity))\n\n/** What the cores are, as a test of a unit: the unit type's id said, or the game's own test */\nconst coresOf = (cores: string | ((world: World, entity: Entity) => boolean)): ((world: World, entity: Entity) => boolean) =>\n\ttypeof cores === 'string' ? (_world, entity) => entity.def.id === cores : cores\n\n/**\n * The rule of a lanes game: a side whose cores have all fallen is out, and the last side with a core wins. A side\n * takes part once it has had a core\n *\n * @beta\n */\nexport function coreVictory(cores: (world: World, entity: Entity) => boolean): System {\n\treturn {\n\t\tname: 'victory',\n\t\tphase: 'cleanup',\n\t\tevery: 15,\n\t\tupdate(world) {\n\t\t\tif (world.winner !== null) return\n\t\t\tconst standing = new Set<number>()\n\t\t\tfor (const entity of world.entities.values()) if (entity.alive && cores(world, entity)) standing.add(world.player(entity.owner).team)\n\t\t\tconst sides = new Set<number>()\n\t\t\tfor (const player of world.players.values()) {\n\t\t\t\tif (player.neutral || player.creeps) continue\n\t\t\t\tif (standing.has(player.team)) player.established = true\n\t\t\t\tif (!player.established) continue\n\t\t\t\tsides.add(player.team)\n\t\t\t\tif (!standing.has(player.team) && !player.defeated) defeat(world, player.id)\n\t\t\t}\n\t\t\tif (sides.size < 2 || standing.size !== 1) return\n\t\t\tconst [winner] = standing\n\t\t\tworld.winner = winner\n\t\t\tworld.events.emit(gameOver, { winner })\n\t\t}\n\t}\n}\n\n/** The hooks and listeners of the lane towers: minions first, and a hero who hits one of theirs before that */\nfunction towerRules(options: LanesOptions) {\n\tconst towers = options.towers ?? ((world: World, entity: Entity) => isTower(world, entity, options.cores))\n\tconst aggro = options.towerAggro ?? 3\n\tconst struckHero = (world: World, entity: Entity) => {\n\t\tconst strike = entity.get(heroStrike)\n\t\treturn !!strike && world.time - strike.at <= aggro\n\t}\n\tconst targetScore = defineHook({\n\t\thook: 'targetScore',\n\t\tid: 'lanes.towers',\n\t\trun(world, event) {\n\t\t\tif (!towers(world, event.attacker)) return\n\t\t\tif (event.target.def.hero && struckHero(world, event.target)) event.score += 200_000\n\t\t\telse if (event.target.has(laneMinion)) event.score += 100_000\n\t\t}\n\t})\n\tconst minions = options.minionAggro === false ? undefined : { radius: 7, chase: 2.5, leash: 10, ...options.minionAggro }\n\t// a hero hit one: the towers of that side within reach of the one who hit turn on it at once, and its minions near\n\tconst heroHitHero = defineListener({\n\t\tid: 'lanes.heroHitHero',\n\t\tevent: damaged,\n\t\trun(world, { target, source }) {\n\t\t\tif (!source?.alive || !source.def.hero || !target.def.hero || !world.areEnemies(source.owner, target.owner)) return\n\t\t\tsource.set(heroStrike, { at: world.time })\n\t\t\tif (minions) {\n\t\t\t\tconst state = world.state(lanesState)\n\t\t\t\tconst turned: Entity[] = []\n\t\t\t\tfor (const minion of world.spatial.query(target.pos.x, target.pos.z, minions.radius)) {\n\t\t\t\t\tconst lane = minion.get(laneMinion)\n\t\t\t\t\tif (!lane || !minion.alive || lane.chase?.target === source.id || !world.areAllies(minion.owner, target.owner)) continue\n\t\t\t\t\tif (!world.isVisibleTo(source, world.player(minion.owner).team)) continue\n\t\t\t\t\tlane.chase = { target: source.id, until: world.time + minions.chase }\n\t\t\t\t\tturned.push(minion)\n\t\t\t\t\tif (!(state.chasing ??= []).includes(minion.id)) state.chasing.push(minion.id)\n\t\t\t\t}\n\t\t\t\tfor (const owner of new Set(turned.map((minion) => minion.owner))) {\n\t\t\t\t\tconst entities = turned.filter((minion) => minion.owner === owner).map((minion) => minion.id)\n\t\t\t\t\tworld.issue({ type: 'order', player: owner, entities, order: { type: 'attack', target: source.id } })\n\t\t\t\t}\n\t\t\t}\n\t\t\tfor (const tower of world.spatial.query(source.pos.x, source.pos.z, 16)) {\n\t\t\t\tif (!tower.alive || !tower.get(fighting) || !towers(world, tower) || !world.areAllies(tower.owner, target.owner)) continue\n\t\t\t\tconst reach = world.settings.combat.acquisitionRange(world, tower) + tower.def.radius\n\t\t\t\tif (hypot(tower.pos.x - source.pos.x, tower.pos.z - source.pos.z) > reach) continue\n\t\t\t\tif (tower.get(fighting)!.autoTarget === source.id || !world.isVisibleTo(source, world.player(tower.owner).team)) continue\n\t\t\t\tdisengage(world, tower)\n\t\t\t\tengageWith(world, tower, source)\n\t\t\t\ttower.get(fighting)!.autoTarget = source.id\n\t\t\t}\n\t\t}\n\t})\n\t// minions done chasing go back to their lane: the time is up, what they chased is gone, or they went too far from it\n\tconst back: System = {\n\t\tname: 'lanes.minions',\n\t\tevery: 6,\n\t\tupdate(world) {\n\t\t\tconst state = world.state(lanesState)\n\t\t\tif (!minions || !state.chasing?.length) return\n\t\t\tconst lanes = lanesOf(world)\n\t\t\tstate.chasing = state.chasing.filter((id) => {\n\t\t\t\tconst minion = world.get(id)\n\t\t\t\tconst lane = minion?.get(laneMinion)\n\t\t\t\tif (!minion?.alive || !lane?.chase) return false\n\t\t\t\tconst path = lanes.find((each) => each.path === lane.lane)\n\t\t\t\tconst target = world.get(lane.chase.target)\n\t\t\t\tconst done =\n\t\t\t\t\tworld.time > lane.chase.until ||\n\t\t\t\t\t!target?.alive ||\n\t\t\t\t\t!world.isVisibleTo(target, world.player(minion.owner).team) ||\n\t\t\t\t\t(!!path && offLane(path, minion.pos) > minions.leash)\n\t\t\t\tif (!done) return true\n\t\t\t\tlane.chase = undefined\n\t\t\t\tif (path) alongLane(world, [minion], path, lane.from, options)\n\t\t\t\treturn false\n\t\t\t})\n\t\t}\n\t}\n\treturn { hooks: [targetScore], listeners: [heroHitHero], systems: [back] }\n}\n"],"mappings":"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"}

package/dist/life.d.ts

@@ -13,12 +13,16 @@ export declare class Life {
     /**
      * Deals damage. In order:
      * 1. the `beforeDamage` hook, which can change the amount or call it off;
-     * 2. armor or magic resist, then shields, take their part;
+     * 2. armor or magic resist take their part, then the damage is made more or less (`incomingDamage`, `outgoingDamage`:
+     *    `RuleSettings.combat.damageScale`), and shields take theirs;
      * 3. the rest comes off the target's health, and it dies when nothing is left (see `kill`);
      * 4. the `afterDamage` hook, for what follows from a hit: life steal, effects on hit.
      */
     damage(target: Entity, amount: number, source?: Entity, options?: DamageOptions): void;
-    /** Gives health back, after the `beforeHeal` hook had its say. Returns how much of it was needed */
+    /**
+     * Gives health back, made more or less by what the target gets of it (`incomingHealing`:
+     * `RuleSettings.combat.healingScale`), then after the `beforeHeal` hook had its say. Returns how much of it was needed
+     */
     heal(target: Entity, amount: number, source?: Entity): number;
     /**
      * Kills an entity by the rules, not by damage: felled, cancelled, run out of time. `attack` says that an attack of