@vibemancer/core 0.1.0 → 0.1.2

package/src/bots/berserker/01_Stormchaser.ts

@@ -1,457 +1,457 @@
-import {WizardFunction, MissileAIFunction} from '../../types.js';
-import {angleTo} from '../../utils/angles.js';
-import {distanceTo} from '../../utils/distance.js';
-import {interceptAngle, moveInDirection} from '../../utils/movement.js';
-import {getMissileCastTime} from '../../utils/combat.js';
-import {ARENA_SIZE, GCD_DURATION, SHIELD_CAST_TIME} from '../../rules.js';
-import {
-	getThreats,
-	getMostUrgentThreat,
-	getDodgeDirectionForMovement,
-	isSafeToAttack,
-	getBlinkToCenter,
-	shouldForceShield,
-} from '../shared.js';
-import {useParam} from '../../engine/params-runtime.js';
-const WALL_BUFFER = 80;
-
-/**
- * Standard homing missile: higher damage for faster kills. s=5 × dur=150 = 750u range.
- */
-const STANDARD_CONFIG = {damage: 15, speed: 5, turnRate: 1, duration: 150};
-
-/**
- * Quick attack config for use under pressure (shorter cast time).
- * Same low turn/duration for warmup compatibility.
- */
-const QUICK_CONFIG = {damage: 10, speed: 5, turnRate: 1, duration: 80};
-
-/**
- * Predictive homing missile AI - leads the target.
- */
-const StormchaserMissileAI: MissileAIFunction = ({
-	worldState,
-	missileState,
-}) => 
-{
-	const enemy = worldState.enemies[0];
-	if (!enemy) return {};
-
-	const angle = interceptAngle(
-		missileState.position,
-		enemy.position,
-		enemy.velocity,
-		missileState.speed,
-	);
-	if (angle !== null) 
-	{
-		return {turnToward: moveInDirection(missileState.position, angle, 100)};
-	}
-	return {turnToward: enemy.position};
-};
-
-/**
- * Check if position is near a wall.
- */
-function isNearWall(position: {x: number; y: number}): boolean 
-{
-	return (
-		position.x < WALL_BUFFER ||
-    position.x > ARENA_SIZE - WALL_BUFFER ||
-    position.y < WALL_BUFFER ||
-    position.y > ARENA_SIZE - WALL_BUFFER
-	);
-}
-
-/**
- * Smart combat movement with threat-aware dodging.
- */
-function combatMove(
-	position: {x: number; y: number},
-	enemy: {position: {x: number; y: number}},
-	currentDistance: number,
-	targetDistance: number,
-	dodgeDirection: {x: number; y: number} | null,
-	tick: number,
-	strafeCyclePeriod: number,
-	strafeIntensity: number,
-	approachSpeed: number,
-	distanceDeadZone: number,
-): {x: number; y: number} 
-{
-	const deltaX = enemy.position.x - position.x;
-	const deltaY = enemy.position.y - position.y;
-	const normalizedDistance = currentDistance > 0 ? currentDistance : 1;
-
-	// Perpendicular directions for strafing
-	const strafeClockwise = {
-		x: -deltaY / normalizedDistance,
-		y: deltaX / normalizedDistance,
-	};
-	const strafeCounterClockwise = {
-		x: deltaY / normalizedDistance,
-		y: -deltaX / normalizedDistance,
-	};
-
-	let strafeDirection: {x: number; y: number};
-
-	// Priority 1: Use dodge direction (from threat analysis or close missile avoidance)
-	if (dodgeDirection) 
-	{
-		strafeDirection = dodgeDirection;
-	}
-	// Priority 2: Avoid walls
-	else if (isNearWall(position)) 
-	{
-		const futureClockwise = {
-			x: position.x + strafeClockwise.x * 100,
-			y: position.y + strafeClockwise.y * 100,
-		};
-		const futureCounterClockwise = {
-			x: position.x + strafeCounterClockwise.x * 100,
-			y: position.y + strafeCounterClockwise.y * 100,
-		};
-		const scoreClockwise = Math.min(
-			futureClockwise.x,
-			ARENA_SIZE - futureClockwise.x,
-			futureClockwise.y,
-			ARENA_SIZE - futureClockwise.y,
-		);
-		const scoreCounterClockwise = Math.min(
-			futureCounterClockwise.x,
-			ARENA_SIZE - futureCounterClockwise.x,
-			futureCounterClockwise.y,
-			ARENA_SIZE - futureCounterClockwise.y,
-		);
-		strafeDirection =
-			scoreClockwise > scoreCounterClockwise
-				? strafeClockwise
-				: strafeCounterClockwise;
-	}
-	// Priority 3: Commit to strafe direction (unpredictability)
-	else 
-	{
-		const cycle = Math.floor(tick / strafeCyclePeriod) % 2;
-		strafeDirection = cycle === 0 ? strafeClockwise : strafeCounterClockwise;
-	}
-
-	// When actively dodging, commit fully — no approach/retreat dilution
-	if (dodgeDirection) 
-	{
-		return {x: strafeDirection.x * 100, y: strafeDirection.y * 100};
-	}
-
-	let moveX = strafeDirection.x * strafeIntensity;
-	let moveY = strafeDirection.y * strafeIntensity;
-
-	// Distance management (tighter band than other bots, only when not dodging)
-	if (currentDistance > targetDistance + distanceDeadZone) 
-	{
-		moveX += (deltaX / normalizedDistance) * approachSpeed;
-		moveY += (deltaY / normalizedDistance) * approachSpeed;
-	}
-	else if (currentDistance < targetDistance - distanceDeadZone) 
-	{
-		let retreatX = -(deltaX / normalizedDistance) * approachSpeed;
-		let retreatY = -(deltaY / normalizedDistance) * approachSpeed;
-		if (position.x < WALL_BUFFER && retreatX < 0) retreatX = 0;
-		if (position.x > ARENA_SIZE - WALL_BUFFER && retreatX > 0) retreatX = 0;
-		if (position.y < WALL_BUFFER && retreatY < 0) retreatY = 0;
-		if (position.y > ARENA_SIZE - WALL_BUFFER && retreatY > 0) retreatY = 0;
-		moveX += retreatX;
-		moveY += retreatY;
-	}
-
-	// Normalize to max speed
-	const magnitude = Math.sqrt(moveX * moveX + moveY * moveY);
-	if (magnitude > 100) 
-	{
-		moveX = (moveX / magnitude) * 100;
-		moveY = (moveY / magnitude) * 100;
-	}
-
-	return {x: moveX, y: moveY};
-}
-
-/**
- * Bot: Stormchaser
- *
- * BEHAVIOR: Fights aggressively while managing defense intelligently. Uses
- * two fixed missile configs (standard homing + quick attack) with predictive
- * homing missile AI (interceptAngle on the missile itself). Blink-dodges
- * incoming threats, shields when blink is on cooldown. Tight distance
- * management (350 units, ±30 band).
- *
- * PROGRESSION LINE: Stormchaser → Stormcaller → Stormforger
- * - Stormchaser (tier 1): Fixed missiles, predictive homing AI, blink-dodge
- * - Stormcaller (tier 2): + fitMissileToBudget, predictive homing, optimized damage
- * - Stormforger (tier 3): Future — supreme berserker, perfect aggression
- *
- * TIER: 1 (base)
- */
-export const Stormchaser: WizardFunction = ({state}) => 
-{
-	const targetDistance = useParam('targetDistance', 191, {
-		range: 150,
-		min: 0,
-	});
-	const healthLowThreshold = useParam('healthLowThreshold', 45, {
-		range: 20,
-		min: 1,
-		steps: 5,
-	});
-	const strafeCyclePeriod = useParam('strafeCyclePeriod', 130, {
-		range: 75,
-		min: 80,
-		max: 300,
-	});
-	const strafeIntensity = useParam('strafeIntensity', 42, {
-		range: 40,
-		min: 20,
-		max: 100,
-		steps: 7,
-	});
-	const approachSpeed = useParam('approachSpeed', 68, {
-		range: 30,
-		min: 10,
-		max: 70,
-		steps: 7,
-	});
-	const distanceDeadZone = useParam('distanceDeadZone', 26, {
-		range: 25,
-		min: 10,
-		max: 60,
-		steps: 7,
-	});
-	const shieldCancelThreshold = useParam('shieldCancelThreshold', 150, {
-		range: 75,
-		min: 50,
-		max: 300,
-	});
-	const blinkWindowMax = useParam('blinkWindowMax', 25, {
-		range: 30,
-		min: 15,
-		max: 80,
-		steps: 7,
-	});
-	const cancelMinRemainingCast = useParam('cancelMinRemainingCast', 5, {
-		range: 50,
-		min: 5,
-		max: 150,
-		steps: 7,
-	});
-	const attackRange = useParam('attackRange', 676, {
-		range: 200,
-		min: 300,
-		max: 800,
-	});
-	const healthDamageRatio = useParam('healthDamageRatio', 5, {
-		range: 2,
-		min: 0.5,
-		max: 5,
-		steps: 7,
-	});
-
-	const enemy = state.enemies[0];
-	if (!enemy) 
-	{
-		return {move: {x: 0, y: 0}};
-	}
-
-	const distance = distanceTo(state.position, enemy.position);
-
-	// Analyze threats using simulation
-	const threats = getThreats(state);
-	const urgentThreat = getMostUrgentThreat(threats);
-
-	// === DEFENSE: Handle channeling state ===
-	if (state.state === 'channeling') 
-	{
-		// Cancel shield if no imminent danger
-		if (!urgentThreat || urgentThreat.ticksToImpact > shieldCancelThreshold) 
-		{
-			return {move: {x: 0, y: 0}, cancel: true};
-		}
-		return {move: {x: 0, y: 0}};
-	}
-
-	// === DEFENSE: Cancel missile cast for threats arriving during vulnerability window ===
-	if (
-		state.state === 'casting' &&
-    state.castingSpell === 'missile' &&
-    urgentThreat
-	) 
-	{
-		const remainingCast = (state.castDuration ?? 0) - (state.castProgress ?? 0);
-		const incomingDamage = urgentThreat.projectile.damage;
-		const arrivesInGCD =
-			urgentThreat.ticksToImpact > remainingCast &&
-      urgentThreat.ticksToImpact <= remainingCast + GCD_DURATION;
-
-		// Cancel for undodgeable threats when trade isn't worth it
-		if (!urgentThreat.bestDodgeDirection) 
-		{
-			const canSurviveHit =
-				state.health > incomingDamage * healthDamageRatio + 1;
-			const tradeWorthIt =
-				canSurviveHit && incomingDamage <= QUICK_CONFIG.damage;
-			if (
-				!tradeWorthIt &&
-        remainingCast > cancelMinRemainingCast &&
-        urgentThreat.ticksToImpact <=
-          remainingCast + GCD_DURATION + SHIELD_CAST_TIME + 1
-			) 
-			{
-				const dodgeDir = getDodgeDirectionForMovement(threats, state.position);
-				const cancelMove = combatMove(
-					state.position,
-					enemy,
-					distance,
-					targetDistance,
-					dodgeDir,
-					state.tick,
-					strafeCyclePeriod,
-					strafeIntensity,
-					approachSpeed,
-					distanceDeadZone,
-				);
-				return {move: cancelMove, cancel: true};
-			}
-		}
-
-		// Cancel for ANY threat arriving during GCD when health is critical
-		// At low health, surviving is more important than finishing the attack.
-		if (
-			arrivesInGCD &&
-      state.health <= incomingDamage + 1 &&
-      remainingCast > 10
-		) 
-		{
-			const dodgeDir = getDodgeDirectionForMovement(threats, state.position);
-			const cancelMove = combatMove(
-				state.position,
-				enemy,
-				distance,
-				targetDistance,
-				dodgeDir,
-				state.tick,
-				strafeCyclePeriod,
-				strafeIntensity,
-				approachSpeed,
-				distanceDeadZone,
-			);
-			return {move: cancelMove, cancel: true};
-		}
-	}
-
-	// === BLINK: Dodge missile + reposition (first priority) ===
-	// Blink dodges the incoming missile — no GCD after, so can immediately fire back.
-	// Only shield when blink is on cooldown.
-	if (
-		state.state === 'idle' &&
-    urgentThreat &&
-    state.blinkCooldown === 0 &&
-    urgentThreat.ticksToImpact >= 10 &&
-    urgentThreat.ticksToImpact <= blinkWindowMax
-	) 
-	{
-		return {
-			move: {x: 0, y: 0},
-			startCast: {spell: 'blink', target: getBlinkToCenter(state.position)},
-		};
-	}
-
-	// === DEFENSE: Shield threats (when blink is on cooldown) ===
-	if (state.state === 'idle' && urgentThreat) 
-	{
-		const forceShield = shouldForceShield(urgentThreat);
-		const undodgeable = !urgentThreat.bestDodgeDirection;
-		const healthLow = state.health < healthLowThreshold;
-		const healthCritical =
-			state.health <= urgentThreat.projectile.damage * healthDamageRatio + 1;
-		const shouldShield =
-			forceShield || (undodgeable && healthLow) || healthCritical;
-
-		if (shouldShield && urgentThreat.canBlockInTime) 
-		{
-			if (urgentThreat.ticksToStartShield <= 3) 
-			{
-				return {
-					move: {x: 0, y: 0},
-					startCast: {spell: 'shield'},
-				};
-			}
-		}
-	}
-
-	// === MOVEMENT: Smart combat movement ===
-	const dodgeDirection = getDodgeDirectionForMovement(threats, state.position);
-	const move = combatMove(
-		state.position,
-		enemy,
-		distance,
-		targetDistance,
-		dodgeDirection,
-		state.tick,
-		strafeCyclePeriod,
-		strafeIntensity,
-		approachSpeed,
-		distanceDeadZone,
-	);
-
-	// === OFFENSE: Attack aggressively while moving ===
-	if (state.state === 'idle' && distance < attackRange) 
-	{
-		// Primary: standard homing missile
-		const standardCastTime = getMissileCastTime(STANDARD_CONFIG);
-		if (isSafeToAttack(threats, standardCastTime)) 
-		{
-			return {
-				move,
-				startCast: {
-					spell: 'missile',
-					config: STANDARD_CONFIG,
-					missileAI: StormchaserMissileAI,
-					direction: angleTo(state.position, enemy.position),
-				},
-			};
-		}
-
-		// Fallback: quick missile under pressure (shorter cast = smaller vulnerability window)
-		const quickCastTime = getMissileCastTime(QUICK_CONFIG);
-		if (isSafeToAttack(threats, quickCastTime)) 
-		{
-			return {
-				move,
-				startCast: {
-					spell: 'missile',
-					config: QUICK_CONFIG,
-					missileAI: StormchaserMissileAI,
-					direction: angleTo(state.position, enemy.position),
-				},
-			};
-		}
-
-		// Not safe to attack — wait for threat to pass, then fire
-	}
-
-	// === FALLBACK DEFENSE: Shield when no attack window exists ===
-	// If all offense checks failed and there's an undodgeable threat, shield it
-	// rather than sitting idle and taking the hit.
-	if (
-		state.state === 'idle' &&
-    urgentThreat &&
-    !urgentThreat.bestDodgeDirection &&
-    urgentThreat.canBlockInTime &&
-    urgentThreat.ticksToStartShield <= 3
-	) 
-	{
-		return {
-			move: {x: 0, y: 0},
-			startCast: {spell: 'shield'},
-		};
-	}
-
-	// Default: just move (dodging/positioning)
-	return {move};
-};
+import {WizardFunction, MissileAIFunction} from '../../types.js';
+import {angleTo} from '../../utils/angles.js';
+import {distanceTo} from '../../utils/distance.js';
+import {interceptAngle, moveInDirection} from '../../utils/movement.js';
+import {getMissileCastTime} from '../../utils/combat.js';
+import {ARENA_SIZE, GCD_DURATION, SHIELD_CAST_TIME} from '../../rules.js';
+import {
+	getThreats,
+	getMostUrgentThreat,
+	getDodgeDirectionForMovement,
+	isSafeToAttack,
+	getBlinkToCenter,
+	shouldForceShield,
+} from '../shared.js';
+import {useParam} from '../../engine/params-runtime.js';
+const WALL_BUFFER = 80;
+
+/**
+ * Standard homing missile: higher damage for faster kills. s=5 × dur=150 = 750u range.
+ */
+const STANDARD_CONFIG = {damage: 15, speed: 5, turnRate: 1, duration: 150};
+
+/**
+ * Quick attack config for use under pressure (shorter cast time).
+ * Same low turn/duration for warmup compatibility.
+ */
+const QUICK_CONFIG = {damage: 10, speed: 5, turnRate: 1, duration: 80};
+
+/**
+ * Predictive homing missile AI - leads the target.
+ */
+const StormchaserMissileAI: MissileAIFunction = ({
+	worldState,
+	missileState,
+}) => 
+{
+	const enemy = worldState.enemies[0];
+	if (!enemy) return {};
+
+	const angle = interceptAngle(
+		missileState.position,
+		enemy.position,
+		enemy.velocity,
+		missileState.speed,
+	);
+	if (angle !== null) 
+	{
+		return {turnToward: moveInDirection(missileState.position, angle, 100)};
+	}
+	return {turnToward: enemy.position};
+};
+
+/**
+ * Check if position is near a wall.
+ */
+function isNearWall(position: {x: number; y: number}): boolean 
+{
+	return (
+		position.x < WALL_BUFFER ||
+    position.x > ARENA_SIZE - WALL_BUFFER ||
+    position.y < WALL_BUFFER ||
+    position.y > ARENA_SIZE - WALL_BUFFER
+	);
+}
+
+/**
+ * Smart combat movement with threat-aware dodging.
+ */
+function combatMove(
+	position: {x: number; y: number},
+	enemy: {position: {x: number; y: number}},
+	currentDistance: number,
+	targetDistance: number,
+	dodgeDirection: {x: number; y: number} | null,
+	tick: number,
+	strafeCyclePeriod: number,
+	strafeIntensity: number,
+	approachSpeed: number,
+	distanceDeadZone: number,
+): {x: number; y: number} 
+{
+	const deltaX = enemy.position.x - position.x;
+	const deltaY = enemy.position.y - position.y;
+	const normalizedDistance = currentDistance > 0 ? currentDistance : 1;
+
+	// Perpendicular directions for strafing
+	const strafeClockwise = {
+		x: -deltaY / normalizedDistance,
+		y: deltaX / normalizedDistance,
+	};
+	const strafeCounterClockwise = {
+		x: deltaY / normalizedDistance,
+		y: -deltaX / normalizedDistance,
+	};
+
+	let strafeDirection: {x: number; y: number};
+
+	// Priority 1: Use dodge direction (from threat analysis or close missile avoidance)
+	if (dodgeDirection) 
+	{
+		strafeDirection = dodgeDirection;
+	}
+	// Priority 2: Avoid walls
+	else if (isNearWall(position)) 
+	{
+		const futureClockwise = {
+			x: position.x + strafeClockwise.x * 100,
+			y: position.y + strafeClockwise.y * 100,
+		};
+		const futureCounterClockwise = {
+			x: position.x + strafeCounterClockwise.x * 100,
+			y: position.y + strafeCounterClockwise.y * 100,
+		};
+		const scoreClockwise = Math.min(
+			futureClockwise.x,
+			ARENA_SIZE - futureClockwise.x,
+			futureClockwise.y,
+			ARENA_SIZE - futureClockwise.y,
+		);
+		const scoreCounterClockwise = Math.min(
+			futureCounterClockwise.x,
+			ARENA_SIZE - futureCounterClockwise.x,
+			futureCounterClockwise.y,
+			ARENA_SIZE - futureCounterClockwise.y,
+		);
+		strafeDirection =
+			scoreClockwise > scoreCounterClockwise
+				? strafeClockwise
+				: strafeCounterClockwise;
+	}
+	// Priority 3: Commit to strafe direction (unpredictability)
+	else 
+	{
+		const cycle = Math.floor(tick / strafeCyclePeriod) % 2;
+		strafeDirection = cycle === 0 ? strafeClockwise : strafeCounterClockwise;
+	}
+
+	// When actively dodging, commit fully — no approach/retreat dilution
+	if (dodgeDirection) 
+	{
+		return {x: strafeDirection.x * 100, y: strafeDirection.y * 100};
+	}
+
+	let moveX = strafeDirection.x * strafeIntensity;
+	let moveY = strafeDirection.y * strafeIntensity;
+
+	// Distance management (tighter band than other bots, only when not dodging)
+	if (currentDistance > targetDistance + distanceDeadZone) 
+	{
+		moveX += (deltaX / normalizedDistance) * approachSpeed;
+		moveY += (deltaY / normalizedDistance) * approachSpeed;
+	}
+	else if (currentDistance < targetDistance - distanceDeadZone) 
+	{
+		let retreatX = -(deltaX / normalizedDistance) * approachSpeed;
+		let retreatY = -(deltaY / normalizedDistance) * approachSpeed;
+		if (position.x < WALL_BUFFER && retreatX < 0) retreatX = 0;
+		if (position.x > ARENA_SIZE - WALL_BUFFER && retreatX > 0) retreatX = 0;
+		if (position.y < WALL_BUFFER && retreatY < 0) retreatY = 0;
+		if (position.y > ARENA_SIZE - WALL_BUFFER && retreatY > 0) retreatY = 0;
+		moveX += retreatX;
+		moveY += retreatY;
+	}
+
+	// Normalize to max speed
+	const magnitude = Math.sqrt(moveX * moveX + moveY * moveY);
+	if (magnitude > 100) 
+	{
+		moveX = (moveX / magnitude) * 100;
+		moveY = (moveY / magnitude) * 100;
+	}
+
+	return {x: moveX, y: moveY};
+}
+
+/**
+ * Bot: Stormchaser
+ *
+ * BEHAVIOR: Fights aggressively while managing defense intelligently. Uses
+ * two fixed missile configs (standard homing + quick attack) with predictive
+ * homing missile AI (interceptAngle on the missile itself). Blink-dodges
+ * incoming threats, shields when blink is on cooldown. Tight distance
+ * management (350 units, ±30 band).
+ *
+ * PROGRESSION LINE: Stormchaser → Stormcaller → Stormforger
+ * - Stormchaser (tier 1): Fixed missiles, predictive homing AI, blink-dodge
+ * - Stormcaller (tier 2): + fitMissileToBudget, predictive homing, optimized damage
+ * - Stormforger (tier 3): Future — supreme berserker, perfect aggression
+ *
+ * TIER: 1 (base)
+ */
+export const Stormchaser: WizardFunction = ({state}) => 
+{
+	const targetDistance = useParam('targetDistance', 191, {
+		range: 150,
+		min: 0,
+	});
+	const healthLowThreshold = useParam('healthLowThreshold', 45, {
+		range: 20,
+		min: 1,
+		steps: 5,
+	});
+	const strafeCyclePeriod = useParam('strafeCyclePeriod', 130, {
+		range: 75,
+		min: 80,
+		max: 300,
+	});
+	const strafeIntensity = useParam('strafeIntensity', 42, {
+		range: 40,
+		min: 20,
+		max: 100,
+		steps: 7,
+	});
+	const approachSpeed = useParam('approachSpeed', 68, {
+		range: 30,
+		min: 10,
+		max: 70,
+		steps: 7,
+	});
+	const distanceDeadZone = useParam('distanceDeadZone', 26, {
+		range: 25,
+		min: 10,
+		max: 60,
+		steps: 7,
+	});
+	const shieldCancelThreshold = useParam('shieldCancelThreshold', 150, {
+		range: 75,
+		min: 50,
+		max: 300,
+	});
+	const blinkWindowMax = useParam('blinkWindowMax', 25, {
+		range: 30,
+		min: 15,
+		max: 80,
+		steps: 7,
+	});
+	const cancelMinRemainingCast = useParam('cancelMinRemainingCast', 5, {
+		range: 50,
+		min: 5,
+		max: 150,
+		steps: 7,
+	});
+	const attackRange = useParam('attackRange', 676, {
+		range: 200,
+		min: 300,
+		max: 800,
+	});
+	const healthDamageRatio = useParam('healthDamageRatio', 5, {
+		range: 2,
+		min: 0.5,
+		max: 5,
+		steps: 7,
+	});
+
+	const enemy = state.enemies[0];
+	if (!enemy) 
+	{
+		return {move: {x: 0, y: 0}};
+	}
+
+	const distance = distanceTo(state.position, enemy.position);
+
+	// Analyze threats using simulation
+	const threats = getThreats(state);
+	const urgentThreat = getMostUrgentThreat(threats);
+
+	// === DEFENSE: Handle channeling state ===
+	if (state.state === 'channeling') 
+	{
+		// Cancel shield if no imminent danger
+		if (!urgentThreat || urgentThreat.ticksToImpact > shieldCancelThreshold) 
+		{
+			return {move: {x: 0, y: 0}, cancel: true};
+		}
+		return {move: {x: 0, y: 0}};
+	}
+
+	// === DEFENSE: Cancel missile cast for threats arriving during vulnerability window ===
+	if (
+		state.state === 'casting' &&
+    state.castingSpell === 'missile' &&
+    urgentThreat
+	) 
+	{
+		const remainingCast = (state.castDuration ?? 0) - (state.castProgress ?? 0);
+		const incomingDamage = urgentThreat.projectile.damage;
+		const arrivesInGCD =
+			urgentThreat.ticksToImpact > remainingCast &&
+      urgentThreat.ticksToImpact <= remainingCast + GCD_DURATION;
+
+		// Cancel for undodgeable threats when trade isn't worth it
+		if (!urgentThreat.bestDodgeDirection) 
+		{
+			const canSurviveHit =
+				state.health > incomingDamage * healthDamageRatio + 1;
+			const tradeWorthIt =
+				canSurviveHit && incomingDamage <= QUICK_CONFIG.damage;
+			if (
+				!tradeWorthIt &&
+        remainingCast > cancelMinRemainingCast &&
+        urgentThreat.ticksToImpact <=
+          remainingCast + GCD_DURATION + SHIELD_CAST_TIME + 1
+			) 
+			{
+				const dodgeDir = getDodgeDirectionForMovement(threats, state.position);
+				const cancelMove = combatMove(
+					state.position,
+					enemy,
+					distance,
+					targetDistance,
+					dodgeDir,
+					state.tick,
+					strafeCyclePeriod,
+					strafeIntensity,
+					approachSpeed,
+					distanceDeadZone,
+				);
+				return {move: cancelMove, cancel: true};
+			}
+		}
+
+		// Cancel for ANY threat arriving during GCD when health is critical
+		// At low health, surviving is more important than finishing the attack.
+		if (
+			arrivesInGCD &&
+      state.health <= incomingDamage + 1 &&
+      remainingCast > 10
+		) 
+		{
+			const dodgeDir = getDodgeDirectionForMovement(threats, state.position);
+			const cancelMove = combatMove(
+				state.position,
+				enemy,
+				distance,
+				targetDistance,
+				dodgeDir,
+				state.tick,
+				strafeCyclePeriod,
+				strafeIntensity,
+				approachSpeed,
+				distanceDeadZone,
+			);
+			return {move: cancelMove, cancel: true};
+		}
+	}
+
+	// === BLINK: Dodge missile + reposition (first priority) ===
+	// Blink dodges the incoming missile — no GCD after, so can immediately fire back.
+	// Only shield when blink is on cooldown.
+	if (
+		state.state === 'idle' &&
+    urgentThreat &&
+    state.blinkCooldown === 0 &&
+    urgentThreat.ticksToImpact >= 10 &&
+    urgentThreat.ticksToImpact <= blinkWindowMax
+	) 
+	{
+		return {
+			move: {x: 0, y: 0},
+			startCast: {spell: 'blink', target: getBlinkToCenter(state.position)},
+		};
+	}
+
+	// === DEFENSE: Shield threats (when blink is on cooldown) ===
+	if (state.state === 'idle' && urgentThreat) 
+	{
+		const forceShield = shouldForceShield(urgentThreat);
+		const undodgeable = !urgentThreat.bestDodgeDirection;
+		const healthLow = state.health < healthLowThreshold;
+		const healthCritical =
+			state.health <= urgentThreat.projectile.damage * healthDamageRatio + 1;
+		const shouldShield =
+			forceShield || (undodgeable && healthLow) || healthCritical;
+
+		if (shouldShield && urgentThreat.canBlockInTime) 
+		{
+			if (urgentThreat.ticksToStartShield <= 3) 
+			{
+				return {
+					move: {x: 0, y: 0},
+					startCast: {spell: 'shield'},
+				};
+			}
+		}
+	}
+
+	// === MOVEMENT: Smart combat movement ===
+	const dodgeDirection = getDodgeDirectionForMovement(threats, state.position);
+	const move = combatMove(
+		state.position,
+		enemy,
+		distance,
+		targetDistance,
+		dodgeDirection,
+		state.tick,
+		strafeCyclePeriod,
+		strafeIntensity,
+		approachSpeed,
+		distanceDeadZone,
+	);
+
+	// === OFFENSE: Attack aggressively while moving ===
+	if (state.state === 'idle' && distance < attackRange) 
+	{
+		// Primary: standard homing missile
+		const standardCastTime = getMissileCastTime(STANDARD_CONFIG);
+		if (isSafeToAttack(threats, standardCastTime)) 
+		{
+			return {
+				move,
+				startCast: {
+					spell: 'missile',
+					config: STANDARD_CONFIG,
+					missileAI: StormchaserMissileAI,
+					direction: angleTo(state.position, enemy.position),
+				},
+			};
+		}
+
+		// Fallback: quick missile under pressure (shorter cast = smaller vulnerability window)
+		const quickCastTime = getMissileCastTime(QUICK_CONFIG);
+		if (isSafeToAttack(threats, quickCastTime)) 
+		{
+			return {
+				move,
+				startCast: {
+					spell: 'missile',
+					config: QUICK_CONFIG,
+					missileAI: StormchaserMissileAI,
+					direction: angleTo(state.position, enemy.position),
+				},
+			};
+		}
+
+		// Not safe to attack — wait for threat to pass, then fire
+	}
+
+	// === FALLBACK DEFENSE: Shield when no attack window exists ===
+	// If all offense checks failed and there's an undodgeable threat, shield it
+	// rather than sitting idle and taking the hit.
+	if (
+		state.state === 'idle' &&
+    urgentThreat &&
+    !urgentThreat.bestDodgeDirection &&
+    urgentThreat.canBlockInTime &&
+    urgentThreat.ticksToStartShield <= 3
+	) 
+	{
+		return {
+			move: {x: 0, y: 0},
+			startCast: {spell: 'shield'},
+		};
+	}
+
+	// Default: just move (dodging/positioning)
+	return {move};
+};