@vibemancer/core 0.1.0

package/src/bots/kiter/03_Spellbinder.ts

@@ -0,0 +1,448 @@
+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, getLeadPosition} from '../../utils/combat.js';
+import {
+	getThreats,
+	getMostUrgentThreat,
+	getDodgeDirectionForMovement,
+	getBlinkToCenter,
+	getBlinkToIncreaseDistance,
+	fitMissileToBudget,
+	MIN_BLINK_ESCAPE_DISTANCE,
+	shouldForceShield,
+	MAX_CAST_BUDGET,
+	MIN_USEFUL_DAMAGE,
+	getEnemyVulnerabilityTicks,
+} from '../shared.js';
+import {useParam} from '../../engine/params-runtime.js';
+const WALL_BUFFER = 60;
+
+const SHIELD_BUFFER = 3;
+
+/**
+ * Standard homing missile AI.
+ */
+const HomingAI: MissileAIFunction = ({worldState}) =>
+{
+	const enemy = worldState.enemies[0];
+	return {
+		turnToward: enemy?.position,
+	};
+};
+
+/**
+ * Straight missile AI — no homing, flies in initial direction.
+ */
+const StraightAI: MissileAIFunction = () => ({});
+
+/**
+ * Check if near wall.
+ */
+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 strafe with threat-aware dodging and wall avoidance.
+ */
+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: Spellbinder
+ *
+ * BEHAVIOR: Enhanced Spellweaver with vulnerability exploitation. Same medium-range
+ * kiting playstyle — maintains distance, strafes heavily, uses fitMissileToBudget
+ * for adaptive homing missiles. The T3 upgrade adds a punish mode that fires fast
+ * straight missiles timed to land while the enemy is locked in a cast or GCD,
+ * when they cannot shield. Defense, movement, and standard offense are identical
+ * to Spellweaver.
+ *
+ * NAMING RATIONALE: A binder constrains and locks down opponents. Where the
+ * Spellweaver optimizes missile patterns (adaptive fitting), the Spellbinder
+ * reads the enemy's state and punishes vulnerability windows — binding them
+ * to their commitments with unavoidable damage.
+ *
+ * PROGRESSION LINE: Spellspinner → Spellweaver → Spellbinder
+ * - Spellspinner (tier 1): Fixed homing missiles, constant strafe, basic defense
+ * - Spellweaver (tier 2): + adaptive missile fitting, more sophisticated patterns
+ * - Spellbinder (tier 3): + vulnerability punish mode with fast straight missiles
+ *
+ * TIER: 3 (elite Spellspinner line)
+ */
+export const Spellbinder: WizardFunction = ({state}) =>
+{
+	const targetDistance = useParam('targetDistance', 134, {
+		range: 150,
+		min: 0,
+	});
+	const dangerDistance = useParam('dangerDistance', 389, {
+		range: 125,
+		min: 0,
+	});
+	const minTurnRate = useParam('minTurnRate', 0.2, {range: 1.5, steps: 5});
+	const strafeCyclePeriod = useParam('strafeCyclePeriod', 123, {
+		range: 75,
+		min: 80,
+		max: 300,
+	});
+	const strafeIntensity = useParam('strafeIntensity', 30, {
+		range: 40,
+		min: 30,
+		max: 100,
+		steps: 7,
+	});
+	const approachSpeed = useParam('approachSpeed', 50, {
+		range: 30,
+		min: 10,
+		max: 70,
+		steps: 7,
+	});
+	const distanceDeadZone = useParam('distanceDeadZone', 7, {
+		range: 30,
+		min: 5,
+		max: 80,
+		steps: 7,
+	});
+	const shieldCancelThreshold = useParam('shieldCancelThreshold', 150, {
+		range: 75,
+		min: 50,
+		max: 300,
+	});
+	const flightTimeDivisor = useParam('flightTimeDivisor', 10.8, {
+		range: 4,
+		min: 2,
+		max: 12,
+		steps: 5,
+	});
+	const punishMinVulnerability = useParam('punishMinVulnerability', 30, {
+		range: 80,
+		min: 30,
+		steps: 7,
+	});
+
+	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);
+
+	// Smart strafe
+	const dodgeDirection = getDodgeDirectionForMovement(threats, state.position);
+	const strafe = smartStrafe(
+		state.position,
+		enemy,
+		dodgeDirection,
+		state.tick,
+		strafeCyclePeriod,
+		strafeIntensity,
+	);
+
+	// Distance management (only when not dodging)
+	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)
+		{
+			let retreatX = -(deltaX / normalizedDistance) * approachSpeed;
+			let retreatY = -(deltaY / normalizedDistance) * approachSpeed;
+			if (state.position.x < WALL_BUFFER && retreatX < 0) retreatX = 0;
+			if (state.position.x > ARENA_SIZE - WALL_BUFFER && retreatX > 0)
+				retreatX = 0;
+			if (state.position.y < WALL_BUFFER && retreatY < 0) retreatY = 0;
+			if (state.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;
+	}
+
+	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: Cancel missile cast only 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};
+		}
+	}
+
+	// === 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)},
+			};
+		}
+	}
+
+	// === 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},
+			};
+		}
+	}
+
+	// === OFFENSE: Punish mode — fast straight missiles during enemy vulnerability ===
+	if (
+		state.state === 'idle' &&
+    getEnemyVulnerabilityTicks(enemy) >= punishMinVulnerability &&
+    distance < 500
+	)
+	{
+		const vulnerabilityTicks = getEnemyVulnerabilityTicks(enemy);
+		const flightTimeEstimate = distance / flightTimeDivisor;
+		const punishBudget = vulnerabilityTicks - flightTimeEstimate;
+		const nextThreatTime = urgentThreat?.ticksToImpact ?? Infinity;
+		const safeBudget =
+			nextThreatTime - GCD_DURATION - SHIELD_CAST_TIME - SHIELD_BUFFER;
+		const effectiveBudget = Math.min(
+			punishBudget,
+			safeBudget,
+			MAX_CAST_BUDGET,
+		);
+
+		if (effectiveBudget > 0)
+		{
+			const enemyHP = Math.ceil(enemy.health);
+			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)
+				{
+					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),
+						},
+					};
+				}
+			}
+		}
+	}
+
+	// === OFFENSE: Adaptive missile fitting (identical to Spellweaver) ===
+	// 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 < 600 && !hasNearbyLethalMissile)
+	{
+		let nextThreatTime = urgentThreat?.ticksToImpact ?? Infinity;
+
+		// Account for enemy's active cast
+		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);
+
+		// Spellbinder always uses homing in standard mode (kiting means enemies are always moving)
+		const enemyHP = Math.ceil(enemy.health);
+		const minDmg = Math.min(MIN_USEFUL_DAMAGE, enemyHP);
+		const config = fitMissileToBudget(budgetTicks, distance, {
+			minTurnRate,
+			maxDamage: enemyHP,
+			lastMissileConfig: state.lastMissileConfig,
+		});
+
+		if (config && config.damage >= minDmg)
+		{
+			return {
+				move,
+				startCast: {
+					spell: 'missile',
+					config,
+					missileAI: HomingAI,
+					direction: angleTo(state.position, enemy.position),
+				},
+			};
+		}
+
+		// Budget too small for useful missile — wait for threat to pass, then fire
+	}
+
+	return {move};
+};

