@vibemancer/core 0.1.0 → 0.1.1

package/src/bots/caster/01_Flamecaller.ts

@@ -1,286 +1,286 @@
-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} from '../../rules.js';
-import {getMissileCastTime} from '../../utils/combat.js';
-import {
-	getThreats,
-	getMostUrgentThreat,
-	getDodgeDirectionForMovement,
-	isSafeToAttack,
-	getBlinkToCenter,
-	shouldForceShield,
-} from '../shared.js';
-import {useParam} from '../../engine/params-runtime.js';
-
-const WALL_BUFFER = 60;
-
-const SHIELD_BUFFER = 3;
-
-// Fixed homing missile: damage 12, speed 5, turnRate 1, duration 180
-// Range: 5 × 180 = 900 units (covers arena)
-const MISSILE_CONFIG = {damage: 12, speed: 5, turnRate: 1, duration: 180};
-
-const HomingAI: MissileAIFunction = ({worldState}) => 
-{
-	const enemy = worldState.enemies[0];
-	return {turnToward: enemy?.position};
-};
-
-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
-	);
-}
-
-function smartStrafe(
-	position: {x: number; y: number},
-	enemy: {position: {x: number; y: number}},
-	dodgeDirection: {x: number; y: number} | null,
-	tick: number,
-	strafeCyclePeriod: number,
-	strafeIntensity: number,
-): {x: number; y: number} 
-{
-	const deltaX = enemy.position.x - position.x;
-	const deltaY = enemy.position.y - position.y;
-	const normalizedDistance = Math.sqrt(deltaX * deltaX + deltaY * deltaY);
-	if (normalizedDistance === 0) return {x: 0, y: 0};
-
-	const strafeClockwise = {
-		x: -deltaY / normalizedDistance,
-		y: deltaX / normalizedDistance,
-	};
-	const strafeCounterClockwise = {
-		x: deltaY / normalizedDistance,
-		y: -deltaX / normalizedDistance,
-	};
-
-	let strafeDir: {x: number; y: number};
-
-	if (dodgeDirection) 
-	{
-		strafeDir = 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,
-		);
-		strafeDir =
-			scoreClockwise > scoreCounterClockwise
-				? strafeClockwise
-				: strafeCounterClockwise;
-	}
-	else 
-	{
-		const cycle = Math.floor(tick / strafeCyclePeriod) % 2;
-		strafeDir = cycle === 0 ? strafeClockwise : strafeCounterClockwise;
-	}
-
-	const intensity = dodgeDirection ? 100 : strafeIntensity;
-	return {x: strafeDir.x * intensity, y: strafeDir.y * intensity};
-}
-
-/**
- * Bot: Flamecaller
- *
- * BEHAVIOR: Long-range homing missile caster with fixed missile config.
- * Maintains 350u distance, strafes to dodge, and fires standard homing
- * missiles (d=10, s=5, t=1, dur=180). Shields undodgeable threats,
- * emergency blinks. A straightforward ranged caster that trades
- * consistency for adaptability.
- *
- * PROGRESSION LINE: Flamecaller → Pyromancer → Infernalist
- * - Flamecaller (tier 1): Fixed homing missiles, basic strafe and defense
- * - Pyromancer (tier 2): + adaptive fitting, cast canceling, smart fallbacks
- * - Infernalist (tier 3): Future — overwhelming adaptive fire
- *
- * TIER: 1 (base)
- */
-export const Flamecaller: WizardFunction = ({state}) => 
-{
-	const targetDistance = useParam('targetDistance', 753, {
-		range: 150,
-		min: 0,
-	});
-	const strafeCyclePeriod = useParam('strafeCyclePeriod', 273, {
-		range: 75,
-		min: 80,
-		max: 300,
-	});
-	const strafeIntensity = useParam('strafeIntensity', 20, {
-		range: 40,
-		min: 20,
-		max: 100,
-		steps: 7,
-	});
-	const approachSpeed = useParam('approachSpeed', 40, {
-		range: 30,
-		min: 10,
-		max: 70,
-		steps: 7,
-	});
-	const distanceDeadZone = useParam('distanceDeadZone', 56, {
-		range: 30,
-		min: 5,
-		max: 80,
-		steps: 7,
-	});
-	const shieldCancelThreshold = useParam('shieldCancelThreshold', 150, {
-		range: 75,
-		min: 50,
-		max: 300,
-	});
-	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);
-	const strafe = smartStrafe(
-		state.position,
-		enemy,
-		dodgeDirection,
-		state.tick,
-		strafeCyclePeriod,
-		strafeIntensity,
-	);
-
-	// Distance management (retreat if too close, approach if too far)
-	let moveX = strafe.x;
-	let moveY = strafe.y;
-
-	if (!dodgeDirection) 
-	{
-		const deltaX = enemy.position.x - state.position.x;
-		const deltaY = enemy.position.y - state.position.y;
-		const normalizedDistance = distance > 0 ? distance : 1;
-
-		if (distance > targetDistance + distanceDeadZone) 
-		{
-			moveX += (deltaX / normalizedDistance) * approachSpeed;
-			moveY += (deltaY / normalizedDistance) * approachSpeed;
-		}
-		else if (distance < targetDistance - distanceDeadZone) 
-		{
-			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;
-	}
-
-	const move = {x: moveX, y: moveY};
-
-	// === DEFENSE: Handle channeling ===
-	if (state.state === 'channeling') 
-	{
-		if (!urgentThreat || urgentThreat.ticksToImpact > shieldCancelThreshold) 
-		{
-			return {move, cancel: true};
-		}
-		return {move: {x: 0, y: 0}};
-	}
-
-	// === DEFENSE: Let shield cast finish ===
-	if (state.state === 'casting' && state.castingSpell === 'shield') 
-	{
-		return {move: {x: 0, y: 0}};
-	}
-
-	// === DEFENSE: Shield undodgeable or high-damage homing threats ===
-	if (
-		state.state === 'idle' &&
-    urgentThreat &&
-    (!urgentThreat.bestDodgeDirection || shouldForceShield(urgentThreat))
-	) 
-	{
-		if (urgentThreat.canBlockInTime) 
-		{
-			if (urgentThreat.ticksToStartShield <= SHIELD_BUFFER) 
-			{
-				return {
-					move: {x: 0, y: 0},
-					startCast: {spell: 'shield'},
-				};
-			}
-		}
-		else if (state.blinkCooldown === 0) 
-		{
-			return {
-				move: {x: 0, y: 0},
-				startCast: {spell: 'blink', target: getBlinkToCenter(state.position)},
-			};
-		}
-	}
-
-	// === OFFENSE: Fire fixed homing missile when safe ===
-	if (state.state === 'idle') 
-	{
-		const nextThreatTime = urgentThreat?.ticksToImpact ?? Infinity;
-		const castTime = getMissileCastTime(
-			MISSILE_CONFIG,
-			state.lastMissileConfig,
-		);
-		const safeWindow =
-			castTime + GCD_DURATION + SHIELD_CAST_TIME + SHIELD_BUFFER;
-
-		if (
-			nextThreatTime > safeWindow &&
-      isSafeToAttack(threats, safeAttackCastEstimate)
-		) 
-		{
-			return {
-				move,
-				startCast: {
-					spell: 'missile',
-					config: MISSILE_CONFIG,
-					missileAI: HomingAI,
-					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} from '../../rules.js';
+import {getMissileCastTime} from '../../utils/combat.js';
+import {
+	getThreats,
+	getMostUrgentThreat,
+	getDodgeDirectionForMovement,
+	isSafeToAttack,
+	getBlinkToCenter,
+	shouldForceShield,
+} from '../shared.js';
+import {useParam} from '../../engine/params-runtime.js';
+
+const WALL_BUFFER = 60;
+
+const SHIELD_BUFFER = 3;
+
+// Fixed homing missile: damage 12, speed 5, turnRate 1, duration 180
+// Range: 5 × 180 = 900 units (covers arena)
+const MISSILE_CONFIG = {damage: 12, speed: 5, turnRate: 1, duration: 180};
+
+const HomingAI: MissileAIFunction = ({worldState}) => 
+{
+	const enemy = worldState.enemies[0];
+	return {turnToward: enemy?.position};
+};
+
+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
+	);
+}
+
+function smartStrafe(
+	position: {x: number; y: number},
+	enemy: {position: {x: number; y: number}},
+	dodgeDirection: {x: number; y: number} | null,
+	tick: number,
+	strafeCyclePeriod: number,
+	strafeIntensity: number,
+): {x: number; y: number} 
+{
+	const deltaX = enemy.position.x - position.x;
+	const deltaY = enemy.position.y - position.y;
+	const normalizedDistance = Math.sqrt(deltaX * deltaX + deltaY * deltaY);
+	if (normalizedDistance === 0) return {x: 0, y: 0};
+
+	const strafeClockwise = {
+		x: -deltaY / normalizedDistance,
+		y: deltaX / normalizedDistance,
+	};
+	const strafeCounterClockwise = {
+		x: deltaY / normalizedDistance,
+		y: -deltaX / normalizedDistance,
+	};
+
+	let strafeDir: {x: number; y: number};
+
+	if (dodgeDirection) 
+	{
+		strafeDir = 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,
+		);
+		strafeDir =
+			scoreClockwise > scoreCounterClockwise
+				? strafeClockwise
+				: strafeCounterClockwise;
+	}
+	else 
+	{
+		const cycle = Math.floor(tick / strafeCyclePeriod) % 2;
+		strafeDir = cycle === 0 ? strafeClockwise : strafeCounterClockwise;
+	}
+
+	const intensity = dodgeDirection ? 100 : strafeIntensity;
+	return {x: strafeDir.x * intensity, y: strafeDir.y * intensity};
+}
+
+/**
+ * Bot: Flamecaller
+ *
+ * BEHAVIOR: Long-range homing missile caster with fixed missile config.
+ * Maintains 350u distance, strafes to dodge, and fires standard homing
+ * missiles (d=10, s=5, t=1, dur=180). Shields undodgeable threats,
+ * emergency blinks. A straightforward ranged caster that trades
+ * consistency for adaptability.
+ *
+ * PROGRESSION LINE: Flamecaller → Pyromancer → Infernalist
+ * - Flamecaller (tier 1): Fixed homing missiles, basic strafe and defense
+ * - Pyromancer (tier 2): + adaptive fitting, cast canceling, smart fallbacks
+ * - Infernalist (tier 3): Future — overwhelming adaptive fire
+ *
+ * TIER: 1 (base)
+ */
+export const Flamecaller: WizardFunction = ({state}) => 
+{
+	const targetDistance = useParam('targetDistance', 753, {
+		range: 150,
+		min: 0,
+	});
+	const strafeCyclePeriod = useParam('strafeCyclePeriod', 273, {
+		range: 75,
+		min: 80,
+		max: 300,
+	});
+	const strafeIntensity = useParam('strafeIntensity', 20, {
+		range: 40,
+		min: 20,
+		max: 100,
+		steps: 7,
+	});
+	const approachSpeed = useParam('approachSpeed', 40, {
+		range: 30,
+		min: 10,
+		max: 70,
+		steps: 7,
+	});
+	const distanceDeadZone = useParam('distanceDeadZone', 56, {
+		range: 30,
+		min: 5,
+		max: 80,
+		steps: 7,
+	});
+	const shieldCancelThreshold = useParam('shieldCancelThreshold', 150, {
+		range: 75,
+		min: 50,
+		max: 300,
+	});
+	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);
+	const strafe = smartStrafe(
+		state.position,
+		enemy,
+		dodgeDirection,
+		state.tick,
+		strafeCyclePeriod,
+		strafeIntensity,
+	);
+
+	// Distance management (retreat if too close, approach if too far)
+	let moveX = strafe.x;
+	let moveY = strafe.y;
+
+	if (!dodgeDirection) 
+	{
+		const deltaX = enemy.position.x - state.position.x;
+		const deltaY = enemy.position.y - state.position.y;
+		const normalizedDistance = distance > 0 ? distance : 1;
+
+		if (distance > targetDistance + distanceDeadZone) 
+		{
+			moveX += (deltaX / normalizedDistance) * approachSpeed;
+			moveY += (deltaY / normalizedDistance) * approachSpeed;
+		}
+		else if (distance < targetDistance - distanceDeadZone) 
+		{
+			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;
+	}
+
+	const move = {x: moveX, y: moveY};
+
+	// === DEFENSE: Handle channeling ===
+	if (state.state === 'channeling') 
+	{
+		if (!urgentThreat || urgentThreat.ticksToImpact > shieldCancelThreshold) 
+		{
+			return {move, cancel: true};
+		}
+		return {move: {x: 0, y: 0}};
+	}
+
+	// === DEFENSE: Let shield cast finish ===
+	if (state.state === 'casting' && state.castingSpell === 'shield') 
+	{
+		return {move: {x: 0, y: 0}};
+	}
+
+	// === DEFENSE: Shield undodgeable or high-damage homing threats ===
+	if (
+		state.state === 'idle' &&
+    urgentThreat &&
+    (!urgentThreat.bestDodgeDirection || shouldForceShield(urgentThreat))
+	) 
+	{
+		if (urgentThreat.canBlockInTime) 
+		{
+			if (urgentThreat.ticksToStartShield <= SHIELD_BUFFER) 
+			{
+				return {
+					move: {x: 0, y: 0},
+					startCast: {spell: 'shield'},
+				};
+			}
+		}
+		else if (state.blinkCooldown === 0) 
+		{
+			return {
+				move: {x: 0, y: 0},
+				startCast: {spell: 'blink', target: getBlinkToCenter(state.position)},
+			};
+		}
+	}
+
+	// === OFFENSE: Fire fixed homing missile when safe ===
+	if (state.state === 'idle') 
+	{
+		const nextThreatTime = urgentThreat?.ticksToImpact ?? Infinity;
+		const castTime = getMissileCastTime(
+			MISSILE_CONFIG,
+			state.lastMissileConfig,
+		);
+		const safeWindow =
+			castTime + GCD_DURATION + SHIELD_CAST_TIME + SHIELD_BUFFER;
+
+		if (
+			nextThreatTime > safeWindow &&
+      isSafeToAttack(threats, safeAttackCastEstimate)
+		) 
+		{
+			return {
+				move,
+				startCast: {
+					spell: 'missile',
+					config: MISSILE_CONFIG,
+					missileAI: HomingAI,
+					direction: angleTo(state.position, enemy.position),
+				},
+			};
+		}
+	}
+
+	return {move};
+};