@vibemancer/core 0.1.0 → 0.1.1

package/src/bots/melee/02_Nightblade.ts

@@ -1,437 +1,437 @@
-import {WizardFunction} from '../../types.js';
-import {distanceTo} from '../../utils/distance.js';
-import {angleTo} from '../../utils/angles.js';
-import {ARENA_SIZE, GCD_DURATION, SHIELD_CAST_TIME} from '../../rules.js';
-import {
-	getThreats,
-	getMostUrgentThreat,
-	getDodgeDirectionForMovement,
-	getBlinkToDecreaseDistance,
-	shouldForceShield,
-	fitMissileToBudget,
-	MAX_CAST_BUDGET,
-	MIN_USEFUL_DAMAGE,
-} from '../shared.js';
-import {useParam} from '../../engine/params-runtime.js';
-const WALL_BUFFER = 50;
-const SHIELD_BUFFER = 3;
-
-/**
- * Aggressive movement: dodge missiles, close distance, light strafe.
- */
-function aggressiveMove(
-	position: {x: number; y: number},
-	enemy: {position: {x: number; y: number}},
-	currentDistance: number,
-	dodgeDirection: {x: number; y: number} | null,
-	tick: number,
-	strafeCyclePeriod: number,
-	strafeIntensity: number,
-	approachSpeed: 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;
-
-	const strafeClockwise = {
-		x: -deltaY / normalizedDistance,
-		y: deltaX / normalizedDistance,
-	};
-	const strafeCounterClockwise = {
-		x: deltaY / normalizedDistance,
-		y: -deltaX / normalizedDistance,
-	};
-
-	let strafeDirection: {x: number; y: number};
-
-	if (dodgeDirection) 
-	{
-		strafeDirection = dodgeDirection;
-	}
-	else if (
-		position.x < WALL_BUFFER ||
-    position.x > ARENA_SIZE - WALL_BUFFER ||
-    position.y < WALL_BUFFER ||
-    position.y > ARENA_SIZE - WALL_BUFFER
-	) 
-	{
-		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;
-	}
-	else 
-	{
-		const cycle = Math.floor(tick / strafeCyclePeriod) % 2;
-		strafeDirection = cycle === 0 ? strafeClockwise : strafeCounterClockwise;
-	}
-
-	// When actively dodging, commit fully
-	if (dodgeDirection) 
-	{
-		return {x: strafeDirection.x * 100, y: strafeDirection.y * 100};
-	}
-
-	// Light strafe + aggressive closing
-	let moveX = strafeDirection.x * strafeIntensity;
-	let moveY = strafeDirection.y * strafeIntensity;
-
-	// Always close distance aggressively
-	moveX += (deltaX / normalizedDistance) * approachSpeed;
-	moveY += (deltaY / normalizedDistance) * approachSpeed;
-
-	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: Nightblade
- *
- * BEHAVIOR: Enhanced melee assassin. Same aggressive engagement as Shadowblade —
- * blinks directly to the enemy and stabs for 15 damage (2-hit kill). The tier 2
- * upgrade is PREEMPTIVE DEFENSE: Nightblade watches the enemy's cast bar and
- * shields before a point-blank missile is even launched. At melee range, missiles
- * arrive almost instantly after launch — too fast to react. Nightblade anticipates
- * the threat. Also has emergency blink and proper channeling management.
- *
- * PROGRESSION LINE: Shadowblade → Nightblade → Voidblade
- * - Shadowblade (tier 1): Offensive blink, melee stabs, basic shield (reactive only)
- * - Nightblade (tier 2): + preemptive shield vs enemy casts, emergency blink
- * - Voidblade (tier 3): Future — perfect assassination timing, inescapable engages
- *
- * TIER: 2 (enhanced Shadowblade)
- */
-export const Nightblade: WizardFunction = ({state}) => 
-{
-	const stabRange = useParam('stabRange', 263, {range: 38, min: 0, steps: 5});
-	const stabRangeVsCasting = stabRange + 20;
-	const preemptiveShieldRange = useParam('preemptiveShieldRange', 261, {
-		range: 85,
-		min: 0,
-		steps: 7,
-	});
-	const acceptHitFraction = useParam('acceptHitFraction', 0, {
-		range: 0.2,
-		min: 0,
-		max: 1,
-		steps: 5,
-	});
-	const minTurnRate = useParam('minTurnRate', -11.4, {range: 5.25, steps: 5});
-	const strafeCyclePeriod = useParam('strafeCyclePeriod', 300, {
-		range: 75,
-		min: 80,
-		max: 300,
-	});
-	const strafeIntensity = useParam('strafeIntensity', 22, {
-		range: 30,
-		min: 10,
-		max: 80,
-		steps: 7,
-	});
-	const approachSpeed = useParam('approachSpeed', 92, {
-		range: 20,
-		min: 50,
-		max: 100,
-		steps: 7,
-	});
-	const shieldCancelThreshold = useParam('shieldCancelThreshold', 50, {
-		range: 75,
-		min: 50,
-		max: 300,
-	});
-	const blinkWindowMax = useParam('blinkWindowMax', 19, {
-		range: 30,
-		min: 15,
-		max: 80,
-		steps: 7,
-	});
-	const flightTimeDivisor = useParam('flightTimeDivisor', 12, {
-		range: 4,
-		min: 2,
-		max: 12,
-		steps: 5,
-	});
-	const enemyFiringSoonThreshold = useParam('enemyFiringSoonThreshold', 50, {
-		range: 30,
-		min: 10,
-		max: 100,
-		steps: 7,
-	});
-	const meleeAbortRange = useParam('meleeAbortRange', 200, {
-		range: 50,
-		min: 50,
-		max: 200,
-		steps: 7,
-	});
-
-	const enemy = state.enemies[0];
-	if (!enemy) 
-	{
-		return {move: {x: 0, y: 0}};
-	}
-
-	const distance = distanceTo(state.position, enemy.position);
-
-	const threats = getThreats(state);
-	const urgentThreat = getMostUrgentThreat(threats);
-
-	const dodgeDirection = getDodgeDirectionForMovement(threats, state.position);
-	const move = aggressiveMove(
-		state.position,
-		enemy,
-		distance,
-		dodgeDirection,
-		state.tick,
-		strafeCyclePeriod,
-		strafeIntensity,
-		approachSpeed,
-	);
-
-	// === DEFENSE: Handle channeling ===
-	if (state.state === 'channeling') 
-	{
-		// Keep shield up if enemy is about to fire at close range (preemptive shield scenario)
-		const enemyFiringSoon =
-			distance < preemptiveShieldRange &&
-      enemy.state === 'casting' &&
-      enemy.castingSpell === 'missile' &&
-      (enemy.castDuration ?? 0) -
-        (enemy.castProgress ?? 0) +
-        distance / flightTimeDivisor <
-        enemyFiringSoonThreshold;
-		if (
-			(!urgentThreat && !enemyFiringSoon) ||
-      (urgentThreat && urgentThreat.ticksToImpact > shieldCancelThreshold)
-		) 
-		{
-			return {move, cancel: true};
-		}
-		return {move: {x: 0, y: 0}};
-	}
-
-	// === DEFENSE: Cancel missile cast for LETHAL incoming damage ===
-	// DPS trade: we accepted the hit when we started casting. Only cancel to survive.
-	if (
-		state.state === 'casting' &&
-    state.castingSpell === 'missile' &&
-    urgentThreat &&
-    urgentThreat.projectile.damage >= state.health
-	) 
-	{
-		const remainingCast = (state.castDuration ?? 0) - (state.castProgress ?? 0);
-		if (
-			urgentThreat.ticksToImpact <=
-      remainingCast + GCD_DURATION + SHIELD_CAST_TIME + SHIELD_BUFFER
-		) 
-		{
-			return {move, cancel: true};
-		}
-	}
-
-	// === CANCEL: Abort melee cast if target escaped (non-homing missile won't reach) ===
-	// Melee missiles are non-homing with short range (~63u). If the enemy blinked away,
-	// continuing the cast is wasted time while we're vulnerable.
-	if (
-		state.state === 'casting' &&
-    state.castingSpell === 'missile' &&
-    distance > meleeAbortRange
-	) 
-	{
-		return {move, cancel: true};
-	}
-
-	// === BLINK: Dodge missile + close gap simultaneously (first priority) ===
-	// Blink both dodges the incoming missile AND closes distance — better than shielding.
-	// Only shield when blink is on cooldown.
-	if (
-		state.state === 'idle' &&
-    urgentThreat &&
-    state.blinkCooldown === 0 &&
-    distance > stabRange &&
-    urgentThreat.ticksToImpact >= 10 &&
-    urgentThreat.ticksToImpact <= blinkWindowMax
-	) 
-	{
-		const blinkTarget =
-			getBlinkToDecreaseDistance(
-				state.position,
-				enemy.position,
-				state.projectiles,
-			) ?? enemy.position;
-		return {
-			move: {x: 0, y: 0},
-			startCast: {spell: 'blink', target: blinkTarget},
-		};
-	}
-
-	// === DEFENSE: Shield lethal/high-damage undodgeable threats — survival over offense ===
-	if (
-		state.state === 'idle' &&
-    urgentThreat &&
-    (!urgentThreat.bestDodgeDirection || shouldForceShield(urgentThreat)) &&
-    urgentThreat.projectile.damage >= state.health &&
-    urgentThreat.canBlockInTime
-	) 
-	{
-		return {
-			move: {x: 0, y: 0},
-			startCast: {spell: 'shield'},
-		};
-	}
-
-	// === OFFENSE: Budget-based melee stab when close enough ===
-	// Tier 2 upgrade: fits the highest-damage stab into the available time window
-	// before needing to shield. Also stabs from farther when enemy is casting/channeling
-	// (they move at 0.5 or 0 speed, so the cast delay doesn't let them dodge).
-	const effectiveStabRange =
-		enemy.state === 'casting' || enemy.state === 'channeling'
-			? stabRangeVsCasting
-			: stabRange;
-	// Skip offense when a lethal missile could reach us during cast+GCD — dodge at full speed instead
-	const myProjectileIds = new Set(state.myProjectiles.map((p) => p.id));
-	const hasNearbyLethalMissile = state.projectiles.some(
-		(p) =>
-			!myProjectileIds.has(p.id) &&
-      p.damage >= state.health &&
-      distanceTo(state.position, p.position) / p.speed <
-        MAX_CAST_BUDGET + GCD_DURATION,
-	);
-	if (
-		state.state === 'idle' &&
-    distance < effectiveStabRange &&
-    !hasNearbyLethalMissile
-	) 
-	{
-		let nextThreatTime = urgentThreat?.ticksToImpact ?? Infinity;
-
-		// Account for enemy's active cast — their missile will arrive after cast completes + flight time
-		if (enemy.state === 'casting' && enemy.castingSpell === 'missile') 
-		{
-			const remainingEnemyCast =
-				(enemy.castDuration ?? 0) - (enemy.castProgress ?? 0);
-			const estimatedFlightTime = distance / flightTimeDivisor;
-			nextThreatTime = Math.min(
-				nextThreatTime,
-				remainingEnemyCast + estimatedFlightTime,
-			);
-		}
-
-		const safeBudget =
-			nextThreatTime - GCD_DURATION - SHIELD_CAST_TIME - SHIELD_BUFFER;
-		const budgetTicks = Math.min(safeBudget, MAX_CAST_BUDGET);
-		const enemyHP = Math.ceil(enemy.health);
-		const minDmg = Math.min(MIN_USEFUL_DAMAGE, enemyHP);
-		let config = fitMissileToBudget(budgetTicks, distance, {
-			minTurnRate,
-			maxDamage: enemyHP,
-			lastMissileConfig: state.lastMissileConfig,
-		});
-
-		// If budget too small for useful stab, fire bigger and accept the hit
-		// Only accept small hits (< 25% HP) — don't trade away large chunks of health
-		// Never accept when enemy is actively casting (their missile WILL arrive during our long cast)
-		const enemyCasting =
-			enemy.state === 'casting' && enemy.castingSpell === 'missile';
-		if (
-			(!config || config.damage < minDmg) &&
-      !enemyCasting &&
-      (!urgentThreat ||
-        urgentThreat.projectile.damage < state.health * acceptHitFraction)
-		) 
-		{
-			config = fitMissileToBudget(MAX_CAST_BUDGET, distance, {
-				minTurnRate,
-				maxDamage: enemyHP,
-				lastMissileConfig: state.lastMissileConfig,
-			});
-		}
-
-		if (config) 
-		{
-			return {
-				move,
-				startCast: {
-					spell: 'missile',
-					config,
-					missileAI: () => ({}),
-					direction: angleTo(state.position, enemy.position),
-				},
-			};
-		}
-	}
-
-	// === DEFENSE: Shield undodgeable or high-damage homing threats (only when blink can't handle it) ===
-	if (
-		state.state === 'idle' &&
-    urgentThreat &&
-    (!urgentThreat.bestDodgeDirection || shouldForceShield(urgentThreat))
-	) 
-	{
-		if (
-			urgentThreat.canBlockInTime &&
-      (state.blinkCooldown > 0 || urgentThreat.ticksToImpact < 10)
-		) 
-		{
-			return {
-				move: {x: 0, y: 0},
-				startCast: {spell: 'shield'},
-			};
-		}
-	}
-
-	// === DEFENSE: Preemptive shield when enemy is casting a missile at close range ===
-	// At melee range, missiles arrive almost instantly after launch — too fast to react.
-	// Shield BEFORE the missile launches. Trigger when shield will finish BEFORE missile hits.
-	if (
-		state.state === 'idle' &&
-    distance < preemptiveShieldRange &&
-    enemy.state === 'casting' &&
-    enemy.castingSpell === 'missile'
-	) 
-	{
-		const remainingCast = (enemy.castDuration ?? 0) - (enemy.castProgress ?? 0);
-		const estimatedFlightTicks = distance / flightTimeDivisor;
-		const ticksUntilHit = remainingCast + estimatedFlightTicks;
-		// Shield when hit is close enough that we MUST start now, but far enough that
-		// the shield finishes in time. The window: SHIELD_CAST_TIME <= ticksUntilHit < SHIELD_CAST_TIME+15
-		if (
-			ticksUntilHit >= SHIELD_CAST_TIME &&
-      ticksUntilHit < SHIELD_CAST_TIME + 15
-		) 
-		{
-			return {
-				move: {x: 0, y: 0},
-				startCast: {spell: 'shield'},
-			};
-		}
-	}
-
-	return {move};
-};
+import {WizardFunction} from '../../types.js';
+import {distanceTo} from '../../utils/distance.js';
+import {angleTo} from '../../utils/angles.js';
+import {ARENA_SIZE, GCD_DURATION, SHIELD_CAST_TIME} from '../../rules.js';
+import {
+	getThreats,
+	getMostUrgentThreat,
+	getDodgeDirectionForMovement,
+	getBlinkToDecreaseDistance,
+	shouldForceShield,
+	fitMissileToBudget,
+	MAX_CAST_BUDGET,
+	MIN_USEFUL_DAMAGE,
+} from '../shared.js';
+import {useParam} from '../../engine/params-runtime.js';
+const WALL_BUFFER = 50;
+const SHIELD_BUFFER = 3;
+
+/**
+ * Aggressive movement: dodge missiles, close distance, light strafe.
+ */
+function aggressiveMove(
+	position: {x: number; y: number},
+	enemy: {position: {x: number; y: number}},
+	currentDistance: number,
+	dodgeDirection: {x: number; y: number} | null,
+	tick: number,
+	strafeCyclePeriod: number,
+	strafeIntensity: number,
+	approachSpeed: 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;
+
+	const strafeClockwise = {
+		x: -deltaY / normalizedDistance,
+		y: deltaX / normalizedDistance,
+	};
+	const strafeCounterClockwise = {
+		x: deltaY / normalizedDistance,
+		y: -deltaX / normalizedDistance,
+	};
+
+	let strafeDirection: {x: number; y: number};
+
+	if (dodgeDirection) 
+	{
+		strafeDirection = dodgeDirection;
+	}
+	else if (
+		position.x < WALL_BUFFER ||
+    position.x > ARENA_SIZE - WALL_BUFFER ||
+    position.y < WALL_BUFFER ||
+    position.y > ARENA_SIZE - WALL_BUFFER
+	) 
+	{
+		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;
+	}
+	else 
+	{
+		const cycle = Math.floor(tick / strafeCyclePeriod) % 2;
+		strafeDirection = cycle === 0 ? strafeClockwise : strafeCounterClockwise;
+	}
+
+	// When actively dodging, commit fully
+	if (dodgeDirection) 
+	{
+		return {x: strafeDirection.x * 100, y: strafeDirection.y * 100};
+	}
+
+	// Light strafe + aggressive closing
+	let moveX = strafeDirection.x * strafeIntensity;
+	let moveY = strafeDirection.y * strafeIntensity;
+
+	// Always close distance aggressively
+	moveX += (deltaX / normalizedDistance) * approachSpeed;
+	moveY += (deltaY / normalizedDistance) * approachSpeed;
+
+	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: Nightblade
+ *
+ * BEHAVIOR: Enhanced melee assassin. Same aggressive engagement as Shadowblade —
+ * blinks directly to the enemy and stabs for 15 damage (2-hit kill). The tier 2
+ * upgrade is PREEMPTIVE DEFENSE: Nightblade watches the enemy's cast bar and
+ * shields before a point-blank missile is even launched. At melee range, missiles
+ * arrive almost instantly after launch — too fast to react. Nightblade anticipates
+ * the threat. Also has emergency blink and proper channeling management.
+ *
+ * PROGRESSION LINE: Shadowblade → Nightblade → Voidblade
+ * - Shadowblade (tier 1): Offensive blink, melee stabs, basic shield (reactive only)
+ * - Nightblade (tier 2): + preemptive shield vs enemy casts, emergency blink
+ * - Voidblade (tier 3): Future — perfect assassination timing, inescapable engages
+ *
+ * TIER: 2 (enhanced Shadowblade)
+ */
+export const Nightblade: WizardFunction = ({state}) => 
+{
+	const stabRange = useParam('stabRange', 263, {range: 38, min: 0, steps: 5});
+	const stabRangeVsCasting = stabRange + 20;
+	const preemptiveShieldRange = useParam('preemptiveShieldRange', 261, {
+		range: 85,
+		min: 0,
+		steps: 7,
+	});
+	const acceptHitFraction = useParam('acceptHitFraction', 0, {
+		range: 0.2,
+		min: 0,
+		max: 1,
+		steps: 5,
+	});
+	const minTurnRate = useParam('minTurnRate', -11.4, {range: 5.25, steps: 5});
+	const strafeCyclePeriod = useParam('strafeCyclePeriod', 300, {
+		range: 75,
+		min: 80,
+		max: 300,
+	});
+	const strafeIntensity = useParam('strafeIntensity', 22, {
+		range: 30,
+		min: 10,
+		max: 80,
+		steps: 7,
+	});
+	const approachSpeed = useParam('approachSpeed', 92, {
+		range: 20,
+		min: 50,
+		max: 100,
+		steps: 7,
+	});
+	const shieldCancelThreshold = useParam('shieldCancelThreshold', 50, {
+		range: 75,
+		min: 50,
+		max: 300,
+	});
+	const blinkWindowMax = useParam('blinkWindowMax', 19, {
+		range: 30,
+		min: 15,
+		max: 80,
+		steps: 7,
+	});
+	const flightTimeDivisor = useParam('flightTimeDivisor', 12, {
+		range: 4,
+		min: 2,
+		max: 12,
+		steps: 5,
+	});
+	const enemyFiringSoonThreshold = useParam('enemyFiringSoonThreshold', 50, {
+		range: 30,
+		min: 10,
+		max: 100,
+		steps: 7,
+	});
+	const meleeAbortRange = useParam('meleeAbortRange', 200, {
+		range: 50,
+		min: 50,
+		max: 200,
+		steps: 7,
+	});
+
+	const enemy = state.enemies[0];
+	if (!enemy) 
+	{
+		return {move: {x: 0, y: 0}};
+	}
+
+	const distance = distanceTo(state.position, enemy.position);
+
+	const threats = getThreats(state);
+	const urgentThreat = getMostUrgentThreat(threats);
+
+	const dodgeDirection = getDodgeDirectionForMovement(threats, state.position);
+	const move = aggressiveMove(
+		state.position,
+		enemy,
+		distance,
+		dodgeDirection,
+		state.tick,
+		strafeCyclePeriod,
+		strafeIntensity,
+		approachSpeed,
+	);
+
+	// === DEFENSE: Handle channeling ===
+	if (state.state === 'channeling') 
+	{
+		// Keep shield up if enemy is about to fire at close range (preemptive shield scenario)
+		const enemyFiringSoon =
+			distance < preemptiveShieldRange &&
+      enemy.state === 'casting' &&
+      enemy.castingSpell === 'missile' &&
+      (enemy.castDuration ?? 0) -
+        (enemy.castProgress ?? 0) +
+        distance / flightTimeDivisor <
+        enemyFiringSoonThreshold;
+		if (
+			(!urgentThreat && !enemyFiringSoon) ||
+      (urgentThreat && urgentThreat.ticksToImpact > shieldCancelThreshold)
+		) 
+		{
+			return {move, cancel: true};
+		}
+		return {move: {x: 0, y: 0}};
+	}
+
+	// === DEFENSE: Cancel missile cast for LETHAL incoming damage ===
+	// DPS trade: we accepted the hit when we started casting. Only cancel to survive.
+	if (
+		state.state === 'casting' &&
+    state.castingSpell === 'missile' &&
+    urgentThreat &&
+    urgentThreat.projectile.damage >= state.health
+	) 
+	{
+		const remainingCast = (state.castDuration ?? 0) - (state.castProgress ?? 0);
+		if (
+			urgentThreat.ticksToImpact <=
+      remainingCast + GCD_DURATION + SHIELD_CAST_TIME + SHIELD_BUFFER
+		) 
+		{
+			return {move, cancel: true};
+		}
+	}
+
+	// === CANCEL: Abort melee cast if target escaped (non-homing missile won't reach) ===
+	// Melee missiles are non-homing with short range (~63u). If the enemy blinked away,
+	// continuing the cast is wasted time while we're vulnerable.
+	if (
+		state.state === 'casting' &&
+    state.castingSpell === 'missile' &&
+    distance > meleeAbortRange
+	) 
+	{
+		return {move, cancel: true};
+	}
+
+	// === BLINK: Dodge missile + close gap simultaneously (first priority) ===
+	// Blink both dodges the incoming missile AND closes distance — better than shielding.
+	// Only shield when blink is on cooldown.
+	if (
+		state.state === 'idle' &&
+    urgentThreat &&
+    state.blinkCooldown === 0 &&
+    distance > stabRange &&
+    urgentThreat.ticksToImpact >= 10 &&
+    urgentThreat.ticksToImpact <= blinkWindowMax
+	) 
+	{
+		const blinkTarget =
+			getBlinkToDecreaseDistance(
+				state.position,
+				enemy.position,
+				state.projectiles,
+			) ?? enemy.position;
+		return {
+			move: {x: 0, y: 0},
+			startCast: {spell: 'blink', target: blinkTarget},
+		};
+	}
+
+	// === DEFENSE: Shield lethal/high-damage undodgeable threats — survival over offense ===
+	if (
+		state.state === 'idle' &&
+    urgentThreat &&
+    (!urgentThreat.bestDodgeDirection || shouldForceShield(urgentThreat)) &&
+    urgentThreat.projectile.damage >= state.health &&
+    urgentThreat.canBlockInTime
+	) 
+	{
+		return {
+			move: {x: 0, y: 0},
+			startCast: {spell: 'shield'},
+		};
+	}
+
+	// === OFFENSE: Budget-based melee stab when close enough ===
+	// Tier 2 upgrade: fits the highest-damage stab into the available time window
+	// before needing to shield. Also stabs from farther when enemy is casting/channeling
+	// (they move at 0.5 or 0 speed, so the cast delay doesn't let them dodge).
+	const effectiveStabRange =
+		enemy.state === 'casting' || enemy.state === 'channeling'
+			? stabRangeVsCasting
+			: stabRange;
+	// Skip offense when a lethal missile could reach us during cast+GCD — dodge at full speed instead
+	const myProjectileIds = new Set(state.myProjectiles.map((p) => p.id));
+	const hasNearbyLethalMissile = state.projectiles.some(
+		(p) =>
+			!myProjectileIds.has(p.id) &&
+      p.damage >= state.health &&
+      distanceTo(state.position, p.position) / p.speed <
+        MAX_CAST_BUDGET + GCD_DURATION,
+	);
+	if (
+		state.state === 'idle' &&
+    distance < effectiveStabRange &&
+    !hasNearbyLethalMissile
+	) 
+	{
+		let nextThreatTime = urgentThreat?.ticksToImpact ?? Infinity;
+
+		// Account for enemy's active cast — their missile will arrive after cast completes + flight time
+		if (enemy.state === 'casting' && enemy.castingSpell === 'missile') 
+		{
+			const remainingEnemyCast =
+				(enemy.castDuration ?? 0) - (enemy.castProgress ?? 0);
+			const estimatedFlightTime = distance / flightTimeDivisor;
+			nextThreatTime = Math.min(
+				nextThreatTime,
+				remainingEnemyCast + estimatedFlightTime,
+			);
+		}
+
+		const safeBudget =
+			nextThreatTime - GCD_DURATION - SHIELD_CAST_TIME - SHIELD_BUFFER;
+		const budgetTicks = Math.min(safeBudget, MAX_CAST_BUDGET);
+		const enemyHP = Math.ceil(enemy.health);
+		const minDmg = Math.min(MIN_USEFUL_DAMAGE, enemyHP);
+		let config = fitMissileToBudget(budgetTicks, distance, {
+			minTurnRate,
+			maxDamage: enemyHP,
+			lastMissileConfig: state.lastMissileConfig,
+		});
+
+		// If budget too small for useful stab, fire bigger and accept the hit
+		// Only accept small hits (< 25% HP) — don't trade away large chunks of health
+		// Never accept when enemy is actively casting (their missile WILL arrive during our long cast)
+		const enemyCasting =
+			enemy.state === 'casting' && enemy.castingSpell === 'missile';
+		if (
+			(!config || config.damage < minDmg) &&
+      !enemyCasting &&
+      (!urgentThreat ||
+        urgentThreat.projectile.damage < state.health * acceptHitFraction)
+		) 
+		{
+			config = fitMissileToBudget(MAX_CAST_BUDGET, distance, {
+				minTurnRate,
+				maxDamage: enemyHP,
+				lastMissileConfig: state.lastMissileConfig,
+			});
+		}
+
+		if (config) 
+		{
+			return {
+				move,
+				startCast: {
+					spell: 'missile',
+					config,
+					missileAI: () => ({}),
+					direction: angleTo(state.position, enemy.position),
+				},
+			};
+		}
+	}
+
+	// === DEFENSE: Shield undodgeable or high-damage homing threats (only when blink can't handle it) ===
+	if (
+		state.state === 'idle' &&
+    urgentThreat &&
+    (!urgentThreat.bestDodgeDirection || shouldForceShield(urgentThreat))
+	) 
+	{
+		if (
+			urgentThreat.canBlockInTime &&
+      (state.blinkCooldown > 0 || urgentThreat.ticksToImpact < 10)
+		) 
+		{
+			return {
+				move: {x: 0, y: 0},
+				startCast: {spell: 'shield'},
+			};
+		}
+	}
+
+	// === DEFENSE: Preemptive shield when enemy is casting a missile at close range ===
+	// At melee range, missiles arrive almost instantly after launch — too fast to react.
+	// Shield BEFORE the missile launches. Trigger when shield will finish BEFORE missile hits.
+	if (
+		state.state === 'idle' &&
+    distance < preemptiveShieldRange &&
+    enemy.state === 'casting' &&
+    enemy.castingSpell === 'missile'
+	) 
+	{
+		const remainingCast = (enemy.castDuration ?? 0) - (enemy.castProgress ?? 0);
+		const estimatedFlightTicks = distance / flightTimeDivisor;
+		const ticksUntilHit = remainingCast + estimatedFlightTicks;
+		// Shield when hit is close enough that we MUST start now, but far enough that
+		// the shield finishes in time. The window: SHIELD_CAST_TIME <= ticksUntilHit < SHIELD_CAST_TIME+15
+		if (
+			ticksUntilHit >= SHIELD_CAST_TIME &&
+      ticksUntilHit < SHIELD_CAST_TIME + 15
+		) 
+		{
+			return {
+				move: {x: 0, y: 0},
+				startCast: {spell: 'shield'},
+			};
+		}
+	}
+
+	return {move};
+};