@v12-engine/engine 0.1.0 → 0.4.0

package/dist/camps.d.ts

@@ -1,28 +1,59 @@
-import { type EntityId, type PlayerId } from './entity';
+import { type Entity, type EntityId, type PlayerId } from './entity';
 import { type Vec2 } from './math';
 import type { World } from './world';
 import type { SessionView } from './replication';
 import type { CampInfo } from './session/protocol';
+/**
+ * Someone a camp is fighting, on its list (`Camp.aggro`)
+ *
+ * @beta
+ */
+export interface CampAggro {
+    /** Who it is */
+    id: EntityId;
+    /** The damage it has done the camp's creeps: the most is gone for first, then the nearest (`campTarget`) */
+    threat: number;
+    /** When it last hit one of the camp's creeps or was hit by one, in seconds of the game */
+    lastHitAt: number;
+}
 /**
  * A group of creeps guarding a spot
  *
  * @beta
  */
 export interface Camp {
+    /** The camp's number: its place in the world's camps, plus one */
     id: number;
+    /** Where the middle of the camp is, east-west in cells */
     x: number;
+    /** Where the middle of the camp is, north-south in cells */
     z: number;
     /** Levels of its creeps added up, as it was set up */
     level: number;
-    /** How far from the camp its creeps chase */
+    /** How far from the camp's centre its creeps fight: what goes past it is let go of (`CampSettings.leash`) */
     leash: number;
+    /** The entity ids of its creeps */
     members: EntityId[];
-    /** Who the camp is fighting. One creep being attacked brings all of them */
+    /**
+     * Who the camp is fighting, as its creeps pick (`campTarget`): fed by every hit on one of them (the damage done, as
+     * threat) and by their own hits, rid of the dead and of what is past the leash, emptied as the camp goes home
+     */
+    aggro: CampAggro[];
+    /** The last it went for: what wakes one of them wakes the rest */
     alarm: EntityId;
+    /** When one of its creeps last hit or was hit, in seconds of the game: it goes home `resetAfter` after. None at peace */
+    foughtAt?: number;
+    /** Seconds a creep of it chases what it neither hits nor is hit by before it lets it go: the rules' `chaseTime` when left out */
+    chaseTime?: number;
+    /** Seconds without a blow before it goes home: the rules' `resetAfter` when left out */
+    resetAfter?: number;
+    /** Whether all of it answers a hit at once: the rules' `helpAtOnce` when left out */
+    helpAtOnce?: boolean;
     /** The name it was given on the map, for the rules to find it by (`campNamed`) */
     name?: string;
     /** Who its creeps are, and of what types, for it to come back the same (see `respawn`). None in saves of before */
     owner?: PlayerId;
+    /** The unit type ids of its creeps, kept for it to come back the same after `respawn` */
     types?: string[];
     /**
      * Seconds after it was cleared that it comes back, its creeps where they stood, as a hero arena game's jungle camps
@@ -38,13 +69,26 @@ export interface Camp {
  * @beta
  */
 export interface CampMember {
+    /** The number of the camp the creep guards */
     camp: number;
+    /** Where the creep returns to when the camp gives up the fight */
     home: Vec2;
-    /** On its way back after chasing too far. Nothing distracts it until it is home */
+    /** On its way back after the camp gave up the fight. Deaf to everything but a hit, and to that for `RETURN_GRACE` */
     returning: boolean;
+    /** When it turned for home, in seconds of the game */
+    returningAt?: number;
     /** Where it was attacked from by something it could not see, and is going to look */
     searching: Vec2 | null;
+    /** When it last traded a blow with what it goes for, or took it up: a chase with none for `chaseTime` is given up */
+    blowAt?: number;
 }
+/**
+ * Seconds a creep on its way home is deaf even to a hit: so that one led to the end of its leash does not turn on the
+ * first arrow in its back and come straight back out
+ *
+ * @beta
+ */
+export declare const RETURN_GRACE = 1.5;
 /**
  * On a creep: the camp it belongs to
  *
@@ -85,6 +129,28 @@ export declare function spawnCamp(world: World, owner: PlayerId, point: Vec2, ty
  * @beta
  */
 export declare function respawnCamp(world: World, camp: Camp): void;
+/**
+ * What a creep of the camp goes for of the camp's list (`Camp.aggro`): the most threat, then the nearest, the
+ * `targetScore` hook having the last word; nothing it leaves alone for now (`shun`: it could not get at it, or chased it
+ * too long), cannot see or attack, or that stands past the leash. None when the list has nothing for it
+ *
+ * @beta
+ */
+export declare function campTarget(world: World, entity: Entity, camp: Camp): Entity | undefined;
+/**
+ * Puts someone on a camp's list as if it had done the camp `threat` damage (`Camp.aggro`): a taunt, or a game's own
+ * reason for the creeps to come. The camp comes at once, as for a hit, where it helps at once (`CampSettings.helpAtOnce`)
+ *
+ * @beta
+ */
+export declare function aggroCamp(world: World, camp: Camp, entity: Entity, threat?: number): void;
+/**
+ * The camp gives up the fight now, as it does `resetAfter` after the last blow: its list emptied, every creep of it on
+ * the way home
+ *
+ * @beta
+ */
+export declare function resetCamp(world: World, camp: Camp): void;
 /**
  * The camps as a seat's player knows them (`GameSession.camps`): where they are and how strong, and which their team
  * has seen empty. Worked out once a tick, as the minimap asks every frame: the same list and objects every time, kept

package/dist/camps.js

@@ -0,0 +1,501 @@
+import { cos, sin } from "./exactMath.js";
+import { dist } from "./math.js";
+import { at, declaredAt, lowerChain } from "./defs.js";
+import { defineComponent } from "./components.js";
+import { defineListener } from "./events.js";
+import { campCleared, campReturned, damaged } from "./engineEvents.js";
+import { edgeDistance, fighting, moving } from "./entity.js";
+import { defineHook } from "./hooks.js";
+import { engageWith, engagedLike, isBlocked, isShunned, roomFor, shun } from "./engagement.js";
+import { halt, moveTo } from "./systems/movement.js";
+import { acquireTarget, canAttack, canSee, disengage, engage } from "./systems/combat.js";
+import { createOrder, giveOrder } from "./orders/queue.js";
+import { freeToHelp } from "./orders/idle.js";
+//#region src/camps.ts
+/**
+* Creep camps: groups of neutral hostile creeps that guard a spot. They go for whoever comes close or attacks one of
+* them, all of them at once, keep a list of who hurt them (`Camp.aggro`) and fight it out to the end of their leash,
+* give up a chase that brings no blow (`CampSettings.chaseTime`), go home a while after the last blow (`resetAfter`), heal
+* on the way back, and sleep at night. A feature a game turns on by taking `campHooks` and `campListeners` (the heroes
+* pack has them); the engine itself knows only the player the creeps belong to. Without it, creeps are units like any
+* other, that stand where they are put and fight back. See docs/creeps.md
+*/
+/**
+* Seconds a creep on its way home is deaf even to a hit: so that one led to the end of its leash does not turn on the
+* first arrow in its back and come straight back out
+*
+* @beta
+*/
+var RETURN_GRACE = 1.5;
+/** How far past the leash a creep may itself stand, fighting what is just inside it */
+var LEASH_SLACK = 2;
+/**
+* On a creep: the camp it belongs to
+*
+* @beta
+*/
+var campMember = defineComponent({ id: "core.camp" });
+/**
+* The camps of a world, by id less one
+*
+* @beta
+*/
+var camps = defineComponent({
+	id: "core.camps",
+	default: () => []
+});
+/**
+* Gives the camps of a world, the list `camps` holds
+*
+* @internal
+*/
+var campsOf = (world) => world.state(camps);
+/**
+* The camp of this name, as it was given one on the map. It is there for as long as the game, with or without its creeps
+*
+* @beta
+*/
+var campNamed = (world, name) => campsOf(world).find((camp) => camp.name === name);
+/**
+* Where the creeps of a camp stand: the first one in the middle, the rest in a ring around it, facing out
+*
+* @beta
+*/
+function campLayout(point, count) {
+	return Array.from({ length: count }, (_, i) => {
+		const angle = i / Math.max(count - 1, 1) * Math.PI * 2;
+		const spread = i === 0 ? 0 : 1.6;
+		return {
+			x: point.x + sin(angle) * spread,
+			z: point.z + cos(angle) * spread,
+			facing: angle
+		};
+	});
+}
+/**
+* Puts a camp of creeps on the map. The creeps stand around the point and come back to it
+*
+* @beta
+*/
+function spawnCamp(world, owner, point, types, leash = world.settings.camps.leash) {
+	const all = campsOf(world);
+	const level = types.reduce((sum, type) => sum + (world.registry.unit(type).level ?? 1), 0);
+	const camp = {
+		id: all.length + 1,
+		x: point.x,
+		z: point.z,
+		level,
+		leash,
+		members: [],
+		aggro: [],
+		alarm: 0,
+		owner,
+		types: [...types]
+	};
+	const { respawn } = world.settings.camps;
+	if (respawn !== void 0) camp.respawn = respawn;
+	all.push(camp);
+	populate(world, camp, owner, types);
+	return camp;
+}
+/** Puts a camp's creeps where they stand, as its members */
+function populate(world, camp, owner, types) {
+	const layout = campLayout(camp, types.length);
+	camp.members = [];
+	types.forEach((type, i) => {
+		const { x, z, facing } = layout[i];
+		const creep = world.spawn(type, owner, {
+			x,
+			z
+		}, { facing });
+		creep.set(campMember, {
+			camp: camp.id,
+			home: {
+				x: creep.pos.x,
+				z: creep.pos.z
+			},
+			returning: false,
+			searching: null
+		});
+		camp.members.push(creep.id);
+	});
+}
+/**
+* Brings a cleared camp back now, the same creeps where they stood (`campReturned`): from code, or when its time comes
+*
+* @beta
+*/
+function respawnCamp(world, camp) {
+	if (!camp.types?.length || camp.owner === void 0) return;
+	populate(world, camp, camp.owner, camp.types);
+	camp.alarm = 0;
+	camp.aggro = [];
+	camp.foughtAt = void 0;
+	camp.clearedAt = void 0;
+	world.events.emit(campReturned, { camp });
+}
+/** Whether every creep of a camp is gone */
+var emptied = (world, camp) => camp.members.every((id) => !world.get(id)?.alive);
+/**
+* Camps that come back (`Camp.respawn`): told when one is found empty (`campCleared`), and brought back once its time is
+* up, when nobody but its own kind stands in it. Once a second, at the rate of 30 ticks
+*
+* @internal
+*/
+var campRespawnSystem = {
+	name: "campRespawn",
+	phase: "cleanup",
+	every: 30,
+	update(world) {
+		for (const camp of campsOf(world)) {
+			if (!emptied(world, camp)) continue;
+			if (camp.clearedAt === void 0) {
+				camp.clearedAt = world.time;
+				world.events.emit(campCleared, { camp });
+			}
+			if (camp.respawn === void 0 || world.time - camp.clearedAt < camp.respawn) continue;
+			if (world.spatial.query(camp.x, camp.z, 3, found).some((entity) => entity.alive && entity.isUnit && entity.owner !== camp.owner)) continue;
+			respawnCamp(world, camp);
+		}
+	}
+};
+/** Part of their health creeps regain per second on the way home */
+var RETREAT_HEALING = .1;
+var found = [];
+/** Uses an ability that hits what is around the creep, when that is worth it */
+function lashOut(world, entity) {
+	for (const state of entity.abilities) {
+		if (state.level < 1 || state.cooldown > 0) continue;
+		const ability = world.registry.ability(state.id);
+		if (ability.target !== "none" || at(ability.manaCost, state.level) > entity.mana) continue;
+		const radius = lowerChain(ability.effects).reduce((max, effect) => Math.max(max, effect.type === "damage" ? declaredAt(effect.radius, state.level) : 0), 0);
+		if (!radius) continue;
+		let caught = 0;
+		for (const other of world.spatial.query(entity.pos.x, entity.pos.z, radius, found)) if (other.isUnit && canAttack(world, entity, other) && edgeDistance(entity, other) <= radius) caught++;
+		if (caught < 2) continue;
+		giveOrder(world, entity, createOrder(world, {
+			type: "cast",
+			ability: ability.id
+		}));
+		return true;
+	}
+	return false;
+}
+/** The camp's own `chaseTime`, or the rules' */
+var chaseTimeOf = (world, camp) => camp.chaseTime ?? world.settings.camps.chaseTime;
+/** The camp's own `resetAfter`, or the rules' */
+var resetAfterOf = (world, camp) => camp.resetAfter ?? world.settings.camps.resetAfter;
+/** The camp's own `helpAtOnce`, or the rules' */
+var helpsAtOnce = (world, camp) => camp.helpAtOnce ?? world.settings.camps.helpAtOnce;
+/** Whether the creep may go for it: an enemy it sees, inside the camp's leash, and not one it leaves alone for now (`shun`) */
+function mayChase(world, entity, camp, other) {
+	return !!other && other.alive && canAttack(world, entity, other) && canSee(world, entity, other) && dist(other.pos, camp) <= camp.leash && !isShunned(world, entity, other);
+}
+/** The camp's list rid of the dead, the gone and what stands past the leash */
+function prune(world, camp) {
+	let kept = 0;
+	for (const entry of camp.aggro) {
+		const other = world.get(entry.id);
+		if (other?.alive && dist(other.pos, camp) <= camp.leash) camp.aggro[kept++] = entry;
+	}
+	camp.aggro.length = kept;
+}
+/** What the `targetScore` hook is asked with for each on a camp's list: one, used again */
+var scoring = {
+	attacker: void 0,
+	target: void 0,
+	distance: 0,
+	engaged: 0,
+	room: 0,
+	score: 0
+};
+/**
+* What a creep of the camp goes for of the camp's list (`Camp.aggro`): the most threat, then the nearest, the
+* `targetScore` hook having the last word; nothing it leaves alone for now (`shun`: it could not get at it, or chased it
+* too long), cannot see or attack, or that stands past the leash. None when the list has nothing for it
+*
+* @beta
+*/
+function campTarget(world, entity, camp) {
+	prune(world, camp);
+	const hooked = world.hooks.has("targetScore");
+	let best;
+	let bestScore = -Infinity;
+	for (const entry of camp.aggro) {
+		const other = world.get(entry.id);
+		if (!mayChase(world, entity, camp, other)) continue;
+		const distance = edgeDistance(entity, other);
+		let score = entry.threat * 1e3 - distance;
+		if (hooked) {
+			scoring.attacker = entity;
+			scoring.target = other;
+			scoring.distance = distance;
+			scoring.engaged = engagedLike(world, other, entity);
+			scoring.room = roomFor(world, other, entity);
+			scoring.score = score;
+			score = world.hooks.run("targetScore", scoring).score;
+		}
+		if (score > bestScore) {
+			bestScore = score;
+			best = other;
+		}
+	}
+	return best;
+}
+/** Its entry on the camp's list, put on it with no threat if it was not */
+function entryOf(world, camp, other) {
+	let entry = camp.aggro.find((each) => each.id === other.id);
+	if (!entry) camp.aggro.push(entry = {
+		id: other.id,
+		threat: 0,
+		lastHitAt: world.time
+	});
+	return entry;
+}
+/** The creep goes for it now: put on the camp's list, the camp's alarm, the chase timed from now */
+function take(world, entity, member, camp, target) {
+	engageWith(world, entity, target);
+	entity.get(fighting).autoTarget = target.id;
+	member.searching = null;
+	member.blowAt = world.time;
+	camp.alarm = target.id;
+	entryOf(world, camp, target);
+}
+/** Whether a creep of the camp on its way home takes a fight again: once it has been on the way `RETURN_GRACE` seconds */
+var pastGrace = (world, member) => world.time - (member.returningAt ?? -Infinity) >= RETURN_GRACE;
+/**
+* Every creep of the camp free to fight goes for the best of the camp's list now, not at its next look round: those
+* asleep woken, those fighting left to it, those on their way home only past `RETURN_GRACE`, those with an order of their
+* player's (a hold) or standing down (`CombatState.passive`) not at all
+*/
+function rally(world, camp) {
+	for (const id of camp.members) {
+		const creep = world.get(id);
+		const member = creep?.get(campMember);
+		if (!creep?.alive || !member || !freeToHelp(creep)) continue;
+		if (member.returning && !pastGrace(world, member)) continue;
+		const combat = creep.get(fighting);
+		if (combat.autoTarget && world.get(combat.autoTarget)?.alive) continue;
+		const next = campTarget(world, creep, camp);
+		if (!next) continue;
+		creep.asleep = false;
+		member.returning = false;
+		take(world, creep, member, camp, next);
+	}
+}
+/**
+* Puts someone on a camp's list as if it had done the camp `threat` damage (`Camp.aggro`): a taunt, or a game's own
+* reason for the creeps to come. The camp comes at once, as for a hit, where it helps at once (`CampSettings.helpAtOnce`)
+*
+* @beta
+*/
+function aggroCamp(world, camp, entity, threat = 0) {
+	const entry = entryOf(world, camp, entity);
+	entry.threat += threat;
+	entry.lastHitAt = world.time;
+	camp.foughtAt = world.time;
+	if (!world.get(camp.alarm)) camp.alarm = entity.id;
+	if (helpsAtOnce(world, camp)) rally(world, camp);
+}
+/**
+* The camp gives up the fight now, as it does `resetAfter` after the last blow: its list emptied, every creep of it on
+* the way home
+*
+* @beta
+*/
+function resetCamp(world, camp) {
+	camp.aggro.length = 0;
+	camp.foughtAt = void 0;
+	camp.alarm = 0;
+	for (const id of camp.members) {
+		const creep = world.get(id);
+		const member = creep?.get(campMember);
+		if (creep?.alive && member && !member.returning) goHome(world, creep, member);
+	}
+}
+/** A creep of the camp lets go of what it fought and walks home, healing as it goes */
+function goHome(world, entity, member) {
+	const combat = entity.get(fighting);
+	if (combat) combat.autoTarget = 0;
+	disengage(world, entity);
+	member.searching = null;
+	if (entity.get(moving) && dist(entity.pos, member.home) > 1.5) {
+		member.returning = true;
+		member.returningAt = world.time;
+		moveTo(world, entity, member.home);
+	}
+}
+/**
+* A hit on a creep of a camp, or by one: the camp's list fed (the damage done, as threat), its fight kept up, a chase of
+* the one hit or hitting timed anew, and the camp brought at once (`helpAtOnce`). A creep on its way home turns when hit
+* past `RETURN_GRACE`
+*/
+function hit(world, target, source, amount) {
+	if (!source || !world.areEnemies(source.owner, target.owner)) return;
+	const struck = target.get(campMember);
+	const camp = struck && campsOf(world)[struck.camp - 1];
+	if (struck && camp) {
+		const entry = entryOf(world, camp, source);
+		entry.threat += amount;
+		entry.lastHitAt = world.time;
+		camp.foughtAt = world.time;
+		if (!world.get(camp.alarm)) camp.alarm = source.id;
+		if (target.get(fighting)?.autoTarget === source.id) struck.blowAt = world.time;
+		if (target.alive && struck.returning && pastGrace(world, struck)) struck.returning = false;
+		if (helpsAtOnce(world, camp)) rally(world, camp);
+	}
+	const striker = source.get(campMember);
+	const own = striker && campsOf(world)[striker.camp - 1];
+	if (striker && own) {
+		entryOf(world, own, target).lastHitAt = world.time;
+		own.foughtAt = world.time;
+		if (source.get(fighting)?.autoTarget === target.id) striker.blowAt = world.time;
+	}
+}
+/**
+* What creeps do: guard their camp. They go for whoever comes close or attacks one of them, the most threat on the
+* camp's list first; give up a chase that brings no blow for `chaseTime`, and what goes past the leash from the camp's
+* centre; wait where they stand while the camp's fight is on, and go home `resetAfter` after its last blow, healing on
+* the way. At night they sleep at home
+*/
+function guardCamp(world, entity, dt) {
+	const member = entity.get(campMember);
+	const combat = entity.get(fighting);
+	const camp = campsOf(world)[member.camp - 1];
+	const m = entity.get(moving);
+	if (entity.asleep) {
+		if (world.night && !combat.lastAttacker && !world.get(camp.alarm)) return;
+		entity.asleep = false;
+	}
+	if (member.returning) {
+		entity.health = Math.min(entity.health + entity.maxHealth * RETREAT_HEALING * dt, entity.maxHealth);
+		if (m && m.status === "moving") return;
+		if (m && dist(entity.pos, member.home) > 1.5 && m.status !== "failed") {
+			moveTo(world, entity, member.home);
+			return;
+		}
+		member.returning = false;
+		member.returningAt = void 0;
+		combat.lastAttacker = 0;
+		if (camp.alarm && !world.get(camp.alarm)) camp.alarm = 0;
+		return;
+	}
+	let dropped = false;
+	if (combat.autoTarget) {
+		const target = world.get(combat.autoTarget);
+		const tooFar = !target || dist(target.pos, camp) > camp.leash || dist(entity.pos, camp) > camp.leash + LEASH_SLACK;
+		if (!tooFar && lashOut(world, entity)) return;
+		let result = tooFar ? "invalid" : engage(world, entity, target, dt, !!m);
+		const stale = world.time - (member.blowAt ?? world.time) > chaseTimeOf(world, camp);
+		if (result === "chasing" && target && (stale || isBlocked(world, entity, target))) {
+			shun(world, entity, target);
+			result = "invalid";
+		}
+		if (result === "attacking" || result === "chasing") return;
+		combat.autoTarget = 0;
+		disengage(world, entity);
+		dropped = true;
+	}
+	if (!dropped && (world.tick + entity.id) % 4 !== 0) return;
+	let next = campTarget(world, entity, camp);
+	if (!next) {
+		const seen = acquireTarget(world, entity);
+		if (mayChase(world, entity, camp, seen)) next = seen;
+	}
+	const hitter = world.get(combat.lastAttacker);
+	if (!next && mayChase(world, entity, camp, hitter)) next = hitter;
+	const alarm = world.get(camp.alarm);
+	if (!next && mayChase(world, entity, camp, alarm)) next = alarm;
+	if (!next && m && hitter && canAttack(world, entity, hitter) && !isShunned(world, entity, hitter) && dist(hitter.pos, camp) <= camp.leash) {
+		member.searching = {
+			x: hitter.pos.x,
+			z: hitter.pos.z
+		};
+		moveTo(world, entity, member.searching);
+	}
+	combat.lastAttacker = 0;
+	if (next) {
+		take(world, entity, member, camp, next);
+		return;
+	}
+	if (member.searching && m?.status === "moving" && dist(entity.pos, camp) <= camp.leash) return;
+	member.searching = null;
+	if (camp.foughtAt !== void 0 && world.time - camp.foughtAt < resetAfterOf(world, camp)) {
+		if (m?.status === "moving") halt(world, entity);
+		return;
+	}
+	if (camp.foughtAt !== void 0 || camp.aggro.length) {
+		camp.aggro.length = 0;
+		camp.foughtAt = void 0;
+	}
+	const intruder = world.get(camp.alarm);
+	if (camp.alarm && (!intruder || dist(intruder.pos, camp) > camp.leash)) camp.alarm = 0;
+	goHome(world, entity, member);
+	if (world.night && world.settings.camps.sleep && !member.returning && !camp.alarm) entity.asleep = true;
+}
+/**
+* What turns camps on: creeps of a camp guard it instead of doing what idle units do
+*
+* @internal
+*/
+var campHooks = [defineHook({
+	hook: "idle",
+	id: "guardCamp",
+	run(world, event) {
+		if (event.handled || !event.fights || !event.entity.has(campMember)) return;
+		guardCamp(world, event.entity, event.dt);
+		event.handled = true;
+	}
+})];
+/**
+* What feeds the camps' lists (`Camp.aggro`): every hit on a creep of a camp, or by one, as it is told (`damaged`). The
+* heroes pack's, with `campHooks`
+*
+* @internal
+*/
+var campListeners = [defineListener({
+	event: damaged,
+	id: "campAggro",
+	run: (world, { target, source, amount }) => hit(world, target, source, amount)
+})];
+/** What a seat says of the camps, kept up to date once a tick (`campsFor`) */
+var CAMPS = {};
+/**
+* The camps as a seat's player knows them (`GameSession.camps`): where they are and how strong, and which their team
+* has seen empty. Worked out once a tick, as the minimap asks every frame: the same list and objects every time, kept
+* up to date, so it is to read, not to keep
+*
+* @beta
+*/
+function campsFor(view) {
+	const kept = view.keep(CAMPS, () => ({
+		at: -1,
+		infos: []
+	}));
+	const { world } = view;
+	if (kept.at === world.tick) return kept.infos;
+	kept.at = world.tick;
+	const all = campsOf(world);
+	const { cleared } = view.memory;
+	const occupied = (members) => members.some((id) => !!world.get(id));
+	for (let i = 0; i < all.length; i++) {
+		const camp = all[i];
+		const known = cleared.indexOf(camp.id);
+		if (known < 0 && view.sees(camp.x, camp.z) && !occupied(camp.members)) cleared.push(camp.id);
+		else if (known >= 0 && view.sees(camp.x, camp.z) && occupied(camp.members)) cleared.splice(known, 1);
+		const info = kept.infos[i] ??= {
+			id: camp.id,
+			x: camp.x,
+			z: camp.z,
+			level: camp.level,
+			cleared: false
+		};
+		info.cleared = cleared.includes(camp.id);
+	}
+	kept.infos.length = all.length;
+	return kept.infos;
+}
+//#endregion
+export { RETURN_GRACE, aggroCamp, campHooks, campLayout, campListeners, campMember, campNamed, campRespawnSystem, campTarget, camps, campsFor, campsOf, resetCamp, respawnCamp, spawnCamp };
+
+//# sourceMappingURL=camps.js.map