@vibemancer/core 0.1.0 → 0.1.1

package/src/bots/duelist/03_Archmage.ts

@@ -1,588 +1,588 @@
-import {WizardFunction, MissileAIFunction} from '../../types.js';
-import {angleTo} from '../../utils/angles.js';
-import {distanceTo} from '../../utils/distance.js';
-import {
-	ARENA_SIZE,
-	GCD_DURATION,
-	SHIELD_CAST_TIME,
-	BLINK_CAST_TIME,
-} from '../../rules.js';
-import {getMissileCastTime, getLeadPosition} from '../../utils/combat.js';
-import {
-	getThreats,
-	getMostUrgentThreat,
-	getDodgeDirectionForMovement,
-	fitMissileToBudget,
-	getBlinkToDecreaseDistance,
-	getBlinkToIncreaseDistance,
-	shouldForceShield,
-	MIN_BLINK_ESCAPE_DISTANCE,
-	MAX_CAST_BUDGET,
-	MIN_USEFUL_DAMAGE,
-	getEnemyVulnerabilityTicks,
-	isSafeToAttack,
-} from '../shared.js';
-import {useParam} from '../../engine/params-runtime.js';
-
-const WALL_BUFFER = 60;
-const SHIELD_BUFFER = 3;
-
-const HomingAI: MissileAIFunction = ({worldState}) => 
-{
-	const enemy = worldState.enemies[0];
-	return {turnToward: enemy?.position};
-};
-
-const StraightAI: MissileAIFunction = () => ({});
-
-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;
-
-	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 (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;
-	}
-	else 
-	{
-		const cycle = Math.floor(tick / strafeCyclePeriod) % 2;
-		strafeDirection = cycle === 0 ? strafeClockwise : strafeCounterClockwise;
-	}
-
-	if (dodgeDirection) 
-	{
-		return {x: strafeDirection.x * 100, y: strafeDirection.y * 100};
-	}
-
-	let moveX = strafeDirection.x * strafeIntensity;
-	let moveY = strafeDirection.y * strafeIntensity;
-
-	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;
-	}
-
-	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: Archmage
- *
- * BEHAVIOR: Versatile duelist that adapts missile choice based on distance and HP.
- * Close range → straight missiles (no turn cost = more damage). Mid/far range → homing.
- * Uses dual-blink aggressively (gap-close during vulnerability, escape when trade is bad).
- * HP-aware: ahead → aggressive close range; behind → defensive ranged kiting.
- *
- * KEY IMPROVEMENTS OVER WARMAGE:
- * - Range-adaptive missiles: straight close, homing far
- * - Vulnerability-timed blinks: gap-close during enemy cast/GCD
- * - HP-aware aggression: adjusts distance + risk tolerance based on HP differential
- * - Progressive cast-cancel: graduated thresholds
- *
- * PROGRESSION LINE: Battlemage → Warmage → Archmage
- * TIER: 3 (elite Duelist line)
- */
-export const Archmage: WizardFunction = ({state}) => 
-{
-	const targetDistance = useParam('targetDistance', 214, {
-		range: 150,
-		min: 0,
-	});
-	const minTurnRate = useParam('minTurnRate', -14.6, {range: 1.5, steps: 5});
-	const blinkEscapeDistance = useParam('blinkEscapeDistance', 442, {
-		range: 190,
-		min: 0,
-		steps: 7,
-	});
-	const punishMinVulnerability = useParam('punishMinVulnerability', 85, {
-		range: 30,
-		min: 10,
-		steps: 5,
-	});
-	const aggressiveHPThreshold = useParam('aggressiveHPThreshold', 4, {
-		range: 20,
-		min: 0,
-		steps: 5,
-	});
-	const preferBlinkDodge =
-		useParam('preferBlinkDodge', 1, {min: 0, max: 1, steps: 2}) >= 0.5;
-	const strafeCyclePeriod = useParam('strafeCyclePeriod', 248, {
-		range: 75,
-		min: 80,
-		max: 250,
-	});
-	const strafeIntensity = useParam('strafeIntensity', 100, {
-		range: 40,
-		min: 20,
-		max: 100,
-		steps: 7,
-	});
-	const approachSpeed = useParam('approachSpeed', 57, {
-		range: 30,
-		min: 10,
-		max: 80,
-		steps: 7,
-	});
-	const distanceDeadZone = useParam('distanceDeadZone', 37, {
-		range: 30,
-		min: 10,
-		max: 80,
-		steps: 7,
-	});
-	const aggressiveDistanceOffset = useParam('aggressiveDistanceOffset', 99, {
-		range: 50,
-		min: 0,
-		max: 100,
-		steps: 7,
-	});
-	const cautiousDistanceOffset = useParam('cautiousDistanceOffset', 42, {
-		range: 50,
-		min: 0,
-		max: 120,
-		steps: 7,
-	});
-	const cancelHeavyDmg = useParam('cancelHeavyDmg', 40, {
-		range: 15,
-		min: 5,
-		max: 40,
-		steps: 5,
-	});
-	const cancelMediumDmg = useParam('cancelMediumDmg', 20, {
-		range: 10,
-		min: 3,
-		max: 25,
-		steps: 5,
-	});
-	const cancelCastRatio = useParam('cancelCastRatio', 0.74, {
-		range: 0.4,
-		min: 0.3,
-		max: 1.0,
-		steps: 5,
-	});
-	const shieldCancelThreshold = useParam('shieldCancelThreshold', 100, {
-		range: 75,
-		min: 50,
-		max: 300,
-	});
-	const blinkWindowMax = useParam('blinkWindowMax', 29, {
-		range: 40,
-		min: 20,
-		max: 120,
-		steps: 7,
-	});
-	const blinkGapThreshold = useParam('blinkGapThreshold', 80, {
-		range: 75,
-		min: 20,
-		max: 200,
-		steps: 7,
-	});
-	const flightTimeDivisor = useParam('flightTimeDivisor', 4.5, {
-		range: 4,
-		min: 2,
-		max: 12,
-		steps: 5,
-	});
-	const closeRangeStraightThreshold = useParam(
-		'closeRangeStraightThreshold',
-		50,
-		{range: 100, min: 50, max: 300, steps: 7},
-	);
-	const safeAttackCastEstimate = useParam('safeAttackCastEstimate', 35, {
-		range: 25,
-		min: 10,
-		max: 80,
-		steps: 5,
-	});
-
-	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);
-
-	// HP-aware distance: ahead → fight closer, behind → kite at range
-	const hpDiff = state.health - enemy.health;
-	const isAggressive = hpDiff >= -aggressiveHPThreshold;
-	const effectiveTargetDistance = isAggressive
-		? targetDistance - aggressiveDistanceOffset
-		: targetDistance + cautiousDistanceOffset;
-
-	const move = combatMove(
-		state.position,
-		enemy,
-		distance,
-		effectiveTargetDistance,
-		dodgeDirection,
-		state.tick,
-		strafeCyclePeriod,
-		strafeIntensity,
-		approachSpeed,
-		distanceDeadZone,
-	);
-
-	// === STEP 1: CHANNELING ===
-	if (state.state === 'channeling') 
-	{
-		if (!urgentThreat || urgentThreat.ticksToImpact > shieldCancelThreshold) 
-		{
-			return {move, cancel: true};
-		}
-		return {move: {x: 0, y: 0}};
-	}
-
-	// === STEP 2: PROGRESSIVE CAST-CANCEL ===
-	if (
-		state.state === 'casting' &&
-    state.castingSpell === 'missile' &&
-    urgentThreat &&
-    !urgentThreat.bestDodgeDirection
-	) 
-	{
-		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);
-
-			if (incomingDamage >= state.health || incomingDamage >= cancelHeavyDmg) 
-			{
-				return {move, cancel: true};
-			}
-			if (incomingDamage >= cancelMediumDmg && castRatio < cancelCastRatio) 
-			{
-				return {move, cancel: true};
-			}
-		}
-	}
-
-	// === STEP 3: BLINK-DODGE — 100% damage avoidance (optimizer-controlled) ===
-	if (
-		preferBlinkDodge &&
-    state.state === 'idle' &&
-    urgentThreat &&
-    state.blinkCooldown === 0 &&
-    (!urgentThreat.bestDodgeDirection || shouldForceShield(urgentThreat)) &&
-    urgentThreat.ticksToImpact >= BLINK_CAST_TIME &&
-    urgentThreat.ticksToImpact <= blinkWindowMax
-	) 
-	{
-		// Aggressive: blink toward enemy to dodge + close gap
-		// Defensive: blink away to dodge + increase distance
-		if (isAggressive && distance > effectiveTargetDistance) 
-		{
-			const blinkTarget = getBlinkToDecreaseDistance(
-				state.position,
-				enemy.position,
-				state.projectiles,
-			);
-			if (blinkTarget) 
-			{
-				return {
-					move: {x: 0, y: 0},
-					startCast: {spell: 'blink', target: blinkTarget},
-				};
-			}
-		}
-		const blinkTarget = getBlinkToIncreaseDistance(
-			state.position,
-			enemy.position,
-			state.projectiles,
-			MIN_BLINK_ESCAPE_DISTANCE,
-		);
-		if (blinkTarget) 
-		{
-			return {
-				move: {x: 0, y: 0},
-				startCast: {spell: 'blink', target: blinkTarget},
-			};
-		}
-	}
-
-	// === STEP 4: BLINK ESCAPE — enemy too close ===
-	if (
-		state.state === 'idle' &&
-    distance < blinkEscapeDistance &&
-    state.blinkCooldown === 0 &&
-    (!urgentThreat || urgentThreat.bestDodgeDirection !== null)
-	) 
-	{
-		const escapeTarget = getBlinkToIncreaseDistance(
-			state.position,
-			enemy.position,
-			state.projectiles,
-			MIN_BLINK_ESCAPE_DISTANCE,
-		);
-		if (escapeTarget) 
-		{
-			return {
-				move: {x: 0, y: 0},
-				startCast: {spell: 'blink', target: escapeTarget},
-			};
-		}
-	}
-
-	// === STEP 5: SHIELD ===
-	if (
-		state.state === 'idle' &&
-    urgentThreat &&
-    (!urgentThreat.bestDodgeDirection || shouldForceShield(urgentThreat))
-	) 
-	{
-		if (
-			urgentThreat.canBlockInTime &&
-      urgentThreat.ticksToStartShield <= SHIELD_BUFFER &&
-      (state.blinkCooldown > 0 || urgentThreat.ticksToImpact < 10)
-		) 
-		{
-			return {
-				move: {x: 0, y: 0},
-				startCast: {spell: 'shield'},
-			};
-		}
-	}
-
-	// === STEP 6: VULNERABILITY BLINK — gap-close during enemy cast/GCD ===
-	if (
-		state.state === 'idle' &&
-    state.blinkCooldown === 0 &&
-    isAggressive &&
-    distance > effectiveTargetDistance + blinkGapThreshold &&
-    (!urgentThreat || urgentThreat.bestDodgeDirection !== null)
-	) 
-	{
-		const vulnerabilityTicks = getEnemyVulnerabilityTicks(enemy);
-		if (vulnerabilityTicks >= punishMinVulnerability) 
-		{
-			const blinkTarget = getBlinkToDecreaseDistance(
-				state.position,
-				enemy.position,
-				state.projectiles,
-			);
-			if (blinkTarget) 
-			{
-				return {
-					move: {x: 0, y: 0},
-					startCast: {spell: 'blink', target: blinkTarget},
-				};
-			}
-		}
-	}
-
-	// === STEP 7: OFFENSE ===
-	if (state.state === 'idle' && distance < 500) 
-	{
-		const offenseDefenseTime =
-			state.blinkCooldown === 0
-				? BLINK_CAST_TIME
-				: SHIELD_CAST_TIME + SHIELD_BUFFER;
-		const enemyHP = Math.ceil(enemy.health);
-		const vulnerabilityTicks = getEnemyVulnerabilityTicks(enemy);
-
-		// --- PUNISH MODE: range-adaptive missiles during 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) 
-			{
-				// Close range → straight for max damage, far → light homing
-				const punishTurnRate = distance < closeRangeStraightThreshold ? 0 : 0.2;
-				const config = fitMissileToBudget(effectiveBudget, distance, {
-					minTurnRate: punishTurnRate,
-					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,
-							startCast: {
-								spell: 'missile',
-								config,
-								missileAI: config.turnRate > 0 ? HomingAI : StraightAI,
-								direction: angleTo(state.position, aimTarget),
-							},
-						};
-					}
-				}
-			}
-		}
-
-		// --- STANDARD MODE: range-adaptive missiles ---
-		const nextThreatTime = urgentThreat?.ticksToImpact ?? Infinity;
-		const safeBudget = nextThreatTime - GCD_DURATION - offenseDefenseTime;
-		const budgetTicks = Math.min(safeBudget, MAX_CAST_BUDGET);
-
-		// Adapt turn rate to distance: close → straight, far → homing
-		const effectiveMinTurnRate =
-			distance < closeRangeStraightThreshold ? 0 : minTurnRate;
-		const minDmg = Math.min(MIN_USEFUL_DAMAGE, enemyHP);
-		let config = fitMissileToBudget(budgetTicks, distance, {
-			minTurnRate: effectiveMinTurnRate,
-			maxDamage: enemyHP,
-			lastMissileConfig: state.lastMissileConfig,
-		});
-
-		if (
-			config &&
-      config.damage >= minDmg &&
-      isSafeToAttack(threats, safeAttackCastEstimate)
-		) 
-		{
-			return {
-				move,
-				startCast: {
-					spell: 'missile',
-					config,
-					missileAI: config.turnRate > 0 ? HomingAI : StraightAI,
-					direction: angleTo(state.position, enemy.position),
-				},
-			};
-		}
-
-		// Fallback: fire bigger missile, accept incoming hit
-		if (!config || config.damage < minDmg) 
-		{
-			config = fitMissileToBudget(MAX_CAST_BUDGET, distance, {
-				minTurnRate: effectiveMinTurnRate,
-				maxDamage: enemyHP,
-				lastMissileConfig: state.lastMissileConfig,
-			});
-			if (config) 
-			{
-				return {
-					move,
-					startCast: {
-						spell: 'missile',
-						config,
-						missileAI: config.turnRate > 0 ? HomingAI : StraightAI,
-						direction: angleTo(state.position, enemy.position),
-					},
-				};
-			}
-		}
-	}
-
-	return {move};
-};
+import {WizardFunction, MissileAIFunction} from '../../types.js';
+import {angleTo} from '../../utils/angles.js';
+import {distanceTo} from '../../utils/distance.js';
+import {
+	ARENA_SIZE,
+	GCD_DURATION,
+	SHIELD_CAST_TIME,
+	BLINK_CAST_TIME,
+} from '../../rules.js';
+import {getMissileCastTime, getLeadPosition} from '../../utils/combat.js';
+import {
+	getThreats,
+	getMostUrgentThreat,
+	getDodgeDirectionForMovement,
+	fitMissileToBudget,
+	getBlinkToDecreaseDistance,
+	getBlinkToIncreaseDistance,
+	shouldForceShield,
+	MIN_BLINK_ESCAPE_DISTANCE,
+	MAX_CAST_BUDGET,
+	MIN_USEFUL_DAMAGE,
+	getEnemyVulnerabilityTicks,
+	isSafeToAttack,
+} from '../shared.js';
+import {useParam} from '../../engine/params-runtime.js';
+
+const WALL_BUFFER = 60;
+const SHIELD_BUFFER = 3;
+
+const HomingAI: MissileAIFunction = ({worldState}) => 
+{
+	const enemy = worldState.enemies[0];
+	return {turnToward: enemy?.position};
+};
+
+const StraightAI: MissileAIFunction = () => ({});
+
+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;
+
+	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 (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;
+	}
+	else 
+	{
+		const cycle = Math.floor(tick / strafeCyclePeriod) % 2;
+		strafeDirection = cycle === 0 ? strafeClockwise : strafeCounterClockwise;
+	}
+
+	if (dodgeDirection) 
+	{
+		return {x: strafeDirection.x * 100, y: strafeDirection.y * 100};
+	}
+
+	let moveX = strafeDirection.x * strafeIntensity;
+	let moveY = strafeDirection.y * strafeIntensity;
+
+	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;
+	}
+
+	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: Archmage
+ *
+ * BEHAVIOR: Versatile duelist that adapts missile choice based on distance and HP.
+ * Close range → straight missiles (no turn cost = more damage). Mid/far range → homing.
+ * Uses dual-blink aggressively (gap-close during vulnerability, escape when trade is bad).
+ * HP-aware: ahead → aggressive close range; behind → defensive ranged kiting.
+ *
+ * KEY IMPROVEMENTS OVER WARMAGE:
+ * - Range-adaptive missiles: straight close, homing far
+ * - Vulnerability-timed blinks: gap-close during enemy cast/GCD
+ * - HP-aware aggression: adjusts distance + risk tolerance based on HP differential
+ * - Progressive cast-cancel: graduated thresholds
+ *
+ * PROGRESSION LINE: Battlemage → Warmage → Archmage
+ * TIER: 3 (elite Duelist line)
+ */
+export const Archmage: WizardFunction = ({state}) => 
+{
+	const targetDistance = useParam('targetDistance', 214, {
+		range: 150,
+		min: 0,
+	});
+	const minTurnRate = useParam('minTurnRate', -14.6, {range: 1.5, steps: 5});
+	const blinkEscapeDistance = useParam('blinkEscapeDistance', 442, {
+		range: 190,
+		min: 0,
+		steps: 7,
+	});
+	const punishMinVulnerability = useParam('punishMinVulnerability', 85, {
+		range: 30,
+		min: 10,
+		steps: 5,
+	});
+	const aggressiveHPThreshold = useParam('aggressiveHPThreshold', 4, {
+		range: 20,
+		min: 0,
+		steps: 5,
+	});
+	const preferBlinkDodge =
+		useParam('preferBlinkDodge', 1, {min: 0, max: 1, steps: 2}) >= 0.5;
+	const strafeCyclePeriod = useParam('strafeCyclePeriod', 248, {
+		range: 75,
+		min: 80,
+		max: 250,
+	});
+	const strafeIntensity = useParam('strafeIntensity', 100, {
+		range: 40,
+		min: 20,
+		max: 100,
+		steps: 7,
+	});
+	const approachSpeed = useParam('approachSpeed', 57, {
+		range: 30,
+		min: 10,
+		max: 80,
+		steps: 7,
+	});
+	const distanceDeadZone = useParam('distanceDeadZone', 37, {
+		range: 30,
+		min: 10,
+		max: 80,
+		steps: 7,
+	});
+	const aggressiveDistanceOffset = useParam('aggressiveDistanceOffset', 99, {
+		range: 50,
+		min: 0,
+		max: 100,
+		steps: 7,
+	});
+	const cautiousDistanceOffset = useParam('cautiousDistanceOffset', 42, {
+		range: 50,
+		min: 0,
+		max: 120,
+		steps: 7,
+	});
+	const cancelHeavyDmg = useParam('cancelHeavyDmg', 40, {
+		range: 15,
+		min: 5,
+		max: 40,
+		steps: 5,
+	});
+	const cancelMediumDmg = useParam('cancelMediumDmg', 20, {
+		range: 10,
+		min: 3,
+		max: 25,
+		steps: 5,
+	});
+	const cancelCastRatio = useParam('cancelCastRatio', 0.74, {
+		range: 0.4,
+		min: 0.3,
+		max: 1.0,
+		steps: 5,
+	});
+	const shieldCancelThreshold = useParam('shieldCancelThreshold', 100, {
+		range: 75,
+		min: 50,
+		max: 300,
+	});
+	const blinkWindowMax = useParam('blinkWindowMax', 29, {
+		range: 40,
+		min: 20,
+		max: 120,
+		steps: 7,
+	});
+	const blinkGapThreshold = useParam('blinkGapThreshold', 80, {
+		range: 75,
+		min: 20,
+		max: 200,
+		steps: 7,
+	});
+	const flightTimeDivisor = useParam('flightTimeDivisor', 4.5, {
+		range: 4,
+		min: 2,
+		max: 12,
+		steps: 5,
+	});
+	const closeRangeStraightThreshold = useParam(
+		'closeRangeStraightThreshold',
+		50,
+		{range: 100, min: 50, max: 300, steps: 7},
+	);
+	const safeAttackCastEstimate = useParam('safeAttackCastEstimate', 35, {
+		range: 25,
+		min: 10,
+		max: 80,
+		steps: 5,
+	});
+
+	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);
+
+	// HP-aware distance: ahead → fight closer, behind → kite at range
+	const hpDiff = state.health - enemy.health;
+	const isAggressive = hpDiff >= -aggressiveHPThreshold;
+	const effectiveTargetDistance = isAggressive
+		? targetDistance - aggressiveDistanceOffset
+		: targetDistance + cautiousDistanceOffset;
+
+	const move = combatMove(
+		state.position,
+		enemy,
+		distance,
+		effectiveTargetDistance,
+		dodgeDirection,
+		state.tick,
+		strafeCyclePeriod,
+		strafeIntensity,
+		approachSpeed,
+		distanceDeadZone,
+	);
+
+	// === STEP 1: CHANNELING ===
+	if (state.state === 'channeling') 
+	{
+		if (!urgentThreat || urgentThreat.ticksToImpact > shieldCancelThreshold) 
+		{
+			return {move, cancel: true};
+		}
+		return {move: {x: 0, y: 0}};
+	}
+
+	// === STEP 2: PROGRESSIVE CAST-CANCEL ===
+	if (
+		state.state === 'casting' &&
+    state.castingSpell === 'missile' &&
+    urgentThreat &&
+    !urgentThreat.bestDodgeDirection
+	) 
+	{
+		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);
+
+			if (incomingDamage >= state.health || incomingDamage >= cancelHeavyDmg) 
+			{
+				return {move, cancel: true};
+			}
+			if (incomingDamage >= cancelMediumDmg && castRatio < cancelCastRatio) 
+			{
+				return {move, cancel: true};
+			}
+		}
+	}
+
+	// === STEP 3: BLINK-DODGE — 100% damage avoidance (optimizer-controlled) ===
+	if (
+		preferBlinkDodge &&
+    state.state === 'idle' &&
+    urgentThreat &&
+    state.blinkCooldown === 0 &&
+    (!urgentThreat.bestDodgeDirection || shouldForceShield(urgentThreat)) &&
+    urgentThreat.ticksToImpact >= BLINK_CAST_TIME &&
+    urgentThreat.ticksToImpact <= blinkWindowMax
+	) 
+	{
+		// Aggressive: blink toward enemy to dodge + close gap
+		// Defensive: blink away to dodge + increase distance
+		if (isAggressive && distance > effectiveTargetDistance) 
+		{
+			const blinkTarget = getBlinkToDecreaseDistance(
+				state.position,
+				enemy.position,
+				state.projectiles,
+			);
+			if (blinkTarget) 
+			{
+				return {
+					move: {x: 0, y: 0},
+					startCast: {spell: 'blink', target: blinkTarget},
+				};
+			}
+		}
+		const blinkTarget = getBlinkToIncreaseDistance(
+			state.position,
+			enemy.position,
+			state.projectiles,
+			MIN_BLINK_ESCAPE_DISTANCE,
+		);
+		if (blinkTarget) 
+		{
+			return {
+				move: {x: 0, y: 0},
+				startCast: {spell: 'blink', target: blinkTarget},
+			};
+		}
+	}
+
+	// === STEP 4: BLINK ESCAPE — enemy too close ===
+	if (
+		state.state === 'idle' &&
+    distance < blinkEscapeDistance &&
+    state.blinkCooldown === 0 &&
+    (!urgentThreat || urgentThreat.bestDodgeDirection !== null)
+	) 
+	{
+		const escapeTarget = getBlinkToIncreaseDistance(
+			state.position,
+			enemy.position,
+			state.projectiles,
+			MIN_BLINK_ESCAPE_DISTANCE,
+		);
+		if (escapeTarget) 
+		{
+			return {
+				move: {x: 0, y: 0},
+				startCast: {spell: 'blink', target: escapeTarget},
+			};
+		}
+	}
+
+	// === STEP 5: SHIELD ===
+	if (
+		state.state === 'idle' &&
+    urgentThreat &&
+    (!urgentThreat.bestDodgeDirection || shouldForceShield(urgentThreat))
+	) 
+	{
+		if (
+			urgentThreat.canBlockInTime &&
+      urgentThreat.ticksToStartShield <= SHIELD_BUFFER &&
+      (state.blinkCooldown > 0 || urgentThreat.ticksToImpact < 10)
+		) 
+		{
+			return {
+				move: {x: 0, y: 0},
+				startCast: {spell: 'shield'},
+			};
+		}
+	}
+
+	// === STEP 6: VULNERABILITY BLINK — gap-close during enemy cast/GCD ===
+	if (
+		state.state === 'idle' &&
+    state.blinkCooldown === 0 &&
+    isAggressive &&
+    distance > effectiveTargetDistance + blinkGapThreshold &&
+    (!urgentThreat || urgentThreat.bestDodgeDirection !== null)
+	) 
+	{
+		const vulnerabilityTicks = getEnemyVulnerabilityTicks(enemy);
+		if (vulnerabilityTicks >= punishMinVulnerability) 
+		{
+			const blinkTarget = getBlinkToDecreaseDistance(
+				state.position,
+				enemy.position,
+				state.projectiles,
+			);
+			if (blinkTarget) 
+			{
+				return {
+					move: {x: 0, y: 0},
+					startCast: {spell: 'blink', target: blinkTarget},
+				};
+			}
+		}
+	}
+
+	// === STEP 7: OFFENSE ===
+	if (state.state === 'idle' && distance < 500) 
+	{
+		const offenseDefenseTime =
+			state.blinkCooldown === 0
+				? BLINK_CAST_TIME
+				: SHIELD_CAST_TIME + SHIELD_BUFFER;
+		const enemyHP = Math.ceil(enemy.health);
+		const vulnerabilityTicks = getEnemyVulnerabilityTicks(enemy);
+
+		// --- PUNISH MODE: range-adaptive missiles during 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) 
+			{
+				// Close range → straight for max damage, far → light homing
+				const punishTurnRate = distance < closeRangeStraightThreshold ? 0 : 0.2;
+				const config = fitMissileToBudget(effectiveBudget, distance, {
+					minTurnRate: punishTurnRate,
+					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,
+							startCast: {
+								spell: 'missile',
+								config,
+								missileAI: config.turnRate > 0 ? HomingAI : StraightAI,
+								direction: angleTo(state.position, aimTarget),
+							},
+						};
+					}
+				}
+			}
+		}
+
+		// --- STANDARD MODE: range-adaptive missiles ---
+		const nextThreatTime = urgentThreat?.ticksToImpact ?? Infinity;
+		const safeBudget = nextThreatTime - GCD_DURATION - offenseDefenseTime;
+		const budgetTicks = Math.min(safeBudget, MAX_CAST_BUDGET);
+
+		// Adapt turn rate to distance: close → straight, far → homing
+		const effectiveMinTurnRate =
+			distance < closeRangeStraightThreshold ? 0 : minTurnRate;
+		const minDmg = Math.min(MIN_USEFUL_DAMAGE, enemyHP);
+		let config = fitMissileToBudget(budgetTicks, distance, {
+			minTurnRate: effectiveMinTurnRate,
+			maxDamage: enemyHP,
+			lastMissileConfig: state.lastMissileConfig,
+		});
+
+		if (
+			config &&
+      config.damage >= minDmg &&
+      isSafeToAttack(threats, safeAttackCastEstimate)
+		) 
+		{
+			return {
+				move,
+				startCast: {
+					spell: 'missile',
+					config,
+					missileAI: config.turnRate > 0 ? HomingAI : StraightAI,
+					direction: angleTo(state.position, enemy.position),
+				},
+			};
+		}
+
+		// Fallback: fire bigger missile, accept incoming hit
+		if (!config || config.damage < minDmg) 
+		{
+			config = fitMissileToBudget(MAX_CAST_BUDGET, distance, {
+				minTurnRate: effectiveMinTurnRate,
+				maxDamage: enemyHP,
+				lastMissileConfig: state.lastMissileConfig,
+			});
+			if (config) 
+			{
+				return {
+					move,
+					startCast: {
+						spell: 'missile',
+						config,
+						missileAI: config.turnRate > 0 ? HomingAI : StraightAI,
+						direction: angleTo(state.position, enemy.position),
+					},
+				};
+			}
+		}
+	}
+
+	return {move};
+};