@vibemancer/core 1.0.7 → 1.0.8

package/src/hooks/threat-analysis.ts

@@ -1,389 +1,396 @@
-/**
- * VIBEMANCER - THREAT ANALYSIS
- *
- * Pre-computes threat information for incoming projectiles.
- * This handles the "subconscious" perception of missile trajectories.
- */
-
-import {Position, ProjectileState} from '../types.js';
-import {
-	RULES,
-	COLLISION_RADIUS,
-	MISSILE_BASE_RADIUS,
-	MISSILE_RADIUS_PER_DAMAGE,
-	ARENA_SIZE,
-	ARENA_MIN,
-	ARENA_MAX,
-	ARENA_WATER_BUFFER,
-} from '../rules.js';
-import {distanceTo} from '../utils/distance.js';
-import {angleTo, normalizeAngle, angleDiff} from '../utils/angles.js';
-import type {AnalyzedThreat} from './types.js';
-
-// Maximum distance at which a missile is still tracked as a potential threat
-// (even if simulation says it will miss — homing missiles can change course)
-const THREAT_RELEVANCE_DISTANCE = 500;
-
-/**
- * Analyze all threats from enemy projectiles.
- *
- * @param myPos - Current position of the wizard
- * @param projectiles - All projectiles in the game
- * @param myProjectiles - Only the bot's own projectiles (used for filtering)
- * @param ticksUntilReady - Ticks until wizard can start a new action
- * @returns Array of analyzed threats sorted by ticksToImpact (soonest first)
- */
-export function analyzeThreats(
-	myPos: Position,
-	projectiles: ProjectileState[],
-	myProjectiles: ProjectileState[],
-	ticksUntilReady: number,
-): AnalyzedThreat[]
-{
-	// Filter to enemy projectiles by excluding our own
-	const myProjectileIds = new Set(myProjectiles.map((p) => p.id));
-	const enemyProjectiles = projectiles.filter((p) => !myProjectileIds.has(p.id));
-
-	// Analyze each projectile
-	const threats: AnalyzedThreat[] = [];
-
-	for (const projectile of enemyProjectiles)
-	{
-		const analysis = analyzeOneThreat(myPos, projectile, ticksUntilReady);
-		// Only include if it will hit or missile is within reasonable distance
-		const missileDistance = Math.sqrt(
-			(projectile.position.x - myPos.x) ** 2 +
-			(projectile.position.y - myPos.y) ** 2,
-		);
-		// Stryker disable next-line EqualityOperator: < vs <= equivalent (exact distance never equals constant in practice)
-		if (analysis.willHit || missileDistance < THREAT_RELEVANCE_DISTANCE)
-		{
-			threats.push(analysis);
-		}
-	}
-
-	// Sort by ticksToImpact (soonest first)
-	threats.sort((a, b) => a.ticksToImpact - b.ticksToImpact);
-
-	return threats;
-}
-
-/**
- * Analyze a single projectile threat.
- */
-function analyzeOneThreat(
-	targetPos: Position,
-	projectile: ProjectileState,
-	ticksUntilReady: number,
-): AnalyzedThreat
-{
-	// Calculate collision radius
-	const missileRadius = MISSILE_BASE_RADIUS + projectile.damage * MISSILE_RADIUS_PER_DAMAGE;
-	const collisionDist = COLLISION_RADIUS + missileRadius;
-
-	// Dodge simulation uses a larger collision distance to account for swept circle collision.
-	// The real game checks the entire missile path each tick (swept), but the simulation only
-	// checks endpoints. Adding half the missile speed compensates for this gap.
-	// Stryker disable next-line ArithmeticOperator: +speed*0.5 vs -speed*0.5 or /0.5 — only affects tight-margin dodge outcomes which are inherently stochastic
-	const dodgeCollisionDist = collisionDist + projectile.speed * 0.5;
-
-	// Simulate missile trajectory toward stationary target
-	const {willHit, ticksToImpact} = simulateMissileToTarget(
-		projectile,
-		targetPos,
-		collisionDist,
-	);
-
-	// Only simulate dodges for missiles that will actually hit (saves ~75% simulation work)
-	let canDodgeLeft = true;
-	let canDodgeRight = true;
-	let canOutrun = true;
-	let bestDodgeDirection: Position | null = null;
-
-	if (willHit)
-	{
-		canDodgeLeft = simulateDodge(projectile, targetPos, 'left', dodgeCollisionDist);
-		canDodgeRight = simulateDodge(projectile, targetPos, 'right', dodgeCollisionDist);
-		canOutrun = simulateDodge(projectile, targetPos, 'away', dodgeCollisionDist);
-
-		bestDodgeDirection = calculateBestDodgeDirection(
-			projectile,
-			targetPos,
-			canDodgeLeft,
-			canDodgeRight,
-			canOutrun,
-		);
-	}
-
-	// Calculate shield timing
-	// Can block if: ticksUntilReady + shield cast time < ticksToImpact
-	// Stryker disable next-line EqualityOperator,ArithmeticOperator: ±1 tick boundary is intentional buffer, not precisely testable
-	const canBlockInTime = ticksToImpact > ticksUntilReady + RULES.SHIELD_CAST_TIME + 1;
-
-	// When to start casting shield (leave 1 tick buffer)
-	const ticksToStartShield = Math.max(0, ticksToImpact - RULES.SHIELD_CAST_TIME - 1);
-
-	return {
-		id: projectile.id,
-		projectile,
-		ticksToImpact,
-		willHit,
-		canDodgeLeft,
-		canDodgeRight,
-		canOutrun,
-		bestDodgeDirection,
-		canBlockInTime,
-		ticksToStartShield,
-	};
-}
-
-/**
- * Simulate a missile moving toward a stationary target.
- * Accounts for homing (turn rate) and expiration.
- */
-function simulateMissileToTarget(
-	projectile: ProjectileState,
-	targetPos: Position,
-	collisionDist: number,
-): {willHit: boolean; ticksToImpact: number}
-{
-	let pos = {...projectile.position};
-	let rotation = projectile.rotation;
-	const maxTicks = projectile.remainingTicks;
-	const speed = projectile.speed;
-	const turnRate = projectile.turnRate;
-
-	// Stryker disable next-line EqualityOperator: <= vs < equivalent (off-by-one at max tick boundary is non-observable)
-	for (let tick = 1; tick <= maxTicks; tick++)
-	{
-		// Stryker disable next-line ConditionalExpression,EqualityOperator: turnRate>=0 equivalent (homing with rate 0 is no-op)
-		if (turnRate > 0)
-		{
-			const desiredAngle = angleTo(pos, targetPos);
-			const diff = angleDiff(rotation, desiredAngle);
-			const maxTurn = turnRate;
-
-			// Stryker disable all: homing snap — equivalent mutations (removing snap or changing boundary doesn't affect hit outcome)
-			if (Math.abs(diff) <= maxTurn)
-			{
-				rotation = desiredAngle;
-			}
-			// Stryker restore all
-			else
-			{
-				rotation = normalizeAngle(rotation + Math.sign(diff) * maxTurn);
-			}
-		}
-
-		// Move forward
-		const rad = rotation * (Math.PI / 180);
-		pos = {
-			x: pos.x + Math.cos(rad) * speed,
-			y: pos.y + Math.sin(rad) * speed,
-		};
-
-		// Check if missile is out of bounds (with water buffer)
-		if (isOutOfBounds(pos))
-		{
-			return {willHit: false, ticksToImpact: Infinity};
-		}
-
-		// Check collision
-		const dist = distanceTo(pos, targetPos);
-		// Stryker disable next-line EqualityOperator: <= vs < equivalent (float distance never exactly equals collisionDist)
-		if (dist <= collisionDist)
-		{
-			return {willHit: true, ticksToImpact: tick};
-		}
-	}
-
-	// Missile expired without hitting
-	return {willHit: false, ticksToImpact: Infinity};
-}
-
-/**
- * Simulate a dodge attempt.
- * Returns true if the dodge avoids the missile.
- */
-function simulateDodge(
-	projectile: ProjectileState,
-	startPos: Position,
-	direction: 'left' | 'right' | 'away',
-	collisionDist: number,
-): boolean
-{
-	// Calculate dodge direction vector
-	const dodgeDir = getDodgeDirection(projectile, startPos, direction);
-
-	// Stryker disable all: guard is equivalent — zero vector means zero movement, missile still hits, returns false either way
-	if (dodgeDir.x === 0 && dodgeDir.y === 0)
-	{
-		return false;
-	}
-	// Stryker restore all
-
-	let targetPos = {...startPos};
-	let missilePos = {...projectile.position};
-	let missileRotation = projectile.rotation;
-	const maxTicks = projectile.remainingTicks;
-	const speed = projectile.speed;
-	const turnRate = projectile.turnRate;
-
-	// Stryker disable next-line EqualityOperator,UpdateOperator: <= vs < off-by-one equivalent; tick-- causes timeout not assertion failure
-	for (let tick = 1; tick <= maxTicks; tick++)
-	{
-		// Stryker disable next-line ArithmeticOperator: RULES.MOVEMENT_SPEED=1 makes * and / identical; sign flip equivalent when wizard is wall-clamped
-		const newX = targetPos.x + dodgeDir.x * RULES.MOVEMENT_SPEED;
-		// Stryker disable next-line ArithmeticOperator: same as above
-		const newY = targetPos.y + dodgeDir.y * RULES.MOVEMENT_SPEED;
-
-		// Stryker disable all: arena clamp sign — +/- COLLISION_RADIUS equivalent (wizard rarely reaches exact wall boundary during dodge)
-		targetPos = {
-			x: Math.max(ARENA_MIN + COLLISION_RADIUS, Math.min(ARENA_MAX - COLLISION_RADIUS, newX)),
-			y: Math.max(ARENA_MIN + COLLISION_RADIUS, Math.min(ARENA_MAX - COLLISION_RADIUS, newY)),
-		};
-		// Stryker restore all
-
-		// Stryker disable next-line ConditionalExpression,EqualityOperator: turnRate>=0 equivalent (homing with rate 0 is no-op)
-		if (turnRate > 0)
-		{
-			const desiredAngle = angleTo(missilePos, targetPos);
-			const diff = angleDiff(missileRotation, desiredAngle);
-			const maxTurn = turnRate;
-
-			// Stryker disable all: homing snap/incremental — equivalent mutations (removing either branch doesn't change dodge outcome)
-			if (Math.abs(diff) <= maxTurn)
-			{
-				missileRotation = desiredAngle;
-			}
-			else
-			{
-				missileRotation = normalizeAngle(missileRotation + Math.sign(diff) * maxTurn);
-			}
-			// Stryker restore all
-		}
-
-		// Move missile
-		const rad = missileRotation * (Math.PI / 180);
-		missilePos = {
-			x: missilePos.x + Math.cos(rad) * speed,
-			y: missilePos.y + Math.sin(rad) * speed,
-		};
-
-		// Stryker disable all: OOB early-return equivalent — removing it means missile expires instead, still returns true
-		if (isOutOfBounds(missilePos))
-		{
-			return true;
-		}
-		// Stryker restore all
-
-		// Check collision
-		const dist = distanceTo(missilePos, targetPos);
-		// Stryker disable next-line EqualityOperator: <= vs < equivalent (float dist never exactly equals collisionDist)
-		if (dist <= collisionDist)
-		{
-			return false; // Got hit while dodging
-		}
-	}
-
-	// Missile expired without hitting
-	return true;
-}
-
-/**
- * Get the dodge direction vector based on direction type.
- */
-function getDodgeDirection(
-	projectile: ProjectileState,
-	targetPos: Position,
-	direction: 'left' | 'right' | 'away',
-): Position
-{
-	// Get missile direction vector
-	const missileAngleRad = projectile.rotation * (Math.PI / 180);
-	const missileDir = {
-		x: Math.cos(missileAngleRad),
-		y: Math.sin(missileAngleRad),
-	};
-
-	switch (direction)
-	{
-		case 'left':
-			// Perpendicular to missile direction (left = counter-clockwise)
-			return {x: missileDir.y, y: -missileDir.x};
-
-		case 'right':
-			// Perpendicular to missile direction (right = clockwise)
-			return {x: -missileDir.y, y: missileDir.x};
-
-		case 'away':
-		{
-			// Away from missile current position
-			const dx = targetPos.x - projectile.position.x;
-			const dy = targetPos.y - projectile.position.y;
-			const len = Math.sqrt(dx * dx + dy * dy);
-			if (len === 0) return {x: 0, y: 0};
-			return {x: dx / len, y: dy / len};
-		}
-
-		default:
-			return {x: 0, y: 0};
-	}
-}
-
-/**
- * Calculate the best dodge direction based on available options.
- */
-function calculateBestDodgeDirection(
-	projectile: ProjectileState,
-	targetPos: Position,
-	canDodgeLeft: boolean,
-	canDodgeRight: boolean,
-	canOutrun: boolean,
-): Position | null
-{
-	// Stryker disable next-line ConditionalExpression: replacing with false just falls through to the `else if (canDodgeLeft)` which returns the same value
-	if (canDodgeLeft && canDodgeRight)
-	{
-		// Both sides work - pick the one closer to where we want to be
-		// For simplicity, just return left
-		return getDodgeDirection(projectile, targetPos, 'left');
-	}
-	else if (canDodgeLeft)
-	{
-		return getDodgeDirection(projectile, targetPos, 'left');
-	}
-	else if (canDodgeRight)
-	{
-		return getDodgeDirection(projectile, targetPos, 'right');
-	}
-	else if (canOutrun)
-	{
-		return getDodgeDirection(projectile, targetPos, 'away');
-	}
-
-	// No dodge available
-	return null;
-}
-
-/**
- * Check if a position is out of bounds (past the water buffer).
- */
-function isOutOfBounds(pos: Position): boolean
-{
-	return (
-		pos.x < -ARENA_WATER_BUFFER ||
-		pos.x > ARENA_SIZE + ARENA_WATER_BUFFER ||
-		pos.y < -ARENA_WATER_BUFFER ||
-		pos.y > ARENA_SIZE + ARENA_WATER_BUFFER
-	);
-}
-
-/** @internal Exposed for mutation testing only. */
-export const _testing = {
-	simulateMissileToTarget,
-	simulateDodge,
-	getDodgeDirection,
-	calculateBestDodgeDirection,
-	isOutOfBounds,
-};
+/**
+ * VIBEMANCER - THREAT ANALYSIS
+ *
+ * Pre-computes threat information for incoming projectiles.
+ * This handles the "subconscious" perception of missile trajectories.
+ */
+
+import {Position, ProjectileState} from '../types.js';
+import {
+	RULES,
+	COLLISION_RADIUS,
+	calculateMissileRadius,
+	ARENA_SIZE,
+	ARENA_MIN,
+	ARENA_MAX,
+	ARENA_WATER_BUFFER,
+} from '../rules.js';
+import {distanceTo} from '../utils/distance.js';
+import {angleTo, normalizeAngle, angleDiff} from '../utils/angles.js';
+import type {AnalyzedThreat} from './types.js';
+
+// Maximum distance at which a missile is still tracked as a potential threat
+// (even if simulation says it will miss — homing missiles can change course)
+const THREAT_RELEVANCE_DISTANCE = 500;
+
+/**
+ * Analyze all threats from enemy projectiles.
+ *
+ * @param myPos - Current position of the wizard
+ * @param projectiles - All projectiles in the game
+ * @param myProjectiles - Only the bot's own projectiles (used for filtering)
+ * @param ticksUntilReady - Ticks until wizard can start a new action
+ * @returns Array of analyzed threats sorted by ticksToImpact (soonest first)
+ */
+export function analyzeThreats(
+	myPos: Position,
+	projectiles: ProjectileState[],
+	myProjectiles: ProjectileState[],
+	ticksUntilReady: number,
+): AnalyzedThreat[]
+{
+	// Filter to enemy projectiles by excluding our own
+	const myProjectileIds = new Set(myProjectiles.map((p) => p.id));
+	const enemyProjectiles = projectiles.filter((p) => !myProjectileIds.has(p.id));
+
+	// Analyze each projectile
+	const threats: AnalyzedThreat[] = [];
+
+	for (const projectile of enemyProjectiles)
+	{
+		const analysis = analyzeOneThreat(myPos, projectile, ticksUntilReady);
+		// Only include if it will hit or missile is within reasonable distance
+		const missileDistance = Math.sqrt(
+			(projectile.position.x - myPos.x) ** 2 +
+			(projectile.position.y - myPos.y) ** 2,
+		);
+		// Stryker disable next-line EqualityOperator: < vs <= equivalent (exact distance never equals constant in practice)
+		if (analysis.willHit || missileDistance < THREAT_RELEVANCE_DISTANCE)
+		{
+			threats.push(analysis);
+		}
+	}
+
+	// Sort by ticksToImpact (soonest first)
+	threats.sort((a, b) => a.ticksToImpact - b.ticksToImpact);
+
+	return threats;
+}
+
+/**
+ * Analyze a single projectile threat.
+ */
+function analyzeOneThreat(
+	targetPos: Position,
+	projectile: ProjectileState,
+	ticksUntilReady: number,
+): AnalyzedThreat
+{
+	// Ask the ENGINE for the collision radius rather than re-deriving it.
+	//
+	// This used to compute `MISSILE_BASE_RADIUS + damage * MISSILE_RADIUS_PER_DAMAGE`, which
+	// is the formula every document states — and which is not what the engine collides with.
+	// `calculateMissileRadius` multiplies that by 3, and `simulation.ts` feeds its result to
+	// the swept-circle check. So for a 10-damage missile this modelled a collision at 8 units
+	// while the real one happened at 14, and `useThreats()` — the game's own defensive tool —
+	// reported "will miss" for missiles that hit. A bot dodging into a gap between 8 and 14
+	// was walking into the missile on the engine's own advice.
+	const missileRadius = calculateMissileRadius(projectile.damage);
+	const collisionDist = COLLISION_RADIUS + missileRadius;
+
+	// Dodge simulation uses a larger collision distance to account for swept circle collision.
+	// The real game checks the entire missile path each tick (swept), but the simulation only
+	// checks endpoints. Adding half the missile speed compensates for this gap.
+	// Stryker disable next-line ArithmeticOperator: +speed*0.5 vs -speed*0.5 or /0.5 — only affects tight-margin dodge outcomes which are inherently stochastic
+	const dodgeCollisionDist = collisionDist + projectile.speed * 0.5;
+
+	// Simulate missile trajectory toward stationary target
+	const {willHit, ticksToImpact} = simulateMissileToTarget(
+		projectile,
+		targetPos,
+		collisionDist,
+	);
+
+	// Only simulate dodges for missiles that will actually hit (saves ~75% simulation work)
+	let canDodgeLeft = true;
+	let canDodgeRight = true;
+	let canOutrun = true;
+	let bestDodgeDirection: Position | null = null;
+
+	if (willHit)
+	{
+		canDodgeLeft = simulateDodge(projectile, targetPos, 'left', dodgeCollisionDist);
+		canDodgeRight = simulateDodge(projectile, targetPos, 'right', dodgeCollisionDist);
+		canOutrun = simulateDodge(projectile, targetPos, 'away', dodgeCollisionDist);
+
+		bestDodgeDirection = calculateBestDodgeDirection(
+			projectile,
+			targetPos,
+			canDodgeLeft,
+			canDodgeRight,
+			canOutrun,
+		);
+	}
+
+	// Calculate shield timing
+	// Can block if: ticksUntilReady + shield cast time < ticksToImpact
+	// Stryker disable next-line EqualityOperator,ArithmeticOperator: ±1 tick boundary is intentional buffer, not precisely testable
+	const canBlockInTime = ticksToImpact > ticksUntilReady + RULES.SHIELD_CAST_TIME + 1;
+
+	// When to start casting shield (leave 1 tick buffer)
+	const ticksToStartShield = Math.max(0, ticksToImpact - RULES.SHIELD_CAST_TIME - 1);
+
+	return {
+		id: projectile.id,
+		projectile,
+		ticksToImpact,
+		willHit,
+		canDodgeLeft,
+		canDodgeRight,
+		canOutrun,
+		bestDodgeDirection,
+		canBlockInTime,
+		ticksToStartShield,
+	};
+}
+
+/**
+ * Simulate a missile moving toward a stationary target.
+ * Accounts for homing (turn rate) and expiration.
+ */
+function simulateMissileToTarget(
+	projectile: ProjectileState,
+	targetPos: Position,
+	collisionDist: number,
+): {willHit: boolean; ticksToImpact: number}
+{
+	let pos = {...projectile.position};
+	let rotation = projectile.rotation;
+	const maxTicks = projectile.remainingTicks;
+	const speed = projectile.speed;
+	const turnRate = projectile.turnRate;
+
+	// Stryker disable next-line EqualityOperator: <= vs < equivalent (off-by-one at max tick boundary is non-observable)
+	for (let tick = 1; tick <= maxTicks; tick++)
+	{
+		// Stryker disable next-line ConditionalExpression,EqualityOperator: turnRate>=0 equivalent (homing with rate 0 is no-op)
+		if (turnRate > 0)
+		{
+			const desiredAngle = angleTo(pos, targetPos);
+			const diff = angleDiff(rotation, desiredAngle);
+			const maxTurn = turnRate;
+
+			// Stryker disable all: homing snap — equivalent mutations (removing snap or changing boundary doesn't affect hit outcome)
+			if (Math.abs(diff) <= maxTurn)
+			{
+				rotation = desiredAngle;
+			}
+			// Stryker restore all
+			else
+			{
+				rotation = normalizeAngle(rotation + Math.sign(diff) * maxTurn);
+			}
+		}
+
+		// Move forward
+		const rad = rotation * (Math.PI / 180);
+		pos = {
+			x: pos.x + Math.cos(rad) * speed,
+			y: pos.y + Math.sin(rad) * speed,
+		};
+
+		// Check if missile is out of bounds (with water buffer)
+		if (isOutOfBounds(pos))
+		{
+			return {willHit: false, ticksToImpact: Infinity};
+		}
+
+		// Check collision
+		const dist = distanceTo(pos, targetPos);
+		// Stryker disable next-line EqualityOperator: <= vs < equivalent (float distance never exactly equals collisionDist)
+		if (dist <= collisionDist)
+		{
+			return {willHit: true, ticksToImpact: tick};
+		}
+	}
+
+	// Missile expired without hitting
+	return {willHit: false, ticksToImpact: Infinity};
+}
+
+/**
+ * Simulate a dodge attempt.
+ * Returns true if the dodge avoids the missile.
+ */
+function simulateDodge(
+	projectile: ProjectileState,
+	startPos: Position,
+	direction: 'left' | 'right' | 'away',
+	collisionDist: number,
+): boolean
+{
+	// Calculate dodge direction vector
+	const dodgeDir = getDodgeDirection(projectile, startPos, direction);
+
+	// Stryker disable all: guard is equivalent — zero vector means zero movement, missile still hits, returns false either way
+	if (dodgeDir.x === 0 && dodgeDir.y === 0)
+	{
+		return false;
+	}
+	// Stryker restore all
+
+	let targetPos = {...startPos};
+	let missilePos = {...projectile.position};
+	let missileRotation = projectile.rotation;
+	const maxTicks = projectile.remainingTicks;
+	const speed = projectile.speed;
+	const turnRate = projectile.turnRate;
+
+	// Stryker disable next-line EqualityOperator,UpdateOperator: <= vs < off-by-one equivalent; tick-- causes timeout not assertion failure
+	for (let tick = 1; tick <= maxTicks; tick++)
+	{
+		// Stryker disable next-line ArithmeticOperator: RULES.MOVEMENT_SPEED=1 makes * and / identical; sign flip equivalent when wizard is wall-clamped
+		const newX = targetPos.x + dodgeDir.x * RULES.MOVEMENT_SPEED;
+		// Stryker disable next-line ArithmeticOperator: same as above
+		const newY = targetPos.y + dodgeDir.y * RULES.MOVEMENT_SPEED;
+
+		// Stryker disable all: arena clamp sign — +/- COLLISION_RADIUS equivalent (wizard rarely reaches exact wall boundary during dodge)
+		targetPos = {
+			x: Math.max(ARENA_MIN + COLLISION_RADIUS, Math.min(ARENA_MAX - COLLISION_RADIUS, newX)),
+			y: Math.max(ARENA_MIN + COLLISION_RADIUS, Math.min(ARENA_MAX - COLLISION_RADIUS, newY)),
+		};
+		// Stryker restore all
+
+		// Stryker disable next-line ConditionalExpression,EqualityOperator: turnRate>=0 equivalent (homing with rate 0 is no-op)
+		if (turnRate > 0)
+		{
+			const desiredAngle = angleTo(missilePos, targetPos);
+			const diff = angleDiff(missileRotation, desiredAngle);
+			const maxTurn = turnRate;
+
+			// Stryker disable all: homing snap/incremental — equivalent mutations (removing either branch doesn't change dodge outcome)
+			if (Math.abs(diff) <= maxTurn)
+			{
+				missileRotation = desiredAngle;
+			}
+			else
+			{
+				missileRotation = normalizeAngle(missileRotation + Math.sign(diff) * maxTurn);
+			}
+			// Stryker restore all
+		}
+
+		// Move missile
+		const rad = missileRotation * (Math.PI / 180);
+		missilePos = {
+			x: missilePos.x + Math.cos(rad) * speed,
+			y: missilePos.y + Math.sin(rad) * speed,
+		};
+
+		// Stryker disable all: OOB early-return equivalent — removing it means missile expires instead, still returns true
+		if (isOutOfBounds(missilePos))
+		{
+			return true;
+		}
+		// Stryker restore all
+
+		// Check collision
+		const dist = distanceTo(missilePos, targetPos);
+		// Stryker disable next-line EqualityOperator: <= vs < equivalent (float dist never exactly equals collisionDist)
+		if (dist <= collisionDist)
+		{
+			return false; // Got hit while dodging
+		}
+	}
+
+	// Missile expired without hitting
+	return true;
+}
+
+/**
+ * Get the dodge direction vector based on direction type.
+ */
+function getDodgeDirection(
+	projectile: ProjectileState,
+	targetPos: Position,
+	direction: 'left' | 'right' | 'away',
+): Position
+{
+	// Get missile direction vector
+	const missileAngleRad = projectile.rotation * (Math.PI / 180);
+	const missileDir = {
+		x: Math.cos(missileAngleRad),
+		y: Math.sin(missileAngleRad),
+	};
+
+	switch (direction)
+	{
+		case 'left':
+			// Perpendicular to missile direction (left = counter-clockwise)
+			return {x: missileDir.y, y: -missileDir.x};
+
+		case 'right':
+			// Perpendicular to missile direction (right = clockwise)
+			return {x: -missileDir.y, y: missileDir.x};
+
+		case 'away':
+		{
+			// Away from missile current position
+			const dx = targetPos.x - projectile.position.x;
+			const dy = targetPos.y - projectile.position.y;
+			const len = Math.sqrt(dx * dx + dy * dy);
+			if (len === 0) return {x: 0, y: 0};
+			return {x: dx / len, y: dy / len};
+		}
+
+		default:
+			return {x: 0, y: 0};
+	}
+}
+
+/**
+ * Calculate the best dodge direction based on available options.
+ */
+function calculateBestDodgeDirection(
+	projectile: ProjectileState,
+	targetPos: Position,
+	canDodgeLeft: boolean,
+	canDodgeRight: boolean,
+	canOutrun: boolean,
+): Position | null
+{
+	// Stryker disable next-line ConditionalExpression: replacing with false just falls through to the `else if (canDodgeLeft)` which returns the same value
+	if (canDodgeLeft && canDodgeRight)
+	{
+		// Both sides work - pick the one closer to where we want to be
+		// For simplicity, just return left
+		return getDodgeDirection(projectile, targetPos, 'left');
+	}
+	else if (canDodgeLeft)
+	{
+		return getDodgeDirection(projectile, targetPos, 'left');
+	}
+	else if (canDodgeRight)
+	{
+		return getDodgeDirection(projectile, targetPos, 'right');
+	}
+	else if (canOutrun)
+	{
+		return getDodgeDirection(projectile, targetPos, 'away');
+	}
+
+	// No dodge available
+	return null;
+}
+
+/**
+ * Check if a position is out of bounds (past the water buffer).
+ */
+function isOutOfBounds(pos: Position): boolean
+{
+	return (
+		pos.x < -ARENA_WATER_BUFFER ||
+		pos.x > ARENA_SIZE + ARENA_WATER_BUFFER ||
+		pos.y < -ARENA_WATER_BUFFER ||
+		pos.y > ARENA_SIZE + ARENA_WATER_BUFFER
+	);
+}
+
+/** @internal Exposed for mutation testing only. */
+export const _testing = {
+	simulateMissileToTarget,
+	simulateDodge,
+	getDodgeDirection,
+	calculateBestDodgeDirection,
+	isOutOfBounds,
+};