@vibemancer/core 0.1.0

package/src/bots/sniper/03_Spellseeker.ts

@@ -0,0 +1,546 @@
+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,
+	getBlinkToCenter,
+	getBlinkToIncreaseDistance,
+	fitMissileToBudget,
+	shouldForceShield,
+	MIN_BLINK_ESCAPE_DISTANCE,
+	MAX_CAST_BUDGET,
+	MIN_USEFUL_DAMAGE,
+	getClosingRate,
+	getEnemyVulnerabilityTicks,
+	isSafeToAttack,
+} from '../shared.js';
+import {useParam} from '../../engine/params-runtime.js';
+
+const HomingAI: MissileAIFunction = ({worldState}) => 
+{
+	const enemy = worldState.enemies[0];
+	return {turnToward: enemy?.position};
+};
+
+const StraightAI: MissileAIFunction = () => ({});
+
+const WALL_BUFFER = 50;
+const SHIELD_BUFFER = 3;
+
+/**
+ * Smart combat movement: dodge, avoid walls, maintain sniper range.
+ */
+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};
+
+	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;
+	}
+
+	if (dodgeDirection) 
+	{
+		return {x: strafeDirection.x * 100, y: strafeDirection.y * 100};
+	}
+
+	let moveX = strafeDirection.x * strafeIntensity;
+	let moveY = strafeDirection.y * strafeIntensity;
+
+	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: Spellseeker
+ *
+ * BEHAVIOR: Elite sniper that uses intercept-aimed straight missiles during vulnerability
+ * windows. Combines Spelltracer's adaptive fitting with precise lead-position aiming
+ * and vulnerability exploitation. Straight punish missiles at sniper range are nearly
+ * unavoidable. Proactive distance control via closing rate detection.
+ *
+ * KEY IMPROVEMENTS OVER SPELLTRACER:
+ * - Intercept-aimed punish: getLeadPosition + straight missiles during vulnerability
+ * - Proactive distance blink: monitors closing rate, blinks before danger zone
+ * - Progressive cast-cancel: graduated damage thresholds
+ * - Warmup exploitation: always passes lastMissileConfig
+ *
+ * PROGRESSION LINE: Spellshot → Spelltracer → Spellseeker
+ * TIER: 3 (elite Sniper line)
+ */
+export const Spellseeker: WizardFunction = ({state}) => 
+{
+	const dangerDistance = useParam('dangerDistance', 65, {
+		range: 175,
+		min: 0,
+	});
+	const targetDistance = useParam('targetDistance', 289, {
+		range: 200,
+		min: 0,
+	});
+	const distanceDeadZone = useParam('distanceDeadZone', 22, {
+		range: 50,
+		min: 0,
+	});
+	const rangeMin = targetDistance - distanceDeadZone;
+	const rangeMax = targetDistance + distanceDeadZone;
+	const minTurnRate = useParam('minTurnRate', 3.5, {range: 1.5, steps: 5});
+	const closingRateThreshold = useParam('closingRateThreshold', 1.79, {
+		range: 0.65,
+		min: 0,
+		steps: 5,
+	});
+	const punishMinVulnerability = useParam('punishMinVulnerability', 279, {
+		range: 30,
+		min: 10,
+		steps: 5,
+	});
+	const preferBlinkDodge =
+		useParam('preferBlinkDodge', 1, {min: 0, max: 1, steps: 2}) >= 0.5;
+	const strafeCyclePeriod = useParam('strafeCyclePeriod', 231, {
+		range: 75,
+		min: 80,
+		max: 250,
+	});
+	const strafeIntensity = useParam('strafeIntensity', 87, {
+		range: 40,
+		min: 20,
+		max: 100,
+		steps: 7,
+	});
+	const approachSpeed = useParam('approachSpeed', 80, {
+		range: 30,
+		min: 10,
+		max: 80,
+		steps: 7,
+	});
+	const shieldCancelThreshold = useParam('shieldCancelThreshold', 100, {
+		range: 75,
+		min: 50,
+		max: 300,
+	});
+	const blinkWindowMax = useParam('blinkWindowMax', 88, {
+		range: 40,
+		min: 20,
+		max: 120,
+		steps: 7,
+	});
+	const proactiveBlinkRange = useParam('proactiveBlinkRange', 433, {
+		range: 150,
+		min: 100,
+		max: 500,
+		steps: 7,
+	});
+	const flightTimeDivisor = useParam('flightTimeDivisor', 12, {
+		range: 4,
+		min: 2,
+		max: 12,
+		steps: 5,
+	});
+	const castingFlightTimeDivisor = useParam('castingFlightTimeDivisor', 12, {
+		range: 4,
+		min: 3,
+		max: 12,
+		steps: 5,
+	});
+	const enemyResponseEstimate = useParam('enemyResponseEstimate', 168, {
+		range: 100,
+		min: 50,
+		max: 300,
+		steps: 7,
+	});
+	const threatFallbackThreshold = useParam('threatFallbackThreshold', 250, {
+		range: 100,
+		min: 100,
+		max: 400,
+		steps: 7,
+	});
+	const punishAttackRange = useParam('punishAttackRange', 213, {
+		range: 150,
+		min: 200,
+		max: 700,
+		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);
+	const move = combatMove(
+		state.position,
+		enemy,
+		distance,
+		rangeMin,
+		rangeMax,
+		dodgeDirection,
+		state.tick,
+		strafeCyclePeriod,
+		strafeIntensity,
+		approachSpeed,
+	);
+
+	// === STEP 1: CHANNELING — cancel shield when safe ===
+	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 >= 20) 
+			{
+				return {move, cancel: true};
+			}
+			if (incomingDamage >= 10 && castRatio < 0.8) 
+			{
+				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
+	) 
+	{
+		const midRange = targetDistance;
+		const target =
+			distance < midRange
+				? (getBlinkToIncreaseDistance(
+					state.position,
+					enemy.position,
+					state.projectiles,
+				) ?? getBlinkToCenter(state.position))
+				: getBlinkToCenter(state.position);
+		return {
+			move: {x: 0, y: 0},
+			startCast: {spell: 'blink', target},
+		};
+	}
+
+	// === STEP 4: SHIELD — undodgeable or critical threats ===
+	if (
+		state.state === 'idle' &&
+    urgentThreat &&
+    (!urgentThreat.bestDodgeDirection || shouldForceShield(urgentThreat))
+	) 
+	{
+		if (
+			urgentThreat.canBlockInTime &&
+      urgentThreat.ticksToStartShield <= SHIELD_BUFFER
+		) 
+		{
+			return {
+				move: {x: 0, y: 0},
+				startCast: {spell: 'shield'},
+			};
+		}
+	}
+
+	// === STEP 5: PROACTIVE DISTANCE BLINK ===
+	if (
+		state.state === 'idle' &&
+    state.blinkCooldown === 0 &&
+    (!urgentThreat || urgentThreat.bestDodgeDirection !== null)
+	) 
+	{
+		const closingRate = getClosingRate(
+			state.position,
+			enemy.position,
+			enemy.velocity,
+		);
+		if (
+			(closingRate > closingRateThreshold && distance < proactiveBlinkRange) ||
+      distance < dangerDistance
+		) 
+		{
+			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 6: OFFENSE ===
+	if (state.state === 'idle' && distance < 600) 
+	{
+		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: intercept-aimed straight missiles during vulnerability ---
+		if (
+			vulnerabilityTicks >= punishMinVulnerability &&
+      distance < punishAttackRange
+		) 
+		{
+			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,
+							startCast: {
+								spell: 'missile',
+								config,
+								missileAI: config.turnRate > 0 ? HomingAI : StraightAI,
+								direction: angleTo(state.position, aimTarget),
+							},
+						};
+					}
+				}
+			}
+		}
+
+		// --- STANDARD MODE: adaptive homing missiles ---
+		let nextThreatTime = urgentThreat?.ticksToImpact ?? Infinity;
+
+		// Anticipate enemy's next missile based on their current state
+		if (enemy.state === 'casting' && enemy.castingSpell === 'missile') 
+		{
+			const remainingEnemyCast =
+				(enemy.castDuration ?? 0) - (enemy.castProgress ?? 0);
+			nextThreatTime = Math.min(
+				nextThreatTime,
+				remainingEnemyCast + distance / castingFlightTimeDivisor,
+			);
+		}
+		// No imminent threat — estimate enemy's likely response time
+		if (nextThreatTime > threatFallbackThreshold) 
+		{
+			const enemyLockTime = getEnemyVulnerabilityTicks(enemy);
+			nextThreatTime = Math.min(
+				nextThreatTime,
+				enemyLockTime +
+          enemyResponseEstimate +
+          distance / castingFlightTimeDivisor,
+			);
+		}
+
+		const safeBudget =
+			nextThreatTime - GCD_DURATION - SHIELD_CAST_TIME - SHIELD_BUFFER;
+		const budgetTicks = Math.min(safeBudget, MAX_CAST_BUDGET);
+
+		const config = fitMissileToBudget(budgetTicks, distance, {
+			minTurnRate,
+			maxDamage: enemyHP,
+			lastMissileConfig: state.lastMissileConfig,
+		});
+
+		// HIGH-DAMAGE PRIORITY: Sniper missiles need meaningful shield chip.
+		// Fixed big-shot fallback ensures Spellseeker always does significant damage.
+		const BIG_SHOT = {damage: 28, speed: 10, turnRate: 0.5, duration: 80};
+
+		if (
+			config &&
+      config.damage >= 15 &&
+      isSafeToAttack(threats, safeAttackCastEstimate)
+		)
+		{
+			return {
+				move,
+				startCast: {
+					spell: 'missile',
+					config,
+					missileAI: HomingAI,
+					direction: angleTo(state.position, enemy.position),
+				},
+			};
+		}
+
+		// Adaptive fitting weak or failed — fire big shot for meaningful damage
+		if (!urgentThreat || urgentThreat.ticksToImpact > 50)
+		{
+			return {
+				move,
+				startCast: {
+					spell: 'missile',
+					config: BIG_SHOT,
+					missileAI: HomingAI,
+					direction: angleTo(state.position, enemy.position),
+				},
+			};
+		}
+	}
+
+	return {move};
+};

