@vibemancer/core 0.1.0

package/src/bots/sniper/01_Spellshot.ts

@@ -0,0 +1,385 @@
+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,
+	getBlinkToIncreaseDistance,
+	MIN_BLINK_ESCAPE_DISTANCE,
+	shouldForceShield,
+} from '../shared.js';
+import {useParam} from '../../engine/params-runtime.js';
+
+const HomingAI: MissileAIFunction = ({worldState}) => 
+{
+	const enemy = worldState.enemies[0];
+	return {turnToward: enemy?.position};
+};
+const WALL_BUFFER = 50;
+
+/**
+ * Smart combat movement: dodge using threat analysis, avoid walls, commit to direction.
+ */
+function combatMove(
+	position: {x: number; y: number},
+	enemy: {position: {x: number; y: number}},
+	currentDistance: number,
+	minDistance: number,
+	maxDistance: 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};
+
+	// Priority 1: Use dodge direction (from threat analysis or close missile avoidance)
+	if (dodgeDirection) 
+	{
+		strafeDirection = dodgeDirection;
+	}
+	// Priority 2: Avoid walls
+	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;
+	}
+	// Priority 3: Alternate strafe direction
+	else 
+	{
+		const cycle = Math.floor(tick / strafeCyclePeriod) % 2;
+		strafeDirection = cycle === 0 ? strafeClockwise : strafeCounterClockwise;
+	}
+
+	// When actively dodging, commit fully — no approach/retreat dilution
+	if (dodgeDirection) 
+	{
+		return {x: strafeDirection.x * 100, y: strafeDirection.y * 100};
+	}
+
+	let moveX = strafeDirection.x * strafeIntensity;
+	let moveY = strafeDirection.y * strafeIntensity;
+
+	// Distance management (only when not dodging)
+	if (currentDistance > maxDistance) 
+	{
+		moveX += (deltaX / normalizedDistance) * approachSpeed;
+		moveY += (deltaY / normalizedDistance) * approachSpeed;
+	}
+	else if (currentDistance < minDistance) 
+	{
+		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: Spellshot
+ *
+ * BEHAVIOR: Uses interceptAngle to calculate where the enemy will be and fires
+ * fast, non-homing missiles (speed 8, turnRate 0) along the predicted path.
+ * Strafes at medium range (300-400), shields undodgeable threats, emergency
+ * blinks when shield isn't available. The key mechanic is PREDICTION — these
+ * missiles don't track, they go exactly where you calculated the enemy would be.
+ *
+ * NAMING RATIONALE: "Spellshot" — a spell that is a single, precisely aimed shot.
+ * Like a sniper's "called shot" but magical. The defining feature is the intercept
+ * calculation: this bot doesn't fire tracking missiles, it calculates the exact
+ * angle needed to hit a moving target. "Shot" implies precision, singular impact,
+ * and skill-based aiming — everything this bot is about.
+ *
+ * PROGRESSION LINE: Spellshot → Spelltracer → Spellseeker
+ * - Spellshot (tier 1): Basic intercept prediction, non-homing missiles
+ * - Spelltracer (tier 2): Future — predictive homing (missiles that lead AND track)
+ * - Spellseeker (tier 3): Future — perfect prediction, multi-angle attacks
+ * The naming progression: shot (single bullet) → tracer (bullet that tracks a path)
+ * → seeker (actively hunts). Each tier adds more intelligence to the projectile,
+ * evolving from "I calculate where you'll be" to "my missile calculates where you'll be."
+ *
+ * NOTE: A separate future archetype "Spellslinger" (volume-of-fire) is reserved
+ * for a rapid-fire bot that prioritizes quantity over prediction.
+ *
+ * TIER: 1 (base)
+ */
+export const Spellshot: WizardFunction = ({state}) => 
+{
+	const dangerDistance = useParam('dangerDistance', 45, {range: 100, min: 0});
+	const targetDistance = useParam('targetDistance', 339, {
+		range: 150,
+		min: 0,
+	});
+	const distanceDeadZone = useParam('distanceDeadZone', 22, {
+		range: 50,
+		min: 0,
+	});
+	const minCombatDistance = targetDistance - distanceDeadZone;
+	const maxCombatDistance = targetDistance + distanceDeadZone;
+	const strafeCyclePeriod = useParam('strafeCyclePeriod', 230, {
+		range: 75,
+		min: 80,
+		max: 300,
+	});
+	const strafeIntensity = useParam('strafeIntensity', 36, {
+		range: 40,
+		min: 20,
+		max: 100,
+		steps: 7,
+	});
+	const approachSpeed = useParam('approachSpeed', 78, {
+		range: 30,
+		min: 10,
+		max: 80,
+		steps: 7,
+	});
+	const shieldCancelThreshold = useParam('shieldCancelThreshold', 150, {
+		range: 75,
+		min: 50,
+		max: 300,
+	});
+	const missileDamage = useParam('missileDamage', 30, {
+		range: 10,
+		min: 5,
+		max: 30,
+		steps: 5,
+	});
+	const missileSpeed = useParam('missileSpeed', 12, {
+		range: 3,
+		min: 3,
+		max: 12,
+		steps: 5,
+	});
+	const missileTurnRate = useParam('missileTurnRate', 0.3, {
+		range: 1.5,
+		steps: 5,
+	});
+	const missileMinDuration = useParam('missileMinDuration', 55, {
+		range: 30,
+		min: 20,
+		max: 100,
+		steps: 7,
+	});
+	const durationRangeFactor = useParam('durationRangeFactor', 0.67, {
+		range: 0.5,
+		min: 0.5,
+		max: 2.0,
+		steps: 5,
+	});
+
+	const enemy = state.enemies[0];
+	if (!enemy) 
+	{
+		return {move: {x: 0, y: 0}};
+	}
+
+	const distance = distanceTo(state.position, enemy.position);
+
+	// Analyze threats using simulation
+	const threats = getThreats(state);
+	const urgentThreat = getMostUrgentThreat(threats);
+
+	// === DEFENSE: Handle channeling ===
+	if (state.state === 'channeling') 
+	{
+		if (!urgentThreat || urgentThreat.ticksToImpact > shieldCancelThreshold) 
+		{
+			return {move: {x: 0, y: 0}, cancel: true};
+		}
+		return {move: {x: 0, y: 0}};
+	}
+
+	// === DEFENSE: Cancel missile cast if dangerous threat will arrive before we can shield ===
+	// Only cancel for: high-damage homing (always) or undodgeable when health is at risk
+	if (
+		state.state === 'casting' &&
+    state.castingSpell === 'missile' &&
+    urgentThreat &&
+    (!urgentThreat.bestDodgeDirection || shouldForceShield(urgentThreat))
+	) 
+	{
+		const mustCancel =
+			shouldForceShield(urgentThreat) ||
+      state.health <= urgentThreat.projectile.damage * 2 + 1;
+		if (mustCancel) 
+		{
+			const remainingCast =
+				(state.castDuration ?? 0) - (state.castProgress ?? 0);
+			if (
+				urgentThreat.ticksToImpact <=
+        remainingCast + GCD_DURATION + SHIELD_CAST_TIME + 3
+			) 
+			{
+				const dodgeDir = getDodgeDirectionForMovement(threats, state.position);
+				const cancelMove = combatMove(
+					state.position,
+					enemy,
+					distance,
+					minCombatDistance,
+					maxCombatDistance,
+					dodgeDir,
+					state.tick,
+					strafeCyclePeriod,
+					strafeIntensity,
+					approachSpeed,
+				);
+				return {move: cancelMove, cancel: true};
+			}
+		}
+	}
+
+	// === DEFENSE: Shield undodgeable or high-damage homing threats ===
+	if (
+		state.state === 'idle' &&
+    urgentThreat &&
+    (!urgentThreat.bestDodgeDirection || shouldForceShield(urgentThreat))
+	) 
+	{
+		if (urgentThreat.canBlockInTime) 
+		{
+			// Start shield at the right time (small buffer for safety)
+			if (urgentThreat.ticksToStartShield <= 3) 
+			{
+				return {
+					move: {x: 0, y: 0},
+					startCast: {spell: 'shield'},
+				};
+			}
+		}
+		// Can't dodge, can't shield → blink away (emergency)
+		else if (state.blinkCooldown === 0) 
+		{
+			return {
+				move: {x: 0, y: 0},
+				startCast: {spell: 'blink', target: getBlinkToCenter(state.position)},
+			};
+		}
+	}
+
+	// === DISTANCE BLINK: enemy too close, blink to reestablish kiting range ===
+	if (
+		state.state === 'idle' &&
+    distance < dangerDistance &&
+    state.blinkCooldown === 0 &&
+    (!urgentThreat || urgentThreat.bestDodgeDirection !== null)
+	) 
+	{
+		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},
+			};
+		}
+	}
+
+	// Smart combat movement
+	const dodgeDirection = getDodgeDirectionForMovement(threats, state.position);
+	const move = combatMove(
+		state.position,
+		enemy,
+		distance,
+		minCombatDistance,
+		maxCombatDistance,
+		dodgeDirection,
+		state.tick,
+		strafeCyclePeriod,
+		strafeIntensity,
+		approachSpeed,
+	);
+
+	// === OFFENSE: Fast homing missiles ===
+	if (state.state === 'idle' && distance < 600) 
+	{
+		const missileConfig = {
+			damage: missileDamage,
+			speed: missileSpeed,
+			turnRate: missileTurnRate,
+			duration: Math.max(
+				missileMinDuration,
+				Math.ceil((distance * durationRangeFactor) / missileSpeed),
+			),
+		};
+		const castTime = getMissileCastTime(missileConfig, state.lastMissileConfig);
+		if (isSafeToAttack(threats, castTime)) 
+		{
+			return {
+				move,
+				startCast: {
+					spell: 'missile',
+					config: missileConfig,
+					missileAI: HomingAI,
+					direction: angleTo(state.position, enemy.position),
+				},
+			};
+		}
+	}
+
+	return {move};
+};