@vibemancer/core 0.1.0 → 0.1.2

package/src/bots/defensive/03_Golem.ts

@@ -1,357 +1,357 @@
-import {WizardFunction, MissileAIFunction} from '../../types.js';
-import {distanceTo} from '../../utils/distance.js';
-import {angleTo} from '../../utils/angles.js';
-import {
-	GCD_DURATION,
-	SHIELD_CAST_TIME,
-	BLINK_CAST_TIME,
-} from '../../rules.js';
-import {getMissileCastTime, getLeadPosition} from '../../utils/combat.js';
-import {
-	getThreats,
-	getMostUrgentThreat,
-	getBlinkToCenter,
-	fitMissileToBudget,
-	isSafeToAttack,
-	MAX_CAST_BUDGET,
-	MIN_USEFUL_DAMAGE,
-	getEnemyVulnerabilityTicks,
-} from '../shared.js';
-import {useParam} from '../../engine/params-runtime.js';
-
-const SHIELD_BUFFER = 3;
-const SHIELD_HOLD_TICKS = 5;
-
-/**
- * Standard homing missile AI — tracks enemy position.
- */
-const HomingAI: MissileAIFunction = ({worldState}) => 
-{
-	const enemy = worldState.enemies[0];
-	return {turnToward: enemy?.position};
-};
-
-/**
- * Straight missile AI — no homing, flies in initial direction.
- */
-const StraightAI: MissileAIFunction = () => ({});
-
-/**
- * Bot: Golem
- *
- * BEHAVIOR: Stationary fortress with perfect shield timing and devastating
- * counterattacks during enemy vulnerability windows. Reads enemy cast/GCD
- * state to time punish missiles that land when the enemy can't shield.
- * Handles multi-missile volleys by holding shield through consecutive impacts.
- * Uses progressive cast-cancel thresholds for optimal damage trading.
- *
- * KEY IMPROVEMENTS OVER SENTINEL:
- * - Counterattack punish: fires during enemy cast/GCD recovery
- * - Multi-threat volley awareness: holds shield through consecutive hits
- * - Progressive cast-cancel: graduated damage thresholds
- * - Perfect shield timing: uses ticksToStartShield precisely
- *
- * PROGRESSION LINE: Turtle → Sentinel → Golem
- * TIER: 3 (elite Defensive line)
- */
-export const Golem: WizardFunction = ({state}) => 
-{
-	// Positive turn rate ensures homing missiles that hit moving targets.
-	// Hardcoded — optimizer incorrectly pushes this negative for stationary matchups.
-	const minTurnRate = 0.5;
-	const preemptiveShieldRange = useParam('preemptiveShieldRange', 150, {
-		range: 85,
-		min: 0,
-		steps: 7,
-	});
-	const shieldCancelThreshold = useParam('shieldCancelThreshold', 100, {
-		range: 75,
-		min: 10,
-	});
-	const punishMinVulnerability = useParam('punishMinVulnerability', 310, {
-		range: 30,
-		min: 10,
-		steps: 5,
-	});
-	const preferBlinkDodge =
-		useParam('preferBlinkDodge', 1, {min: 0, max: 1, steps: 2}) >= 0.5;
-	const cancelHeavyDmg = useParam('cancelHeavyDmg', 14, {
-		range: 15,
-		min: 5,
-		max: 40,
-		steps: 5,
-	});
-	const cancelMediumDmg = useParam('cancelMediumDmg', 12, {
-		range: 10,
-		min: 3,
-		max: 25,
-		steps: 5,
-	});
-	const cancelCastRatio = useParam('cancelCastRatio', 0.8, {
-		range: 0.4,
-		min: 0.3,
-		max: 1.0,
-		steps: 5,
-	});
-	const cancelLightDmg = useParam('cancelLightDmg', 8, {
-		range: 5,
-		min: 1,
-		max: 15,
-		steps: 5,
-	});
-	const cancelEarlyCastRatio = useParam('cancelEarlyCastRatio', 0.7, {
-		range: 0.3,
-		min: 0.0,
-		max: 0.7,
-		steps: 5,
-	});
-	const blinkWindowMax = useParam('blinkWindowMax', 50, {
-		range: 40,
-		min: 20,
-		max: 120,
-		steps: 7,
-	});
-	const preemptiveShieldBuffer = useParam('preemptiveShieldBuffer', 11.3, {
-		range: 5,
-		min: 0,
-		max: 15,
-		steps: 5,
-	});
-	const flightTimeDivisor = useParam('flightTimeDivisor', 9.5, {
-		range: 4,
-		min: 2,
-		max: 12,
-		steps: 5,
-	});
-
-	const enemy = state.enemies[0];
-	const threats = getThreats(state);
-	const urgentThreat = getMostUrgentThreat(threats);
-	const hittingThreats = threats.filter((t) => t.willHit);
-
-	// === STEP 1: CHANNELING — hold through volleys, cancel when safe ===
-	if (state.state === 'channeling' && state.channelingSpell === 'shield') 
-	{
-		// Hold if any missile is about to hit
-		const imminentThreat = hittingThreats.find(
-			(t) => t.ticksToImpact <= SHIELD_HOLD_TICKS,
-		);
-		if (imminentThreat) 
-		{
-			return {move: {x: 0, y: 0}};
-		}
-
-		// Hold if next threat will arrive before we can reshield
-		const nextHitting = hittingThreats[0];
-		const ticksToReshield = SHIELD_CAST_TIME + SHIELD_BUFFER;
-		if (nextHitting && nextHitting.ticksToImpact <= ticksToReshield) 
-		{
-			return {move: {x: 0, y: 0}};
-		}
-
-		// Cancel shield if no threat or threat is far enough
-		if (!nextHitting || nextHitting.ticksToImpact > shieldCancelThreshold) 
-		{
-			return {move: {x: 0, y: 0}, cancel: true};
-		}
-		return {move: {x: 0, y: 0}};
-	}
-
-	// If casting shield, let it finish
-	if (state.state === 'casting' && state.castingSpell === 'shield') 
-	{
-		return {move: {x: 0, y: 0}};
-	}
-
-	// === STEP 2: PROGRESSIVE CAST-CANCEL — evaluate damage tradeoff ===
-	if (
-		state.state === 'casting' &&
-    state.castingSpell === 'missile' &&
-    urgentThreat
-	) 
-	{
-		// Sentinel is stationary — can't dodge. Must always consider canceling.
-		const remainingCast = (state.castDuration ?? 0) - (state.castProgress ?? 0);
-		const defenseTime =
-			state.blinkCooldown === 0
-				? BLINK_CAST_TIME
-				: SHIELD_CAST_TIME + SHIELD_BUFFER;
-		const willArriveInWindow =
-			urgentThreat.ticksToImpact <= remainingCast + GCD_DURATION + defenseTime;
-
-		if (willArriveInWindow) 
-		{
-			const incomingDamage = urgentThreat.projectile.damage;
-			const castRatio = (state.castProgress ?? 0) / (state.castDuration ?? 1);
-
-			// Always cancel for lethal or heavy damage
-			if (incomingDamage >= state.health || incomingDamage >= cancelHeavyDmg) 
-			{
-				return {move: {x: 0, y: 0}, cancel: true};
-			}
-			// Significant damage + early/mid cast: cancel
-			if (incomingDamage >= cancelMediumDmg && castRatio < cancelCastRatio) 
-			{
-				return {move: {x: 0, y: 0}, cancel: true};
-			}
-			// Medium damage + very early cast: cancel
-			if (
-				incomingDamage >= cancelLightDmg &&
-        castRatio < cancelEarlyCastRatio
-			) 
-			{
-				return {move: {x: 0, y: 0}, cancel: true};
-			}
-		}
-	}
-
-	// === STEP 3: BLINK-DODGE — 100% damage avoidance (optimizer-controlled) ===
-	if (
-		preferBlinkDodge &&
-    state.state === 'idle' &&
-    urgentThreat &&
-    state.blinkCooldown === 0 &&
-    urgentThreat.ticksToImpact >= BLINK_CAST_TIME &&
-    urgentThreat.ticksToImpact <= blinkWindowMax
-	) 
-	{
-		return {
-			move: {x: 0, y: 0},
-			startCast: {spell: 'blink', target: getBlinkToCenter(state.position)},
-		};
-	}
-
-	// === STEP 3b: SHIELD — fallback when blink unavailable (90% block) ===
-	if (
-		state.state === 'idle' &&
-    urgentThreat &&
-    urgentThreat.canBlockInTime &&
-    urgentThreat.ticksToStartShield <= SHIELD_BUFFER
-	) 
-	{
-		return {
-			move: {x: 0, y: 0},
-			startCast: {spell: 'shield'},
-		};
-	}
-
-	// === STEP 4: PREEMPTIVE SHIELD — enemy casting at close range ===
-	if (
-		state.state === 'idle' &&
-    enemy &&
-    enemy.state === 'casting' &&
-    enemy.castingSpell === 'missile'
-	) 
-	{
-		const distance = distanceTo(state.position, enemy.position);
-		if (distance < preemptiveShieldRange) 
-		{
-			const remainingCast =
-				(enemy.castDuration ?? 0) - (enemy.castProgress ?? 0);
-			const estimatedFlightTicks = distance / flightTimeDivisor;
-			const ticksUntilHit = remainingCast + estimatedFlightTicks;
-			if (
-				ticksUntilHit <
-        SHIELD_CAST_TIME + SHIELD_BUFFER + preemptiveShieldBuffer
-			) 
-			{
-				return {
-					move: {x: 0, y: 0},
-					startCast: {spell: 'shield'},
-				};
-			}
-		}
-	}
-
-	// === STEP 5: OFFENSE — punish mode + standard counterattack ===
-	if (state.state === 'idle' && enemy) 
-	{
-		const offenseDefenseTime =
-			state.blinkCooldown === 0
-				? BLINK_CAST_TIME
-				: SHIELD_CAST_TIME + SHIELD_BUFFER;
-		const distance = distanceTo(state.position, enemy.position);
-		const enemyHP = Math.ceil(enemy.health);
-		const vulnerabilityTicks = getEnemyVulnerabilityTicks(enemy);
-
-		// --- PUNISH MODE: exploit enemy cast/GCD vulnerability ---
-		if (vulnerabilityTicks >= punishMinVulnerability) 
-		{
-			const flightTimeEstimate = distance / flightTimeDivisor;
-			const punishBudget = vulnerabilityTicks - flightTimeEstimate;
-			const nextThreatTime = urgentThreat?.ticksToImpact ?? Infinity;
-			const safeBudget = nextThreatTime - GCD_DURATION - offenseDefenseTime;
-			const effectiveBudget = Math.min(
-				punishBudget,
-				safeBudget,
-				MAX_CAST_BUDGET,
-			);
-
-			if (effectiveBudget > 0) 
-			{
-				const config = fitMissileToBudget(effectiveBudget, distance, {
-					minTurnRate: 0,
-					maxDamage: enemyHP,
-					lastMissileConfig: state.lastMissileConfig,
-				});
-
-				if (config && config.damage >= MIN_USEFUL_DAMAGE) 
-				{
-					const castTime = getMissileCastTime(config, state.lastMissileConfig);
-					const actualFlight = distance / config.speed;
-
-					if (
-						castTime + actualFlight < vulnerabilityTicks &&
-            isSafeToAttack(threats, castTime)
-					) 
-					{
-						const aimTarget =
-							config.turnRate > 0
-								? enemy.position
-								: getLeadPosition(
-									enemy.position,
-									enemy.velocity,
-									config.speed,
-									state.position,
-								);
-						return {
-							move: {x: 0, y: 0},
-							startCast: {
-								spell: 'missile',
-								config,
-								missileAI: config.turnRate > 0 ? HomingAI : StraightAI,
-								direction: angleTo(state.position, aimTarget),
-							},
-						};
-					}
-				}
-			}
-		}
-
-		// --- STANDARD MODE: adaptive homing in safe windows ---
-		const nextThreatTime = urgentThreat?.ticksToImpact ?? Infinity;
-		const safeBudget = nextThreatTime - GCD_DURATION - offenseDefenseTime;
-		const budgetTicks = Math.min(safeBudget, MAX_CAST_BUDGET);
-
-		const config = fitMissileToBudget(budgetTicks, distance, {
-			minTurnRate,
-			maxDamage: enemyHP,
-			lastMissileConfig: state.lastMissileConfig,
-		});
-
-		if (config && config.damage >= Math.min(MIN_USEFUL_DAMAGE, enemyHP)) 
-		{
-			return {
-				move: {x: 0, y: 0},
-				startCast: {
-					spell: 'missile',
-					config,
-					missileAI: config.turnRate > 0 ? HomingAI : StraightAI,
-					direction: angleTo(state.position, enemy.position),
-				},
-			};
-		}
-	}
-
-	return {move: {x: 0, y: 0}};
-};
+import {WizardFunction, MissileAIFunction} from '../../types.js';
+import {distanceTo} from '../../utils/distance.js';
+import {angleTo} from '../../utils/angles.js';
+import {
+	GCD_DURATION,
+	SHIELD_CAST_TIME,
+	BLINK_CAST_TIME,
+} from '../../rules.js';
+import {getMissileCastTime, getLeadPosition} from '../../utils/combat.js';
+import {
+	getThreats,
+	getMostUrgentThreat,
+	getBlinkToCenter,
+	fitMissileToBudget,
+	isSafeToAttack,
+	MAX_CAST_BUDGET,
+	MIN_USEFUL_DAMAGE,
+	getEnemyVulnerabilityTicks,
+} from '../shared.js';
+import {useParam} from '../../engine/params-runtime.js';
+
+const SHIELD_BUFFER = 3;
+const SHIELD_HOLD_TICKS = 5;
+
+/**
+ * Standard homing missile AI — tracks enemy position.
+ */
+const HomingAI: MissileAIFunction = ({worldState}) => 
+{
+	const enemy = worldState.enemies[0];
+	return {turnToward: enemy?.position};
+};
+
+/**
+ * Straight missile AI — no homing, flies in initial direction.
+ */
+const StraightAI: MissileAIFunction = () => ({});
+
+/**
+ * Bot: Golem
+ *
+ * BEHAVIOR: Stationary fortress with perfect shield timing and devastating
+ * counterattacks during enemy vulnerability windows. Reads enemy cast/GCD
+ * state to time punish missiles that land when the enemy can't shield.
+ * Handles multi-missile volleys by holding shield through consecutive impacts.
+ * Uses progressive cast-cancel thresholds for optimal damage trading.
+ *
+ * KEY IMPROVEMENTS OVER SENTINEL:
+ * - Counterattack punish: fires during enemy cast/GCD recovery
+ * - Multi-threat volley awareness: holds shield through consecutive hits
+ * - Progressive cast-cancel: graduated damage thresholds
+ * - Perfect shield timing: uses ticksToStartShield precisely
+ *
+ * PROGRESSION LINE: Turtle → Sentinel → Golem
+ * TIER: 3 (elite Defensive line)
+ */
+export const Golem: WizardFunction = ({state}) => 
+{
+	// Positive turn rate ensures homing missiles that hit moving targets.
+	// Hardcoded — optimizer incorrectly pushes this negative for stationary matchups.
+	const minTurnRate = 0.5;
+	const preemptiveShieldRange = useParam('preemptiveShieldRange', 150, {
+		range: 85,
+		min: 0,
+		steps: 7,
+	});
+	const shieldCancelThreshold = useParam('shieldCancelThreshold', 100, {
+		range: 75,
+		min: 10,
+	});
+	const punishMinVulnerability = useParam('punishMinVulnerability', 310, {
+		range: 30,
+		min: 10,
+		steps: 5,
+	});
+	const preferBlinkDodge =
+		useParam('preferBlinkDodge', 1, {min: 0, max: 1, steps: 2}) >= 0.5;
+	const cancelHeavyDmg = useParam('cancelHeavyDmg', 14, {
+		range: 15,
+		min: 5,
+		max: 40,
+		steps: 5,
+	});
+	const cancelMediumDmg = useParam('cancelMediumDmg', 12, {
+		range: 10,
+		min: 3,
+		max: 25,
+		steps: 5,
+	});
+	const cancelCastRatio = useParam('cancelCastRatio', 0.8, {
+		range: 0.4,
+		min: 0.3,
+		max: 1.0,
+		steps: 5,
+	});
+	const cancelLightDmg = useParam('cancelLightDmg', 8, {
+		range: 5,
+		min: 1,
+		max: 15,
+		steps: 5,
+	});
+	const cancelEarlyCastRatio = useParam('cancelEarlyCastRatio', 0.7, {
+		range: 0.3,
+		min: 0.0,
+		max: 0.7,
+		steps: 5,
+	});
+	const blinkWindowMax = useParam('blinkWindowMax', 50, {
+		range: 40,
+		min: 20,
+		max: 120,
+		steps: 7,
+	});
+	const preemptiveShieldBuffer = useParam('preemptiveShieldBuffer', 11.3, {
+		range: 5,
+		min: 0,
+		max: 15,
+		steps: 5,
+	});
+	const flightTimeDivisor = useParam('flightTimeDivisor', 9.5, {
+		range: 4,
+		min: 2,
+		max: 12,
+		steps: 5,
+	});
+
+	const enemy = state.enemies[0];
+	const threats = getThreats(state);
+	const urgentThreat = getMostUrgentThreat(threats);
+	const hittingThreats = threats.filter((t) => t.willHit);
+
+	// === STEP 1: CHANNELING — hold through volleys, cancel when safe ===
+	if (state.state === 'channeling' && state.channelingSpell === 'shield') 
+	{
+		// Hold if any missile is about to hit
+		const imminentThreat = hittingThreats.find(
+			(t) => t.ticksToImpact <= SHIELD_HOLD_TICKS,
+		);
+		if (imminentThreat) 
+		{
+			return {move: {x: 0, y: 0}};
+		}
+
+		// Hold if next threat will arrive before we can reshield
+		const nextHitting = hittingThreats[0];
+		const ticksToReshield = SHIELD_CAST_TIME + SHIELD_BUFFER;
+		if (nextHitting && nextHitting.ticksToImpact <= ticksToReshield) 
+		{
+			return {move: {x: 0, y: 0}};
+		}
+
+		// Cancel shield if no threat or threat is far enough
+		if (!nextHitting || nextHitting.ticksToImpact > shieldCancelThreshold) 
+		{
+			return {move: {x: 0, y: 0}, cancel: true};
+		}
+		return {move: {x: 0, y: 0}};
+	}
+
+	// If casting shield, let it finish
+	if (state.state === 'casting' && state.castingSpell === 'shield') 
+	{
+		return {move: {x: 0, y: 0}};
+	}
+
+	// === STEP 2: PROGRESSIVE CAST-CANCEL — evaluate damage tradeoff ===
+	if (
+		state.state === 'casting' &&
+    state.castingSpell === 'missile' &&
+    urgentThreat
+	) 
+	{
+		// Sentinel is stationary — can't dodge. Must always consider canceling.
+		const remainingCast = (state.castDuration ?? 0) - (state.castProgress ?? 0);
+		const defenseTime =
+			state.blinkCooldown === 0
+				? BLINK_CAST_TIME
+				: SHIELD_CAST_TIME + SHIELD_BUFFER;
+		const willArriveInWindow =
+			urgentThreat.ticksToImpact <= remainingCast + GCD_DURATION + defenseTime;
+
+		if (willArriveInWindow) 
+		{
+			const incomingDamage = urgentThreat.projectile.damage;
+			const castRatio = (state.castProgress ?? 0) / (state.castDuration ?? 1);
+
+			// Always cancel for lethal or heavy damage
+			if (incomingDamage >= state.health || incomingDamage >= cancelHeavyDmg) 
+			{
+				return {move: {x: 0, y: 0}, cancel: true};
+			}
+			// Significant damage + early/mid cast: cancel
+			if (incomingDamage >= cancelMediumDmg && castRatio < cancelCastRatio) 
+			{
+				return {move: {x: 0, y: 0}, cancel: true};
+			}
+			// Medium damage + very early cast: cancel
+			if (
+				incomingDamage >= cancelLightDmg &&
+        castRatio < cancelEarlyCastRatio
+			) 
+			{
+				return {move: {x: 0, y: 0}, cancel: true};
+			}
+		}
+	}
+
+	// === STEP 3: BLINK-DODGE — 100% damage avoidance (optimizer-controlled) ===
+	if (
+		preferBlinkDodge &&
+    state.state === 'idle' &&
+    urgentThreat &&
+    state.blinkCooldown === 0 &&
+    urgentThreat.ticksToImpact >= BLINK_CAST_TIME &&
+    urgentThreat.ticksToImpact <= blinkWindowMax
+	) 
+	{
+		return {
+			move: {x: 0, y: 0},
+			startCast: {spell: 'blink', target: getBlinkToCenter(state.position)},
+		};
+	}
+
+	// === STEP 3b: SHIELD — fallback when blink unavailable (90% block) ===
+	if (
+		state.state === 'idle' &&
+    urgentThreat &&
+    urgentThreat.canBlockInTime &&
+    urgentThreat.ticksToStartShield <= SHIELD_BUFFER
+	) 
+	{
+		return {
+			move: {x: 0, y: 0},
+			startCast: {spell: 'shield'},
+		};
+	}
+
+	// === STEP 4: PREEMPTIVE SHIELD — enemy casting at close range ===
+	if (
+		state.state === 'idle' &&
+    enemy &&
+    enemy.state === 'casting' &&
+    enemy.castingSpell === 'missile'
+	) 
+	{
+		const distance = distanceTo(state.position, enemy.position);
+		if (distance < preemptiveShieldRange) 
+		{
+			const remainingCast =
+				(enemy.castDuration ?? 0) - (enemy.castProgress ?? 0);
+			const estimatedFlightTicks = distance / flightTimeDivisor;
+			const ticksUntilHit = remainingCast + estimatedFlightTicks;
+			if (
+				ticksUntilHit <
+        SHIELD_CAST_TIME + SHIELD_BUFFER + preemptiveShieldBuffer
+			) 
+			{
+				return {
+					move: {x: 0, y: 0},
+					startCast: {spell: 'shield'},
+				};
+			}
+		}
+	}
+
+	// === STEP 5: OFFENSE — punish mode + standard counterattack ===
+	if (state.state === 'idle' && enemy) 
+	{
+		const offenseDefenseTime =
+			state.blinkCooldown === 0
+				? BLINK_CAST_TIME
+				: SHIELD_CAST_TIME + SHIELD_BUFFER;
+		const distance = distanceTo(state.position, enemy.position);
+		const enemyHP = Math.ceil(enemy.health);
+		const vulnerabilityTicks = getEnemyVulnerabilityTicks(enemy);
+
+		// --- PUNISH MODE: exploit enemy cast/GCD vulnerability ---
+		if (vulnerabilityTicks >= punishMinVulnerability) 
+		{
+			const flightTimeEstimate = distance / flightTimeDivisor;
+			const punishBudget = vulnerabilityTicks - flightTimeEstimate;
+			const nextThreatTime = urgentThreat?.ticksToImpact ?? Infinity;
+			const safeBudget = nextThreatTime - GCD_DURATION - offenseDefenseTime;
+			const effectiveBudget = Math.min(
+				punishBudget,
+				safeBudget,
+				MAX_CAST_BUDGET,
+			);
+
+			if (effectiveBudget > 0) 
+			{
+				const config = fitMissileToBudget(effectiveBudget, distance, {
+					minTurnRate: 0,
+					maxDamage: enemyHP,
+					lastMissileConfig: state.lastMissileConfig,
+				});
+
+				if (config && config.damage >= MIN_USEFUL_DAMAGE) 
+				{
+					const castTime = getMissileCastTime(config, state.lastMissileConfig);
+					const actualFlight = distance / config.speed;
+
+					if (
+						castTime + actualFlight < vulnerabilityTicks &&
+            isSafeToAttack(threats, castTime)
+					) 
+					{
+						const aimTarget =
+							config.turnRate > 0
+								? enemy.position
+								: getLeadPosition(
+									enemy.position,
+									enemy.velocity,
+									config.speed,
+									state.position,
+								);
+						return {
+							move: {x: 0, y: 0},
+							startCast: {
+								spell: 'missile',
+								config,
+								missileAI: config.turnRate > 0 ? HomingAI : StraightAI,
+								direction: angleTo(state.position, aimTarget),
+							},
+						};
+					}
+				}
+			}
+		}
+
+		// --- STANDARD MODE: adaptive homing in safe windows ---
+		const nextThreatTime = urgentThreat?.ticksToImpact ?? Infinity;
+		const safeBudget = nextThreatTime - GCD_DURATION - offenseDefenseTime;
+		const budgetTicks = Math.min(safeBudget, MAX_CAST_BUDGET);
+
+		const config = fitMissileToBudget(budgetTicks, distance, {
+			minTurnRate,
+			maxDamage: enemyHP,
+			lastMissileConfig: state.lastMissileConfig,
+		});
+
+		if (config && config.damage >= Math.min(MIN_USEFUL_DAMAGE, enemyHP)) 
+		{
+			return {
+				move: {x: 0, y: 0},
+				startCast: {
+					spell: 'missile',
+					config,
+					missileAI: config.turnRate > 0 ? HomingAI : StraightAI,
+					direction: angleTo(state.position, enemy.position),
+				},
+			};
+		}
+	}
+
+	return {move: {x: 0, y: 0}};
+};