package/src/bots/standalone/Critter.ts

@@ -0,0 +1,89 @@
+import {WizardFunction} from '../../types.js';
+import {ARENA_WIDTH, ARENA_HEIGHT} from '../../rules.js';
+
+/**
+ * Bot: Critter
+ *
+ * BEHAVIOR: Picks random valid actions each tick — random movement, random spells,
+ * random missile configs, random directions. Occasionally cancels its own casts.
+ * Uses engine-provided seeded random for deterministic behavior. Useful for
+ * finding edge cases in the engine, but completely useless in combat.
+ *
+ * NAMING RATIONALE: In WoW, critters are the 1-HP ambient mobs (rabbits, squirrels,
+ * prairie dogs) that wander around doing nothing useful and die to literally anything.
+ * This bot is the wizard equivalent — it flails around randomly and gets destroyed by
+ * anyone with a plan. The word "Critter" immediately tells any gamer "this thing is
+ * helpless and exists only to fill space."
+ *
+ * STANDALONE — no tier progression. Critters don't level up. However, a future
+ * "Hogger" bot could be an elite critter: same chaotic spirit but actually dangerous
+ * (like the famous WoW elite that wipes unprepared lowbies).
+ */
+export const Critter: WizardFunction = ({state, random}) => 
+{
+	// Use the engine-provided random function (seeded, isolated, deterministic)
+	// World-space movement: random x/y in [-100, 100] range
+	const move = {
+		x: random() * 200 - 100, // -100 to 100
+		y: random() * 200 - 100, // -100 to 100
+	};
+
+	if (state.state === 'idle' && random() > 0.95) 
+	{
+		const spellRoll = random();
+		if (spellRoll > 0.6) 
+		{
+			return {
+				move,
+				startCast: {
+					spell: 'missile',
+					config: {
+						damage: Math.floor(random() * 20) + 5,
+						speed: random() * 5 + 2,
+						turnRate: random() * 3,
+						duration: Math.floor(random() * 200) + 100,
+					},
+					// Missile AI gets its own random from engine - use it for random targeting
+					missileAI: ({random: missileRandom}) => ({
+						turnToward:
+              missileRandom() > 0.5
+              	? {
+              		x: missileRandom() * ARENA_WIDTH,
+              		y: missileRandom() * ARENA_HEIGHT,
+              	}
+              	: undefined,
+					}),
+					direction: random() * 360,
+				},
+			};
+		}
+		else if (spellRoll > 0.3) 
+		{
+			return {
+				move,
+				startCast: {spell: 'shield'},
+			};
+		}
+		else if (state.blinkCooldown === 0) 
+		{
+			return {
+				move,
+				startCast: {
+					spell: 'blink',
+					target: {x: random() * ARENA_WIDTH, y: random() * ARENA_HEIGHT},
+				},
+			};
+		}
+	}
+
+	if (
+		(state.state === 'casting' || state.state === 'channeling') &&
+    random() > 0.98
+	) 
+	{
+		return {move, cancel: true};
+	}
+
+	// Override auto-aim with random direction — Critter doesn't know where anything is
+	return {move, aimDirection: random() * 360};
+};