package/src/bots/melee/01_Shadowblade.ts

@@ -0,0 +1,270 @@
+import {WizardFunction} from '../../types.js';
+import {distanceTo} from '../../utils/distance.js';
+import {ARENA_SIZE} from '../../rules.js';
+import {
+	getThreats,
+	getMostUrgentThreat,
+	getDodgeDirectionForMovement,
+	getBlinkToDecreaseDistance,
+	shouldForceShield,
+} from '../shared.js';
+import {useParam} from '../../engine/params-runtime.js';
+const WALL_BUFFER = 50;
+
+// Melee stab: 20 damage, speed 8, 3-hit kill.
+const STAB_CONFIG = {damage: 20, speed: 8, turnRate: 0, duration: 10};
+
+/**
+ * Aggressive movement: dodge missiles using threat analysis, 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 (melee wants to be in the enemy's face)
+	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: Shadowblade
+ *
+ * BEHAVIOR: Melee assassin. Blinks to the enemy, then lands devastating point-blank
+ * stab attacks (15 damage, 30u range, ~60 tick cast = 2-hit kill). Runs directly
+ * at the enemy with minimal strafe, shields undodgeable threats. The entire
+ * strategy is: get close, stab, kill. Simple and brutal.
+ *
+ * PROGRESSION LINE: Shadowblade → Nightblade → Voidblade
+ * - Shadowblade (tier 1): Offensive blink, melee stabs, basic shield
+ * - Nightblade (tier 2): + missile-aware blinks, adaptive stabs, timed defense
+ * - Voidblade (tier 3): Future — perfect assassination timing, inescapable engages
+ *
+ * TIER: 1 (base)
+ */
+export const Shadowblade: WizardFunction = ({state}) => 
+{
+	const stabRange = useParam('stabRange', 76, {
+		range: 30,
+		min: 20,
+		max: 80,
+		steps: 5,
+	});
+	const strafeCyclePeriod = useParam('strafeCyclePeriod', 252, {
+		range: 75,
+		min: 80,
+		max: 300,
+	});
+	const strafeIntensity = useParam('strafeIntensity', 55, {
+		range: 30,
+		min: 10,
+		max: 80,
+		steps: 7,
+	});
+	const approachSpeed = useParam('approachSpeed', 61, {
+		range: 20,
+		min: 50,
+		max: 100,
+		steps: 7,
+	});
+	const shieldCancelThreshold = useParam('shieldCancelThreshold', 150, {
+		range: 75,
+		min: 50,
+		max: 300,
+	});
+	const blinkWindowMax = useParam('blinkWindowMax', 23, {
+		range: 30,
+		min: 15,
+		max: 80,
+		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);
+
+	// Cancel shield if no longer needed
+	if (state.state === 'channeling') 
+	{
+		if (!urgentThreat || urgentThreat.ticksToImpact > shieldCancelThreshold) 
+		{
+			return {move: {x: 0, y: 0}, cancel: true};
+		}
+		return {move: {x: 0, y: 0}};
+	}
+
+	if (state.state === 'idle') 
+	{
+		// === BLINK: Dodge missile + close gap simultaneously (first priority) ===
+		// Wait until the missile is close (<=40 ticks) so the blink actually dodges it.
+		// Blinking too early means the missile can still re-track. Too late (<10) and the
+		// blink cast won't complete in time.
+		if (
+			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},
+			};
+		}
+
+		// Pre-stab shield: already at melee range, survival beats landing another stab.
+		// Gated to stab range so out-of-range threats wait for the blink window.
+		if (
+			urgentThreat &&
+      distance < stabRange &&
+      (!urgentThreat.bestDodgeDirection || shouldForceShield(urgentThreat)) &&
+      urgentThreat.canBlockInTime &&
+      urgentThreat.ticksToStartShield <= 3
+		)
+		{
+			return {
+				move: {x: 0, y: 0},
+				startCast: {spell: 'shield'},
+			};
+		}
+
+		// Melee stab when close enough (offense over defense at melee range)
+		if (distance < stabRange)
+		{
+			return {
+				move: {x: 0, y: 0},
+				startCast: {
+					spell: 'missile',
+					config: STAB_CONFIG,
+					missileAI: () => ({}), // Non-homing, point blank
+				},
+			};
+		}
+
+		// === DEFENSE: Shield undodgeable threats (only when blink can't handle it) ===
+		// Don't shield if blink is available — wait for the blink window instead.
+		if (
+			urgentThreat &&
+      (!urgentThreat.bestDodgeDirection || shouldForceShield(urgentThreat)) &&
+      urgentThreat.canBlockInTime &&
+      urgentThreat.ticksToStartShield <= 3 &&
+      (state.blinkCooldown > 0 || urgentThreat.ticksToImpact < 10)
+		)
+		{
+			return {
+				move: {x: 0, y: 0},
+				startCast: {spell: 'shield'},
+			};
+		}
+	}
+
+	// Aggressive movement — always close distance
+	const dodgeDirection = getDodgeDirectionForMovement(threats, state.position);
+	const move = aggressiveMove(
+		state.position,
+		enemy,
+		distance,
+		dodgeDirection,
+		state.tick,
+		strafeCyclePeriod,
+		strafeIntensity,
+		approachSpeed,
+	);
+	return {move};
+};