@v12-engine/engine 0.1.0 → 0.4.0

package/dist/systems/combat.js

@@ -0,0 +1,677 @@
+import { atan2 } from "../exactMath.js";
+import { angleDiff, dist } from "../math.js";
+import { at } from "../defs.js";
+import { attackTiming, statsOf } from "../stats.js";
+import { attackStarted, impact, missed, projectileRemoved, projectileSpawned, swingCancelled } from "../engineEvents.js";
+import { distanceToEdge, edgeDistance, fighting, moving } from "../entity.js";
+import { isDisarmed, isInvulnerable, isUntargetable, layerOf } from "../abilities/buffs.js";
+import { cancellable } from "../hooks.js";
+import { attackStat, farthestReach, groundAttack, pickAttack, rangeAgainst, reaches, tooNear } from "../attacks.js";
+import { STRUCTURE_REACH, engageWith, engagedLike, isShunned, release, roomFor } from "../engagement.js";
+import { faceTowards, halt, moveTo, moveToEntity, setAnchored } from "./movement.js";
+import { FOE_BONUS, summoned } from "../summoned.js";
+//#region src/systems/combat.ts
+/** Extra reach allowed once a swing has started, so targets stepping back slightly still get hit */
+/**
+* How far past its range a swing already begun still lands (`engage`, and the stances pack, which lets go where the engine would chase)
+*
+* @internal
+*/
+var SWING_SLACK = .75;
+var FACING_TOLERANCE = .4;
+/** The least a swing takes: a hit is never in the tick its swing began */
+var MIN_SWING = 1e-6;
+/** What a swing is aimed at when it is aimed at the ground. No entity has this id */
+var GROUND = -1;
+/**
+* How often an attack up a cliff goes wide
+*
+* @internal
+*/
+var UPHILL_MISS = .25;
+/**
+* Handed to the `canAttack` handlers, again and again, so that asking allocates nothing: one for each question under
+* way, as a handler may ask again (could the target hit back?) while its caller's handlers are still being run
+*/
+var askings = [];
+/** How many questions are under way, one inside the other */
+var asked = 0;
+/**
+* Whether an attacker may attack a target: its attack reaches it, it is an enemy, and the `canAttack` hook agrees.
+* `ordered`: a player told it to (an attack order), which a game may let it do to its own side (`CanAttack.ordered`)
+*
+* @beta
+*/
+function canAttack(world, attacker, target, ordered = false) {
+	if (!attacker.def.attacks?.length || !target.alive || target.hidden || target === attacker || target.def.invulnerable || target.def.targetableBy || target.isResource) return false;
+	if (target.buffs.length && (isInvulnerable(world, target) || isUntargetable(world, target))) return false;
+	if (attacker.buffs.length && isDisarmed(world, attacker)) return false;
+	const allowed = world.areEnemies(attacker.owner, target.owner) && world.settings.combat.pickAttack(world, attacker, target) >= 0;
+	if (!world.hooks.has("canAttack")) return allowed;
+	const asking = askings[asked] ??= cancellable({
+		attacker: void 0,
+		target: void 0,
+		cancelled: true,
+		ordered: false
+	});
+	asking.attacker = attacker;
+	asking.target = target;
+	asking.cancelled = !allowed;
+	asking.ordered = ordered;
+	asked++;
+	try {
+		return !world.hooks.run("canAttack", asking).cancelled;
+	} finally {
+		asked--;
+	}
+}
+/**
+* Whether one of an attacker's attacks can hit a target where it is, whoever's it is: the ground, the air, the kinds it
+* names (`pickAttack`). For a `canAttack` handler that lets a unit attack what is not an enemy
+*
+* @beta
+*/
+function attackReaches(world, attacker, target) {
+	return pickAttack(world, attacker, target) >= 0;
+}
+function canSee(world, viewer, target) {
+	return world.isVisibleTo(target, world.player(viewer.owner).team);
+}
+/**
+* Whether the target stands on higher ground than the attacker. Nothing is uphill from the air
+*
+* @beta
+*/
+function shootsUphill(world, attacker, target) {
+	if (layerOf(world, attacker) === "air") return false;
+	const { terrain } = world;
+	return terrain.levelAt(target.pos.x, target.pos.z) > terrain.levelAt(attacker.pos.x, attacker.pos.z);
+}
+var searches = [];
+/** How many searches are under way, one inside the other */
+var searching = 0;
+/** What a target with no room left for an attacker loses in its score: a free one of the same kind comes first, however far */
+var CROWDED = 1e3;
+/**
+* Best enemy within `range` of the entity (its acquisition range by default), as the `targetScore` hook sees it. Those
+* it leaves alone for now (`shun`) are not, unless `shunned` says to count them too: to know whether a fight is still on
+*/
+var acquireTarget = (world, entity, range, shunned = false) => searchTarget(world, entity, range, shunned).target;
+/**
+* Best enemy it can hit from where it stands: within the range of the attack it would use against each (`pickAttack`),
+* and `slack` more. For one that holds its ground
+*
+* @beta
+*/
+function acquireInRange(world, entity, slack = 0) {
+	const attacks = entity.def.attacks;
+	if (!attacks?.length) return void 0;
+	const stats = statsOf(world, entity);
+	if (attacks.length === 1) return searchTarget(world, entity, attackStat(stats, attacks[0], "range") + slack).target;
+	return searchTarget(world, entity, farthestReach(entity.def, stats) + slack, false, slack).target;
+}
+/**
+* What the `targetScore` hook makes of a target for an attacker, the engine's own score under it: what a search would
+* weigh it at, or -Infinity for one a game's hook leaves out. For a rule that hands an attacker a target without
+* searching (an ally's help), so that the game weighs it as it weighs any
+*/
+function scoreTarget(world, entity, other) {
+	const distance = edgeDistance(entity, other);
+	const threat = other.def.threat ?? (other.def.attacks?.length ? 2 : other.isBuilding ? 0 : 1);
+	const engaged = other.id === entity.get(fighting)?.engaged ? 0 : engagedLike(world, other, entity);
+	const room = roomFor(world, other, entity);
+	const score = threat * 1e3 - distance - (engaged >= room ? CROWDED : 0);
+	if (!world.hooks.has("targetScore")) return score;
+	return world.hooks.run("targetScore", {
+		attacker: entity,
+		target: other,
+		distance,
+		engaged,
+		room,
+		score
+	}).score;
+}
+/** Nothing found, by an entity that does not attack */
+var NOTHING = Object.freeze({
+	target: void 0,
+	passedOver: false
+});
+/**
+* `acquireTarget`, and whether it passed over a target it leaves alone for now (`TargetFound`). What it gives back is
+* the search's own, used again by the next search: read it at once
+*/
+function searchTarget(world, entity, range, shunned = false, inRange) {
+	if (!entity.def.attacks?.length) return NOTHING;
+	const reach = range ?? world.settings.combat.acquisitionRange(world, entity);
+	if (range === void 0 && reach <= 0) return NOTHING;
+	const search = searches[searching] ??= {
+		candidates: [],
+		scoring: {
+			attacker: void 0,
+			target: void 0,
+			distance: 0,
+			engaged: 0,
+			room: 0,
+			score: 0
+		},
+		found: {
+			target: void 0,
+			passedOver: false
+		}
+	};
+	searching++;
+	try {
+		return bestTarget(world, entity, reach, shunned, search, inRange);
+	} finally {
+		searching--;
+		search.candidates.length = 0;
+	}
+}
+/** By world, then by owner: whether another owner is on the owner's side, for the grid to leave out cells of theirs alone */
+var sidesOf = /* @__PURE__ */ new WeakMap();
+function sideTest(world, owner) {
+	let byOwner = sidesOf.get(world);
+	if (!byOwner) sidesOf.set(world, byOwner = /* @__PURE__ */ new Map());
+	let side = byOwner.get(owner);
+	if (!side) byOwner.set(owner, side = (other) => world.areAllies(owner, other));
+	return side;
+}
+var hasDeadZone = (attack) => !!attack.minRange;
+var firesOnTheMove = (attack) => !!attack.onTheMove;
+/** `inRange`: only what the attack it would use reaches, and that much more (`acquireInRange`) */
+function bestTarget(world, entity, reach, shunned, { candidates, scoring, found }, inRange) {
+	const hooked = world.hooks.has("targetScore");
+	world.spatial.query(entity.pos.x, entity.pos.z, reach + entity.def.radius, candidates, sideTest(world, entity.owner));
+	let best;
+	let bestScore = -Infinity;
+	let passed = false;
+	const { owner } = entity;
+	let sideOf = owner;
+	let ownSide = true;
+	const nearest = entity.def.attacks?.some(hasDeadZone) ?? false;
+	const brought = entity.get(summoned);
+	const foe = brought?.foe && brought.foeUntil > world.time ? brought.foe : 0;
+	for (const other of candidates) {
+		if (other.def.ignored) continue;
+		if (other.owner !== sideOf) {
+			sideOf = other.owner;
+			ownSide = world.areAllies(owner, sideOf);
+		}
+		if (ownSide) continue;
+		const distance = edgeDistance(entity, other);
+		if (distance > reach || !canAttack(world, entity, other) || !canSee(world, entity, other)) continue;
+		if (inRange !== void 0 && distance > rangeAgainst(world, entity, other) + inRange) continue;
+		if (nearest && tooNear(entity, other, Math.max(pickAttack(world, entity, other), 0))) continue;
+		if (!shunned && isShunned(world, entity, other)) {
+			passed = true;
+			continue;
+		}
+		const threat = other.def.threat ?? (other.def.attacks?.length ? 2 : other.isBuilding ? 0 : 1);
+		const engaged = other.id === entity.get(fighting)?.engaged ? 0 : engagedLike(world, other, entity);
+		const room = roomFor(world, other, entity);
+		let score = threat * 1e3 - distance - (engaged >= room ? CROWDED : 0);
+		if (foe && other.id === foe) score += FOE_BONUS;
+		if (hooked) {
+			scoring.attacker = entity;
+			scoring.target = other;
+			scoring.distance = distance;
+			scoring.engaged = engaged;
+			scoring.room = room;
+			scoring.score = score;
+			score = world.hooks.run("targetScore", scoring).score;
+		}
+		if (score > bestScore) {
+			bestScore = score;
+			best = other;
+		}
+	}
+	found.target = best;
+	found.passedOver = passed;
+	return found;
+}
+/**
+* Calls off the swing under way, before its blow: said (`swingCancelled`) when there was one, for the screen to cut
+* the attack to the walk. What has been swung already is not given back: the cooldown runs as it did
+*/
+function cancelSwing(world, entity) {
+	const combat = entity.get(fighting);
+	if (!combat) return;
+	if (combat.swing > 0) {
+		const target = combat.swingTarget > 0 ? world.get(combat.swingTarget) : void 0;
+		combat.swing = 0;
+		combat.swingTarget = 0;
+		world.events.emit(swingCancelled, {
+			attacker: entity,
+			target,
+			weapon: combat.weapon ?? 0
+		});
+		return;
+	}
+	combat.swing = 0;
+	combat.swingTarget = 0;
+}
+var caught = [];
+/** What an attack that hits an area does where it comes down */
+function explode(world, point, hit, splash, owner, source) {
+	const { radius, fells, targets } = splash;
+	for (const other of [...world.spatial.query(point.x, point.z, radius, caught)]) {
+		if (!other.alive || other.hidden) continue;
+		const distance = distanceToEdge(point, other);
+		if (distance > radius) continue;
+		if (other.def.fellable) {
+			if (fells) world.kill(other, source, false, "felled");
+			continue;
+		}
+		if (other.def.invulnerable || other.def.targetableBy) continue;
+		if (other.buffs.length && isUntargetable(world, other)) continue;
+		if (!reaches(targets, other, other.flying ? layerOf(world, other) : "ground")) continue;
+		const share = world.settings.combat.splash(world, source, other, distance, radius);
+		if (share <= 0) continue;
+		world.damage(other, hit.damage * share, source, {
+			damageType: hit.type,
+			crit: hit.crit,
+			attack: true,
+			tags: hit.tags,
+			how: hit.how
+		});
+	}
+	world.events.emit(impact, {
+		x: point.x,
+		z: point.z,
+		radius,
+		owner
+	});
+}
+var splashOf = (attack, radius = attack.splash) => radius ? {
+	radius,
+	fells: attack.fells ?? false,
+	targets: attack.targets
+} : void 0;
+/** The attack of the entity at that place goes off: at the target, or at a spot on the ground */
+function landHit(world, attacker, weapon, target, point = target.pos) {
+	const attack = attacker.def.attacks?.[weapon];
+	if (!attack) return;
+	const stats = statsOf(world, attacker);
+	const critical = world.settings.combat.critical(world, attacker, stats);
+	let crit = critical !== void 0;
+	const chance = target ? world.settings.combat.missChance(world, attacker, target) : 0;
+	let miss = chance > 0 && world.rng.next() < chance;
+	let damage = attackStat(stats, attack, "damage") * (critical ?? 1);
+	let type = attack.damageType ?? "physical";
+	let splash = splashOf(attack);
+	let speed = attack.projectileSpeed ?? 0;
+	let look;
+	let tags;
+	let how = typeof attack.how === "function" ? attack.how({
+		attacker,
+		target,
+		damage,
+		type,
+		crit,
+		tags
+	}) : attack.how;
+	if (world.hooks.has("beforeAttack")) {
+		const before = world.hooks.run("beforeAttack", {
+			attacker,
+			target,
+			point,
+			weapon,
+			damage,
+			type,
+			crit,
+			miss,
+			splash: splash?.radius,
+			projectileSpeed: speed,
+			look,
+			tags,
+			how,
+			cancelled: false
+		});
+		if (before.cancelled) return;
+		({damage, type, crit, miss, look, tags, how} = before);
+		speed = before.projectileSpeed;
+		splash = splashOf(attack, before.splash);
+	}
+	if (speed > 0) {
+		const projectile = {
+			id: world.newId(),
+			source: attacker.id,
+			owner: attacker.owner,
+			target: splash || !target ? 0 : target.id,
+			x: attacker.pos.x,
+			z: attacker.pos.z,
+			prevX: attacker.pos.x,
+			prevZ: attacker.pos.z,
+			sx: attacker.pos.x,
+			sz: attacker.pos.z,
+			tx: point.x,
+			tz: point.z,
+			speed,
+			damage,
+			type,
+			crit,
+			miss,
+			splash,
+			kind: attacker.def.id,
+			look,
+			tags,
+			...how && { how },
+			...weapon > 0 && { weapon }
+		};
+		world.projectiles.push(projectile);
+		world.events.emit(projectileSpawned, projectile);
+	} else if (miss) world.events.emit(missed, {
+		x: point.x,
+		z: point.z,
+		source: attacker,
+		target
+	});
+	else if (splash) explode(world, point, {
+		damage,
+		type,
+		crit,
+		tags,
+		how,
+		weapon
+	}, splash, attacker.owner, attacker);
+	else if (target && !(target.buffs.length && isUntargetable(world, target))) {
+		world.damage(target, damage, attacker, {
+			damageType: type,
+			crit,
+			attack: true,
+			tags,
+			how
+		});
+		const cleave = attacker.alive ? world.settings.combat.cleave(world, attacker, target, weapon) : void 0;
+		if (cleave) cleaveAround(world, attacker, target, attack, cleave, {
+			damage,
+			type,
+			crit,
+			tags,
+			how,
+			weapon
+		});
+	}
+}
+/**
+* What a blow from up close of the attacker's weapon at that place cleaves (`AttackDef.cleave`, `BuffDef.cleave`): the
+* attack's own, or a buff's at its level, whichever has the larger part. Nothing for none. The engine's
+* `RuleSettings.combat.cleave`
+*
+* @beta
+*/
+function cleaveOf(world, attacker, _target, weapon) {
+	const own = attacker.def.attacks?.[weapon]?.cleave;
+	let best = own && {
+		part: at(own.part, 1),
+		radius: own.radius,
+		angle: own.angle
+	};
+	for (const instance of attacker.buffs) {
+		const cleave = world.registry.buff(instance.id).cleave;
+		if (!cleave) continue;
+		const part = at(cleave.part, instance.level);
+		if (!best || part > best.part) best = {
+			part,
+			radius: cleave.radius,
+			angle: cleave.angle
+		};
+	}
+	return best && best.part > 0 && best.radius > 0 ? best : void 0;
+}
+var cleft = [];
+/**
+* The enemies of the attacker round a target it struck from up close take their part of the blow: within `radius` of
+* the target's edge, and within the cone of `angle` from the attacker through the target where it says. Not the target,
+* nor what the attack cannot hit. Not an attack of theirs: nothing an attack sets off (`onHit`, life steal) goes off
+* for each, and its tags say `cleave`
+*/
+function cleaveAround(world, attacker, target, attack, cleave, hit) {
+	const facing = atan2(target.pos.x - attacker.pos.x, target.pos.z - attacker.pos.z);
+	const tags = hit.tags ? [...hit.tags, "cleave"] : ["cleave"];
+	const reach = cleave.radius + target.def.radius + 2;
+	for (const other of [...world.spatial.query(target.pos.x, target.pos.z, reach, cleft)]) {
+		if (other === target || other === attacker || !other.alive || other.hidden || other.isResource) continue;
+		if (!world.areEnemies(attacker.owner, other.owner) || other.def.invulnerable || other.def.targetableBy) continue;
+		if (other.buffs.length && isUntargetable(world, other)) continue;
+		if (!reaches(attack.targets, other, other.flying ? layerOf(world, other) : "ground")) continue;
+		if (edgeDistance(target, other) > cleave.radius) continue;
+		if (cleave.angle !== void 0 && Math.abs(angleDiff(atan2(other.pos.x - attacker.pos.x, other.pos.z - attacker.pos.z), facing)) > cleave.angle / 2) continue;
+		world.damage(other, hit.damage * cleave.part, attacker, {
+			damageType: hit.type,
+			crit: hit.crit,
+			attack: false,
+			tags,
+			how: hit.how
+		});
+	}
+}
+/**
+* A swing of the attack at that place begun: its time to the hit less how late in the tick the swing was due (the
+* cooldown run past 0), so that the attacks keep to the attack speed instead of each waiting out a part of a tick (bug
+* 17). At least a moment, so that the hit is the next tick's. Which attack swings is kept for a unit with more than one
+*/
+function startSwing(world, entity, combat, weapon) {
+	combat.swing = Math.max(attackTiming(world, entity, weapon).swing + Math.min(combat.cooldown, 0), MIN_SWING);
+	combat.cooldown = 0;
+	if (weapon > 0 || combat.weapon !== void 0) combat.weapon = weapon;
+}
+/**
+* A swing landed: the time to the next, of whichever attack, is the period of the one that swung less its swing, less
+* how far past the hit this tick went; and where the attack has a recovery (`AttackDef.recovery`), what it is told is
+* held for so long. Gives the attack that swung, by place
+*/
+function endSwing(world, entity, combat) {
+	const weapon = combat.weapon ?? 0;
+	const { swing, period, recovery } = attackTiming(world, entity, weapon);
+	combat.cooldown = Math.max(period - swing + combat.swing, 0);
+	if (recovery > 0 && recovery + combat.swing > 0) combat.recovery = recovery + combat.swing;
+	combat.swing = 0;
+	combat.swingTarget = 0;
+	return weapon;
+}
+/** One tick of attacking a spot on the ground, for attacks that can. Getting into range is up to the caller */
+function bombard(world, entity, point, dt) {
+	const combat = entity.get(fighting);
+	const weapon = groundAttack(entity.def);
+	if (!combat || weapon < 0) return "outOfRange";
+	const swinging = combat.swing > 0 && combat.swingTarget === GROUND;
+	const range = attackStat(statsOf(world, entity), entity.def.attacks[swinging ? combat.weapon ?? 0 : weapon], "range");
+	if (dist(entity.pos, point) - entity.def.radius > range + (swinging ? .75 : 0)) {
+		cancelSwing(world, entity);
+		return "outOfRange";
+	}
+	const m = entity.get(moving);
+	if (m) {
+		if (m.status === "moving") halt(world, entity);
+		setAnchored(world, entity, true);
+	}
+	faceTowards(world, entity, point, dt);
+	if (swinging) {
+		combat.swing -= dt;
+		if (combat.swing <= 0) landHit(world, entity, endSwing(world, entity, combat), void 0, point);
+		return "attacking";
+	}
+	const facing = atan2(point.x - entity.pos.x, point.z - entity.pos.z);
+	if (combat.cooldown <= 0 && Math.abs(angleDiff(entity.facing, facing)) < FACING_TOLERANCE) {
+		startSwing(world, entity, combat, weapon);
+		combat.swingTarget = GROUND;
+		world.events.emit(attackStarted, {
+			attacker: entity,
+			weapon
+		});
+	}
+	return "attacking";
+}
+/**
+* Drives one tick of fighting a target: close the distance, turn, swing, hit.
+* Every order that fights (attack, attack-move, hold, idle auto-attack) goes through here.
+*/
+function engage(world, entity, target, dt, chase, ordered = false) {
+	const combat = entity.get(fighting);
+	const attacks = entity.def.attacks;
+	if (!combat || !attacks?.length || !target || !canAttack(world, entity, target, ordered) || !canSee(world, entity, target)) {
+		cancelSwing(world, entity);
+		release(entity, world);
+		return "invalid";
+	}
+	engageWith(world, entity, target);
+	const distance = edgeDistance(entity, target);
+	const swinging = combat.swing > 0 && combat.swingTarget === target.id;
+	const weapon = attacks.length === 1 ? 0 : swinging ? combat.weapon ?? 0 : Math.max(world.settings.combat.pickAttack(world, entity, target), 0);
+	const range = attackStat(statsOf(world, entity), attacks[weapon], "range") + (target.isStructure ? STRUCTURE_REACH : 0);
+	const near = !swinging ? attacks[weapon].minRange : void 0;
+	if (near && distance < near) {
+		cancelSwing(world, entity);
+		if (!ordered || !chase || !entity.get(moving)) {
+			release(entity, world);
+			return "outOfRange";
+		}
+		const away = dist(entity.pos, target.pos) || 1;
+		const to = Math.min(near + .5, (near + range) / 2) + entity.def.radius + target.def.radius;
+		const step = {
+			x: target.pos.x + (entity.pos.x - target.pos.x) / away * to,
+			z: target.pos.z + (entity.pos.z - target.pos.z) / away * to
+		};
+		const m = entity.get(moving);
+		if (m.status !== "moving" || m.goalEntity || dist(m.goal, step) > .5) moveTo(world, entity, step);
+		return "chasing";
+	}
+	if (distance > range + (swinging ? .75 : 0)) {
+		cancelSwing(world, entity);
+		if (!chase || !entity.get(moving)) {
+			release(entity, world);
+			return "outOfRange";
+		}
+		moveToEntity(world, entity, target, Math.max(range - .15, .05));
+		return "chasing";
+	}
+	const m = entity.get(moving);
+	if (m) {
+		if (m.status === "moving") halt(world, entity);
+		setAnchored(world, entity, true);
+	}
+	faceTowards(world, entity, target.pos, dt);
+	if (swinging) {
+		combat.swing -= dt;
+		if (combat.swing <= 0) landHit(world, entity, endSwing(world, entity, combat), target);
+		return "attacking";
+	}
+	const facing = atan2(target.pos.x - entity.pos.x, target.pos.z - entity.pos.z);
+	if (combat.cooldown <= 0 && Math.abs(angleDiff(entity.facing, facing)) < FACING_TOLERANCE) {
+		startSwing(world, entity, combat, weapon);
+		combat.swingTarget = target.id;
+		world.events.emit(attackStarted, {
+			attacker: entity,
+			target,
+			weapon
+		});
+	}
+	return "attacking";
+}
+/**
+* One tick of an attack that fires as the unit walks (`AttackDef.onTheMove`): what it shot at last tick while it can
+* still be hit from where the unit is, else the best in range (looked for every fourth tick), swung at without a stop
+* or a turn. Gives back what it is shooting at, none for nothing
+*
+* @beta
+*/
+function fireOnTheMove(world, entity, current, dt) {
+	const combat = entity.get(fighting);
+	const attacks = entity.def.attacks;
+	if (!combat || !attacks?.some(firesOnTheMove)) return void 0;
+	if (attacks.length && entity.buffs.length && isDisarmed(world, entity)) return void 0;
+	const usable = (target) => {
+		if (!target || !canAttack(world, entity, target) || !canSee(world, entity, target)) return false;
+		const weapon = attacks.length === 1 ? 0 : Math.max(pickAttack(world, entity, target), 0);
+		if (!attacks[weapon].onTheMove || tooNear(entity, target, weapon)) return false;
+		return edgeDistance(entity, target) <= attackStat(statsOf(world, entity), attacks[weapon], "range");
+	};
+	let target = current === void 0 ? void 0 : world.get(current);
+	if (!usable(target)) {
+		if (combat.swing > 0 && combat.swingTarget === current) cancelSwing(world, entity);
+		target = (world.tick + entity.id) % 4 === 0 ? acquireInRange(world, entity) : void 0;
+		if (!usable(target)) return void 0;
+	}
+	if (combat.swing > 0 && combat.swingTarget === target.id) {
+		combat.swing -= dt;
+		if (combat.swing <= 0) landHit(world, entity, endSwing(world, entity, combat), target);
+		return target.id;
+	}
+	if (combat.cooldown <= 0) {
+		const weapon = attacks.length === 1 ? 0 : Math.max(pickAttack(world, entity, target), 0);
+		startSwing(world, entity, combat, weapon);
+		combat.swingTarget = target.id;
+		world.events.emit(attackStarted, {
+			attacker: entity,
+			target,
+			weapon
+		});
+	}
+	return target.id;
+}
+/** Stops fighting: aborts the swing and lets the unit be pushed around again. */
+function disengage(world, entity) {
+	cancelSwing(world, entity);
+	release(entity, world);
+	setAnchored(world, entity, false);
+}
+var combatSystem = {
+	name: "combat",
+	phase: "resolve",
+	update(world, dt) {
+		for (const entity of world.index.with(fighting)) {
+			const combat = entity.get(fighting);
+			if (!combat) continue;
+			if (combat.cooldown > 0) combat.cooldown -= dt;
+			else if (combat.cooldown < 0) combat.cooldown = 0;
+			if (combat.recovery !== void 0 && (combat.recovery -= dt) <= 0) delete combat.recovery;
+		}
+		const { projectiles } = world;
+		for (let i = projectiles.length - 1; i >= 0; i--) {
+			const p = projectiles[i];
+			const target = world.get(p.target);
+			if (target && !target.hidden) {
+				p.tx = target.pos.x;
+				p.tz = target.pos.z;
+			}
+			p.prevX = p.x;
+			p.prevZ = p.z;
+			const dx = p.x - p.tx;
+			const dz = p.z - p.tz;
+			const remaining = Math.sqrt(dx * dx + dz * dz);
+			const step = p.speed * dt;
+			if (remaining <= step + (target ? target.def.radius * .5 : 0)) {
+				if (p.miss) world.events.emit(missed, {
+					x: p.tx,
+					z: p.tz,
+					source: world.get(p.source),
+					target
+				});
+				else if (p.splash) explode(world, {
+					x: p.tx,
+					z: p.tz
+				}, p, p.splash, p.owner, world.get(p.source));
+				else if (target && !(target.buffs.length && isUntargetable(world, target))) {
+					const source = world.get(p.source);
+					world.damage(target, p.damage, source, {
+						damageType: p.type,
+						crit: p.crit,
+						attack: true,
+						tags: p.tags,
+						how: p.how
+					});
+				}
+				projectiles.splice(i, 1);
+				world.events.emit(projectileRemoved, p);
+				continue;
+			}
+			p.x += (p.tx - p.x) / remaining * step;
+			p.z += (p.tz - p.z) / remaining * step;
+		}
+	}
+};
+//#endregion
+export { STRUCTURE_REACH, SWING_SLACK, UPHILL_MISS, acquireInRange, acquireTarget, attackReaches, bombard, canAttack, canSee, cancelSwing, cleaveOf, combatSystem, disengage, engage, fireOnTheMove, scoreTarget, searchTarget, shootsUphill };
+
+//# sourceMappingURL=combat.js.map