package/src/bots/standalone/Doombringer.ts

@@ -0,0 +1,91 @@
+import {WizardFunction, MissileAIFunction} from '../../types.js';
+import {angleTo} from '../../utils/angles.js';
+import {distanceTo} from '../../utils/distance.js';
+import {fitMissileToBudget} from '../../utils/combat.js';
+import {
+	getThreats,
+	getMostUrgentThreat,
+	getBlinkToCenter,
+} from '../shared.js';
+
+const HomingAI: MissileAIFunction = ({worldState}) => 
+{
+	const enemy = worldState.enemies[0];
+	return {turnToward: enemy?.position};
+};
+
+/**
+ * Bot: Doombringer
+ *
+ * BEHAVIOR: Fires a single maximum-damage homing missile with infinite budget.
+ * No damage cap — goes for the biggest possible hit. Exists as a benchmark to
+ * demonstrate why lower-damage + shield play is superior. Has basic shield
+ * defense but no sophisticated tactics. One fat cast, one fat hit.
+ *
+ * STANDALONE — no tier progression. Benchmark/test bot.
+ */
+export const Doombringer: WizardFunction = ({state}) => 
+{
+	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);
+
+	// === DEFENSE: Handle channeling ===
+	if (state.state === 'channeling') 
+	{
+		if (!urgentThreat || urgentThreat.ticksToImpact > 150) 
+		{
+			return {move: {x: 0, y: 0}, cancel: true};
+		}
+		return {move: {x: 0, y: 0}};
+	}
+
+	// === DEFENSE: Shield undodgeable threats ===
+	if (
+		state.state === 'idle' &&
+    urgentThreat &&
+    !urgentThreat.bestDodgeDirection
+	) 
+	{
+		if (urgentThreat.canBlockInTime && urgentThreat.ticksToStartShield <= 3) 
+		{
+			return {
+				move: {x: 0, y: 0},
+				startCast: {spell: 'shield'},
+			};
+		}
+		else if (!urgentThreat.canBlockInTime && state.blinkCooldown === 0) 
+		{
+			return {
+				move: {x: 0, y: 0},
+				startCast: {spell: 'blink', target: getBlinkToCenter(state.position)},
+			};
+		}
+	}
+
+	// === OFFENSE: Fire max-damage homing missile (no damage cap) ===
+	if (state.state === 'idle') 
+	{
+		const config = fitMissileToBudget(Infinity, distance, {minTurnRate: 0.5});
+		if (config) 
+		{
+			return {
+				move: {x: 0, y: 0},
+				startCast: {
+					spell: 'missile',
+					config,
+					missileAI: HomingAI,
+					direction: angleTo(state.position, enemy.position),
+				},
+			};
+		}
+	}
+
+	return {move: {x: 0, y: 0}};
+};