@vibemancer/core 0.1.0

package/src/bots/kiter/01_Spellspinner.ts

@@ -0,0 +1,398 @@
+import {WizardFunction, MissileAIFunction} from '../../types.js';
+import {angleTo} from '../../utils/angles.js';
+import {distanceTo} from '../../utils/distance.js';
+import {getMissileCastTime} from '../../utils/combat.js';
+import {ARENA_SIZE, GCD_DURATION} from '../../rules.js';
+import {
+	getThreats,
+	getMostUrgentThreat,
+	getDodgeDirectionForMovement,
+	isSafeToAttack,
+	getBlinkToCenter,
+	getBlinkToIncreaseDistance,
+	MIN_BLINK_ESCAPE_DISTANCE,
+	shouldForceShield,
+} from '../shared.js';
+import {useParam} from '../../engine/params-runtime.js';
+const WALL_BUFFER = 60;
+
+/**
+ * Standard homing missile: higher damage, good range. s=5 × dur=150 = 750u range.
+ */
+const STANDARD_CONFIG = {damage: 15, speed: 5, turnRate: 1, duration: 150};
+
+/**
+ * Quick homing missile for firing under pressure.
+ * Similar speed/turn for warmup compatibility.
+ */
+const QUICK_CONFIG = {damage: 10, speed: 5, turnRate: 1, duration: 80};
+
+/**
+ * Standard homing missile AI.
+ */
+const HomingAI: MissileAIFunction = ({worldState}) => 
+{
+	const enemy = worldState.enemies[0];
+	return {
+		turnToward: enemy?.position,
+	};
+};
+
+/**
+ * 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};
+
+	// Perpendicular directions
+	const strafeClockwise = {
+		x: -deltaY / normalizedDistance,
+		y: deltaX / normalizedDistance,
+	};
+	const strafeCounterClockwise = {
+		x: deltaY / normalizedDistance,
+		y: -deltaX / normalizedDistance,
+	};
+
+	let strafeDir: {x: number; y: number};
+
+	// Priority 1: Use dodge direction (from threat analysis or close missile avoidance)
+	if (dodgeDirection) 
+	{
+		strafeDir = dodgeDirection;
+	}
+	// Priority 2: Avoid walls
+	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;
+	}
+	// Priority 3: Commit to direction (switch every ~200 ticks)
+	else 
+	{
+		const cycle = Math.floor(tick / strafeCyclePeriod) % 2;
+		strafeDir = cycle === 0 ? strafeClockwise : strafeCounterClockwise;
+	}
+
+	// When actively dodging, commit fully — no approach/retreat dilution
+	const intensity = dodgeDirection ? 100 : strafeIntensity;
+	return {x: strafeDir.x * intensity, y: strafeDir.y * intensity};
+}
+
+/**
+ * Bot: Spellspinner
+ *
+ * BEHAVIOR: Maintains medium range (350 units), strafes constantly to dodge
+ * missiles, and fires homing missiles (damage 10, speed 4, turnRate 2). Heavy
+ * emphasis on movement — 80% strafe intensity when not dodging, 100% when dodging.
+ * Shields only undodgeable threats, emergency blinks when shield isn't available.
+ * The constant circular strafing motion traces patterns like thread being spun.
+ *
+ * NAMING RATIONALE: Like a spider spinning a web of projectiles while circling its
+ * prey. The constant strafing movement pattern traces circles — spinning thread
+ * around the arena. "Spell" + "spinner" = a wizard who spins spells around the
+ * battlefield. The kiting behavior (maintaining distance while attacking) creates
+ * a web-like pattern of missiles and movement that traps opponents.
+ *
+ * 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): Future — inescapable web of magic, perfect distance control
+ * The progression: spinner (raw thread) → weaver (creates patterns) → binder
+ * (constrains and traps). Each tier's projectile web becomes harder to escape.
+ *
+ * TIER: 1 (base)
+ */
+export const Spellspinner: WizardFunction = ({state}) => 
+{
+	const targetDistance = useParam('targetDistance', 338, {
+		range: 150,
+		min: 150,
+		max: 450,
+	});
+	const dangerDistance = useParam('dangerDistance', 242, {
+		range: 100,
+		min: 100,
+	});
+	const strafeCyclePeriod = useParam('strafeCyclePeriod', 210, {
+		range: 75,
+		min: 80,
+		max: 300,
+	});
+	const strafeIntensity = useParam('strafeIntensity', 31, {
+		range: 40,
+		min: 30,
+		max: 100,
+		steps: 7,
+	});
+	const approachSpeed = useParam('approachSpeed', 25, {
+		range: 30,
+		min: 10,
+		max: 70,
+		steps: 7,
+	});
+	const distanceDeadZone = useParam('distanceDeadZone', 40, {
+		range: 30,
+		min: 5,
+		max: 80,
+		steps: 7,
+	});
+	const shieldCancelThreshold = useParam('shieldCancelThreshold', 150, {
+		range: 75,
+		min: 50,
+		max: 300,
+	});
+	const blinkWindowMax = useParam('blinkWindowMax', 68, {
+		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);
+
+	// Analyze threats using simulation
+	const threats = getThreats(state);
+	const urgentThreat = getMostUrgentThreat(threats);
+
+	// Smart strafe (dodge direction includes close homing missile avoidance)
+	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;
+		}
+	}
+
+	// Normalize
+	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') 
+	{
+		// Cancel shield if no imminent threats
+		if (!urgentThreat || urgentThreat.ticksToImpact > shieldCancelThreshold) 
+		{
+			return {move, cancel: true};
+		}
+		return {move: {x: 0, y: 0}}; // Hold shield if still threatened
+	}
+
+	// === DEFENSE: Cancel missile cast if lethal threat arrives during GCD ===
+	if (
+		state.state === 'casting' &&
+    state.castingSpell === 'missile' &&
+    urgentThreat
+	) 
+	{
+		const remainingCast = (state.castDuration ?? 0) - (state.castProgress ?? 0);
+		const arrivesInGCD =
+			urgentThreat.ticksToImpact > remainingCast &&
+      urgentThreat.ticksToImpact <= remainingCast + GCD_DURATION;
+
+		if (
+			arrivesInGCD &&
+      state.health <= urgentThreat.projectile.damage + 1 &&
+      remainingCast > 10
+		) 
+		{
+			return {move, cancel: true};
+		}
+	}
+
+	// === BLINK-DODGE: For undodgeable threats OR to create attack window ===
+	// Blink to center (stays in combat range) and dodges the current missile.
+	// Also blink when persistent threats block all offense (creates safe firing window).
+	if (
+		state.state === 'idle' &&
+    urgentThreat &&
+    state.blinkCooldown === 0 &&
+    urgentThreat.ticksToImpact >= 10 &&
+    urgentThreat.ticksToImpact <= blinkWindowMax
+	) 
+	{
+		const undodgeableOrForced =
+			!urgentThreat.bestDodgeDirection || shouldForceShield(urgentThreat);
+		const cannotAttack = !isSafeToAttack(
+			threats,
+			getMissileCastTime(QUICK_CONFIG),
+		);
+
+		if (undodgeableOrForced || cannotAttack) 
+		{
+			return {
+				move: {x: 0, y: 0},
+				startCast: {spell: 'blink', target: getBlinkToCenter(state.position)},
+			};
+		}
+	}
+
+	// === DEFENSE: Shield undodgeable/high-damage threats (when blink on cooldown) ===
+	if (
+		state.state === 'idle' &&
+    urgentThreat &&
+    (!urgentThreat.bestDodgeDirection || shouldForceShield(urgentThreat))
+	) 
+	{
+		if (urgentThreat.canBlockInTime) 
+		{
+			if (urgentThreat.ticksToStartShield <= 3) 
+			{
+				return {
+					move: {x: 0, y: 0},
+					startCast: {spell: 'shield'},
+				};
+			}
+		}
+	}
+
+	// === 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: Attack when safe ===
+	if (state.state === 'idle' && distance < 500) 
+	{
+		// Primary: standard homing missile
+		const standardCastTime = getMissileCastTime(STANDARD_CONFIG);
+		if (isSafeToAttack(threats, standardCastTime)) 
+		{
+			return {
+				move,
+				startCast: {
+					spell: 'missile',
+					config: STANDARD_CONFIG,
+					missileAI: HomingAI,
+					direction: angleTo(state.position, enemy.position),
+				},
+			};
+		}
+
+		// Fallback: quick missile under pressure
+		const quickCastTime = getMissileCastTime(QUICK_CONFIG);
+		if (isSafeToAttack(threats, quickCastTime)) 
+		{
+			return {
+				move,
+				startCast: {
+					spell: 'missile',
+					config: QUICK_CONFIG,
+					missileAI: HomingAI,
+					direction: angleTo(state.position, enemy.position),
+				},
+			};
+		}
+	}
+
+	return {move};
+};