@vibemancer/core 0.1.0

package/src/bots/caster/03_Infernalist.ts

@@ -0,0 +1,492 @@
+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,
+	isSafeToAttack,
+	getBlinkToIncreaseDistance,
+	fitMissileToBudget,
+	shouldForceShield,
+	MIN_BLINK_ESCAPE_DISTANCE,
+	MAX_CAST_BUDGET,
+	MIN_USEFUL_DAMAGE,
+	getClosingRate,
+	getEnemyVulnerabilityTicks,
+} from '../shared.js';
+import {useParam} from '../../engine/params-runtime.js';
+
+const WALL_BUFFER = 60;
+const SHIELD_BUFFER = 3;
+
+const HomingAI: MissileAIFunction = ({worldState}) => 
+{
+	const enemy = worldState.enemies[0];
+	return {turnToward: enemy?.position};
+};
+
+const StraightAI: MissileAIFunction = () => ({});
+
+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 len = Math.sqrt(deltaX * deltaX + deltaY * deltaY);
+	if (len === 0) return {x: 0, y: 0};
+
+	const cw = {x: -deltaY / len, y: deltaX / len};
+	const ccw = {x: deltaY / len, y: -deltaX / len};
+
+	let dir: {x: number; y: number};
+
+	if (dodgeDirection) 
+	{
+		dir = dodgeDirection;
+	}
+	else if (isNearWall(position)) 
+	{
+		const fCw = {x: position.x + cw.x * 100, y: position.y + cw.y * 100};
+		const fCcw = {x: position.x + ccw.x * 100, y: position.y + ccw.y * 100};
+		const sCw = Math.min(fCw.x, ARENA_SIZE - fCw.x, fCw.y, ARENA_SIZE - fCw.y);
+		const sCcw = Math.min(
+			fCcw.x,
+			ARENA_SIZE - fCcw.x,
+			fCcw.y,
+			ARENA_SIZE - fCcw.y,
+		);
+		dir = sCw > sCcw ? cw : ccw;
+	}
+	else 
+	{
+		const cycle = Math.floor(tick / strafeCyclePeriod) % 2;
+		dir = cycle === 0 ? cw : ccw;
+	}
+
+	const intensity = dodgeDirection ? 100 : strafeIntensity;
+	return {x: dir.x * intensity, y: dir.y * intensity};
+}
+
+/**
+ * Bot: Infernalist
+ *
+ * BEHAVIOR: Rapid-fire caster that exploits warmup bonus for accelerating DPS.
+ * Fires consistent homing missiles to build warmup, punishes vulnerability windows
+ * with warmup-boosted fast casts. Proactive blink kiting when enemy closes.
+ *
+ * KEY IMPROVEMENTS OVER PYROMANCER:
+ * - Warmup exploitation: always passes lastMissileConfig for bonus
+ * - Punish mode: straight missiles during enemy vulnerability
+ * - Proactive blink kiting: monitors closing rate
+ * - Progressive cast-cancel: graduated thresholds
+ *
+ * PROGRESSION LINE: Flamecaller → Pyromancer → Infernalist
+ * TIER: 3 (elite Caster line)
+ */
+export const Infernalist: WizardFunction = ({state}) => 
+{
+	const targetDistance = useParam('targetDistance', 285, {range: 225, min: 0});
+	const minTurnRate = useParam('minTurnRate', 0.2, {range: 1.5, steps: 5});
+	const dangerDistance = useParam('dangerDistance', 222, {
+		range: 150,
+		min: 0,
+	});
+	const closingRateThreshold = useParam('closingRateThreshold', 0.94, {
+		range: 0.65,
+		min: 0,
+		steps: 5,
+	});
+	const punishMinVulnerability = useParam('punishMinVulnerability', 340, {
+		range: 30,
+		min: 10,
+		steps: 5,
+	});
+	const preferBlinkDodge =
+		useParam('preferBlinkDodge', 0, {min: 0, max: 1, steps: 2}) >= 0.5;
+	const strafeCyclePeriod = useParam('strafeCyclePeriod', 109, {
+		range: 75,
+		min: 80,
+		max: 250,
+	});
+	const strafeIntensity = useParam('strafeIntensity', 23, {
+		range: 40,
+		min: 20,
+		max: 100,
+		steps: 7,
+	});
+	const approachSpeed = useParam('approachSpeed', 53, {
+		range: 30,
+		min: 10,
+		max: 70,
+		steps: 7,
+	});
+	const distanceDeadZone = useParam('distanceDeadZone', 34, {
+		range: 30,
+		min: 5,
+		max: 80,
+		steps: 7,
+	});
+	const cancelHeavyDmg = useParam('cancelHeavyDmg', 40, {
+		range: 15,
+		min: 5,
+		max: 40,
+		steps: 5,
+	});
+	const cancelMediumDmg = useParam('cancelMediumDmg', 9, {
+		range: 10,
+		min: 3,
+		max: 25,
+		steps: 5,
+	});
+	const cancelCastRatio = useParam('cancelCastRatio', 0.78, {
+		range: 0.4,
+		min: 0.3,
+		max: 1.0,
+		steps: 5,
+	});
+	const shieldCancelThreshold = useParam('shieldCancelThreshold', 100, {
+		range: 75,
+		min: 50,
+		max: 300,
+	});
+	const blinkWindowMax = useParam('blinkWindowMax', 75, {
+		range: 40,
+		min: 20,
+		max: 120,
+		steps: 7,
+	});
+	const proactiveBlinkRange = useParam('proactiveBlinkRange', 100, {
+		range: 150,
+		min: 100,
+		max: 500,
+		steps: 7,
+	});
+	const flightTimeDivisor = useParam('flightTimeDivisor', 5.4, {
+		range: 4,
+		min: 2,
+		max: 12,
+		steps: 5,
+	});
+	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 with wall-aware retreat
+	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 norm = distance > 0 ? distance : 1;
+
+		if (distance > targetDistance + distanceDeadZone) 
+		{
+			moveX += (deltaX / norm) * approachSpeed;
+			moveY += (deltaY / norm) * approachSpeed;
+		}
+		else if (distance < targetDistance - distanceDeadZone) 
+		{
+			let rx = -(deltaX / norm) * approachSpeed;
+			let ry = -(deltaY / norm) * approachSpeed;
+			if (state.position.x < WALL_BUFFER && rx < 0) rx = 0;
+			if (state.position.x > ARENA_SIZE - WALL_BUFFER && rx > 0) rx = 0;
+			if (state.position.y < WALL_BUFFER && ry < 0) ry = 0;
+			if (state.position.y > ARENA_SIZE - WALL_BUFFER && ry > 0) ry = 0;
+			moveX += rx;
+			moveY += ry;
+		}
+	}
+
+	const mag = Math.sqrt(moveX * moveX + moveY * moveY);
+	if (mag > 100) 
+	{
+		moveX = (moveX / mag) * 100;
+		moveY = (moveY / mag) * 100;
+	}
+
+	const move = {x: moveX, y: moveY};
+
+	// === STEP 1: CHANNELING ===
+	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 >= cancelHeavyDmg) 
+			{
+				return {move, cancel: true};
+			}
+			if (incomingDamage >= cancelMediumDmg && castRatio < cancelCastRatio) 
+			{
+				return {move, cancel: true};
+			}
+		}
+	}
+
+	// === BLINK-DODGE — optimizer-controlled alternative to shield ===
+	if (
+		preferBlinkDodge &&
+    state.state === 'idle' &&
+    urgentThreat &&
+    state.blinkCooldown === 0 &&
+    (!urgentThreat.bestDodgeDirection || shouldForceShield(urgentThreat)) &&
+    urgentThreat.ticksToImpact >= BLINK_CAST_TIME &&
+    urgentThreat.ticksToImpact <= blinkWindowMax
+	) 
+	{
+		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 3: SHIELD — undodgeable or high-damage homing 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 BLINK KITING ===
+	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') 
+	{
+		const enemyHP = Math.ceil(enemy.health);
+		const vulnerabilityTicks = getEnemyVulnerabilityTicks(enemy);
+
+		// --- PUNISH MODE: warmup-accelerated missiles during vulnerability ---
+		if (vulnerabilityTicks >= punishMinVulnerability && distance < 500) 
+		{
+			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 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: warmup-consistent homing missiles ---
+		const nextThreatTime = urgentThreat?.ticksToImpact ?? Infinity;
+		const safeBudget =
+			nextThreatTime - GCD_DURATION - SHIELD_CAST_TIME - SHIELD_BUFFER;
+		const budgetTicks = Math.min(safeBudget, MAX_CAST_BUDGET);
+
+		const minDmg = Math.min(MIN_USEFUL_DAMAGE, enemyHP);
+		let config = fitMissileToBudget(budgetTicks, distance, {
+			minTurnRate,
+			maxDamage: enemyHP,
+			lastMissileConfig: state.lastMissileConfig,
+		});
+
+		if (
+			config &&
+      config.damage >= minDmg &&
+      isSafeToAttack(threats, safeAttackCastEstimate)
+		) 
+		{
+			return {
+				move,
+				startCast: {
+					spell: 'missile',
+					config,
+					missileAI: HomingAI,
+					direction: angleTo(state.position, enemy.position),
+				},
+			};
+		}
+
+		// Fallback: fire bigger missile, accept incoming hit
+		if (!config || config.damage < minDmg) 
+		{
+			config = fitMissileToBudget(MAX_CAST_BUDGET, distance, {
+				minTurnRate,
+				maxDamage: enemyHP,
+				lastMissileConfig: state.lastMissileConfig,
+			});
+			if (config) 
+			{
+				return {
+					move,
+					startCast: {
+						spell: 'missile',
+						config,
+						missileAI: HomingAI,
+						direction: angleTo(state.position, enemy.position),
+					},
+				};
+			}
+		}
+	}
+
+	return {move};
+};

package/src/bots/defensive/01_Turtle.ts

@@ -0,0 +1,151 @@
+import {WizardFunction} from '../../types.js';
+import {angleTo} from '../../utils/angles.js';
+import {GCD_DURATION, SHIELD_CAST_TIME} from '../../rules.js';
+import {getMissileCastTime} from '../../utils/combat.js';
+import {
+	getThreats,
+	getMostUrgentThreat,
+	getBlinkToCenter,
+} from '../shared.js';
+import {useParam} from '../../engine/params-runtime.js';
+
+/**
+ * Bot: Turtle
+ *
+ * BEHAVIOR: Stationary tank with a simple defense-first loop: shield → missile
+ * → wait → shield → repeat. Never moves. Always prioritizes having shield
+ * ready over dealing damage.
+ *
+ * COMBAT LOOP:
+ * 1. Incoming missile? → Shield immediately (cancel anything else)
+ * 2. Hold shield until missile has actually impacted (don't cancel early!)
+ * 3. Cancel shield → GCD → Fire one missile → GCD → idle
+ * 4. Wait idle for next threat
+ * 5. Goto 1
+ *
+ * CRITICAL: Does NOT cancel shield until incoming missiles have impacted.
+ * Shield must be held through impact to actually block damage.
+ *
+ * Uses damage 10, speed 5, turnRate 1, duration 180 (~81 tick cast).
+ * Emergency blinks toward center when caught in GCD with unavoidable hit.
+ *
+ * NAMING RATIONALE: "Turtling" is the universal gaming term for extreme
+ * defensive play. Sits still and blocks everything.
+ *
+ * PROGRESSION LINE: Turtle → Sentinel → Golem
+ * - Turtle (tier 1): Stationary, fixed missiles, always-shield-first
+ * - Sentinel (tier 2): Stationary, adaptive missile fitting (fitMissileToBudget)
+ * - Golem (tier 3): Future — immovable fortress, perfect timing, punishing hits
+ *
+ * TIER: 1 (base)
+ */
+
+// Homing missile: damage 12, speed 5, turnRate 1, duration 180.
+// Range = 5 × 180 = 900 units.
+const MISSILE_CONFIG = {damage: 12, speed: 5, turnRate: 1, duration: 180};
+
+export const Turtle: WizardFunction = ({state}) => 
+{
+	const shieldBuffer = useParam('shieldBuffer', 3.1, {
+		range: 5,
+		min: 0,
+		steps: 5,
+	});
+	const shieldHoldTicks = useParam('shieldHoldTicks', 5, {
+		range: 5,
+		min: 0,
+		steps: 5,
+	});
+	const ticksToReshield = SHIELD_CAST_TIME + shieldBuffer;
+
+	const enemy = state.enemies[0];
+	if (!enemy) return {move: {x: 0, y: 0}};
+
+	const threats = getThreats(state);
+	const urgentThreat = getMostUrgentThreat(threats);
+
+	const shouldStartShield =
+		urgentThreat !== null &&
+    urgentThreat.ticksToImpact <= SHIELD_CAST_TIME + shieldBuffer;
+
+	// === CHANNELING SHIELD ===
+	// Hold shield until the imminent missile(s) have actually impacted.
+	if (state.state === 'channeling' && state.channelingSpell === 'shield') 
+	{
+		// Don't cancel while a missile is about to hit
+		const imminentThreat = threats.find(
+			(t) => t.willHit && t.ticksToImpact <= shieldHoldTicks,
+		);
+		if (imminentThreat) 
+		{
+			return {move: {x: 0, y: 0}};
+		}
+
+		// Safe to cancel if no next threat, or next threat is far enough to reshield
+		const nextThreat = threats.find((t) => t.willHit);
+		if (!nextThreat || nextThreat.ticksToImpact > ticksToReshield) 
+		{
+			return {move: {x: 0, y: 0}, cancel: true};
+		}
+		// Next threat too soon — keep channeling
+		return {move: {x: 0, y: 0}};
+	}
+
+	// === CASTING SHIELD: let it finish ===
+	if (state.state === 'casting' && state.castingSpell === 'shield') 
+	{
+		return {move: {x: 0, y: 0}};
+	}
+
+	// === NEED TO SHIELD NOW: cancel anything else ===
+	if (shouldStartShield) 
+	{
+		if (state.state === 'casting') 
+		{
+			return {move: {x: 0, y: 0}, cancel: true};
+		}
+		if (state.state === 'idle') 
+		{
+			return {move: {x: 0, y: 0}, startCast: {spell: 'shield'}};
+		}
+	}
+
+	// === EMERGENCY BLINK: missile too close for shield, blink available ===
+	if (
+		state.state === 'idle' &&
+    urgentThreat &&
+    urgentThreat.ticksToImpact < SHIELD_CAST_TIME + shieldBuffer &&
+    urgentThreat.ticksToImpact >= 10 &&
+    state.blinkCooldown === 0
+	) 
+	{
+		return {
+			move: {x: 0, y: 0},
+			startCast: {spell: 'blink', target: getBlinkToCenter(state.position)},
+		};
+	}
+
+	// === ATTACK: one missile if safe window exists ===
+	// Dynamic safe window: actual cast time (with warmup) + GCD + shield + buffer
+	const castTime = getMissileCastTime(MISSILE_CONFIG, state.lastMissileConfig);
+	const safeWindow = castTime + GCD_DURATION + SHIELD_CAST_TIME + shieldBuffer;
+	if (
+		state.state === 'idle' &&
+    (!urgentThreat || urgentThreat.ticksToImpact > safeWindow)
+	) 
+	{
+		return {
+			move: {x: 0, y: 0},
+			startCast: {
+				spell: 'missile',
+				config: MISSILE_CONFIG,
+				missileAI: ({worldState}) => ({
+					turnToward: worldState.enemies[0]?.position,
+				}),
+				direction: angleTo(state.position, enemy.position),
+			},
+		};
+	}
+
+	return {move: {x: 0, y: 0}};
+};