@vibemancer/core 0.1.4 → 0.1.6

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

@@ -1,15 +1,10 @@
-import {WizardFunction, MissileAIFunction} from '../../types.js';
+import type {FinalAction, MissileFunction} from '../../hooks/index.js';
+import {usePosition, useEnemy, useStatus, useBlinkCooldown, useHealth, useTick, useThreats, useProjectiles, useLastMissileConfig, useCastingSpell, useCastProgress, idle, move as moveAction, missile, shield, blink, cancel, getMissileContext, turnToward, flyStraight} from '../../hooks/index.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 {RULES, ARENA_MIN, ARENA_MAX} from '../../rules.js';
 import {getMissileCastTime, getLeadPosition} from '../../utils/combat.js';
 import {
-	getThreats,
 	getMostUrgentThreat,
 	getDodgeDirectionForMovement,
 	isSafeToAttack,
@@ -21,27 +16,30 @@ import {
 	MIN_USEFUL_DAMAGE,
 	getClosingRate,
 	getEnemyVulnerabilityTicks,
+	keepOffWalls,
+	getPreCastReposition,
 } from '../shared.js';
 import {useParam} from '../../engine/params-runtime.js';
 
 const WALL_BUFFER = 60;
 const SHIELD_BUFFER = 3;
 
-const HomingAI: MissileAIFunction = ({worldState}) => 
+const HomingAI: MissileFunction = () =>
 {
-	const enemy = worldState.enemies[0];
-	return {turnToward: enemy?.position};
+	const ctx = getMissileContext();
+	const enemy = ctx.worldState.enemies[0];
+	return enemy ? turnToward(enemy.position.x, enemy.position.y) : flyStraight();
 };
 
-const StraightAI: MissileAIFunction = () => ({});
+const StraightAI: MissileFunction = () => flyStraight();
 
 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
+		position.x < ARENA_MIN + WALL_BUFFER ||
+    position.x > ARENA_MAX - WALL_BUFFER ||
+    position.y < ARENA_MIN + WALL_BUFFER ||
+    position.y > ARENA_MAX - WALL_BUFFER
 	);
 }
 
@@ -72,12 +70,12 @@ function smartStrafe(
 	{
 		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 sCw = Math.min(fCw.x - ARENA_MIN, ARENA_MAX - fCw.x, fCw.y - ARENA_MIN, ARENA_MAX - fCw.y);
 		const sCcw = Math.min(
 			fCcw.x,
-			ARENA_SIZE - fCcw.x,
+			ARENA_MAX - fCcw.x,
 			fCcw.y,
-			ARENA_SIZE - fCcw.y,
+			ARENA_MAX - fCcw.y,
 		);
 		dir = sCw > sCcw ? cw : ccw;
 	}
@@ -87,7 +85,7 @@ function smartStrafe(
 		dir = cycle === 0 ? cw : ccw;
 	}
 
-	const intensity = dodgeDirection ? 100 : strafeIntensity;
+	const intensity = dodgeDirection ? 1 : strafeIntensity;
 	return {x: dir.x * intensity, y: dir.y * intensity};
 }
 
@@ -107,11 +105,24 @@ function smartStrafe(
  * PROGRESSION LINE: Flamecaller → Pyromancer → Infernalist
  * TIER: 3 (elite Caster line)
  */
-export const Infernalist: WizardFunction = ({state}) => 
+export function Infernalist(): FinalAction
 {
-	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, {
+	const position = usePosition();
+	const enemy = useEnemy();
+	const status = useStatus();
+	const blinkCooldown = useBlinkCooldown();
+	const health = useHealth();
+	const tick = useTick();
+	const threats = useThreats();
+	const projectiles = useProjectiles();
+	const lastMissileConfig = useLastMissileConfig();
+	const castingSpell = useCastingSpell();
+	const castProgressData = useCastProgress();
+
+
+	const targetDistance = useParam('targetDistance', 141, {range: 225, min: 0});
+	const minTurnRate = useParam('minTurnRate', 0.9, {range: 1.5, steps: 5});
+	const dangerDistance = useParam('dangerDistance', 332, {
 		range: 150,
 		min: 0,
 	});
@@ -125,61 +136,59 @@ export const Infernalist: WizardFunction = ({state}) =>
 		min: 10,
 		steps: 5,
 	});
-	const preferBlinkDodge =
-		useParam('preferBlinkDodge', 0, {min: 0, max: 1, steps: 2}) >= 0.5;
-	const strafeCyclePeriod = useParam('strafeCyclePeriod', 109, {
+	const strafeCyclePeriod = useParam('strafeCyclePeriod', 174, {
 		range: 75,
 		min: 80,
 		max: 250,
 	});
-	const strafeIntensity = useParam('strafeIntensity', 23, {
-		range: 40,
-		min: 20,
-		max: 100,
+	const strafeIntensity = useParam('strafeIntensity', 0.87, {
+		range: 0.4,
+		min: 0.2,
+		max: 1,
 		steps: 7,
 	});
-	const approachSpeed = useParam('approachSpeed', 53, {
-		range: 30,
-		min: 10,
-		max: 70,
+	const approachSpeed = useParam('approachSpeed', 0.66, {
+		range: 0.3,
+		min: 0.1,
+		max: 0.7,
 		steps: 7,
 	});
-	const distanceDeadZone = useParam('distanceDeadZone', 34, {
+	const distanceDeadZone = useParam('distanceDeadZone', 29, {
 		range: 30,
 		min: 5,
 		max: 80,
 		steps: 7,
 	});
-	const cancelHeavyDmg = useParam('cancelHeavyDmg', 40, {
+	const cancelHeavyDmg = useParam('cancelHeavyDmg', 31, {
 		range: 15,
 		min: 5,
 		max: 40,
 		steps: 5,
 	});
-	const cancelMediumDmg = useParam('cancelMediumDmg', 9, {
+	const cancelMediumDmg = useParam('cancelMediumDmg', 12, {
 		range: 10,
 		min: 3,
 		max: 25,
 		steps: 5,
 	});
-	const cancelCastRatio = useParam('cancelCastRatio', 0.78, {
+	const cancelCastRatio = useParam('cancelCastRatio', 0.77, {
 		range: 0.4,
 		min: 0.3,
 		max: 1.0,
 		steps: 5,
 	});
-	const shieldCancelThreshold = useParam('shieldCancelThreshold', 100, {
+	const shieldCancelThreshold = useParam('shieldCancelThreshold', 60, {
 		range: 75,
 		min: 50,
 		max: 300,
 	});
-	const blinkWindowMax = useParam('blinkWindowMax', 75, {
+	const blinkWindowMax = useParam('blinkWindowMax', 23, {
 		range: 40,
 		min: 20,
 		max: 120,
 		steps: 7,
 	});
-	const proactiveBlinkRange = useParam('proactiveBlinkRange', 100, {
+	const proactiveBlinkRange = useParam('proactiveBlinkRange', 175, {
 		range: 150,
 		min: 100,
 		max: 500,
@@ -191,28 +200,37 @@ export const Infernalist: WizardFunction = ({state}) =>
 		max: 12,
 		steps: 5,
 	});
-	const safeAttackCastEstimate = useParam('safeAttackCastEstimate', 35, {
-		range: 25,
-		min: 10,
-		max: 80,
+	const centerBias = useParam('centerBias', 0.13, {
+		range: 0.4,
+		min: 0,
+		max: 0.8,
 		steps: 5,
 	});
+	const maxBlinkDistance = useParam('maxBlinkDistance', 123, {
+		range: 100,
+		min: 50,
+		max: 300,
+		steps: 7,
+	});
 
-	const enemy = state.enemies[0];
-	if (!enemy) 
+	function capBlinkDistance(target: {x: number; y: number}): {x: number; y: number}
 	{
-		return {move: {x: 0, y: 0}};
+		const dx = target.x - position.x;
+		const dy = target.y - position.y;
+		const dist = Math.sqrt(dx * dx + dy * dy);
+		if (dist <= maxBlinkDistance) return target;
+		const scale = maxBlinkDistance / dist;
+		return {x: position.x + dx * scale, y: position.y + dy * scale};
 	}
 
-	const distance = distanceTo(state.position, enemy.position);
-	const threats = getThreats(state);
+	const distance = distanceTo(position, enemy.position);
 	const urgentThreat = getMostUrgentThreat(threats);
-	const dodgeDirection = getDodgeDirectionForMovement(threats, state.position);
+	const dodgeDirection = getDodgeDirectionForMovement(threats, position);
 	const strafe = smartStrafe(
-		state.position,
+		position,
 		enemy,
 		dodgeDirection,
-		state.tick,
+		tick,
 		strafeCyclePeriod,
 		strafeIntensity,
 	);
@@ -223,133 +241,158 @@ export const Infernalist: WizardFunction = ({state}) =>
 
 	if (!dodgeDirection) 
 	{
-		const deltaX = enemy.position.x - state.position.x;
-		const deltaY = enemy.position.y - state.position.y;
+		const deltaX = enemy.position.x - position.x;
+		const deltaY = enemy.position.y - position.y;
 		const norm = distance > 0 ? distance : 1;
 
-		if (distance > targetDistance + distanceDeadZone) 
+		if (distance > targetDistance + distanceDeadZone)
 		{
-			moveX += (deltaX / norm) * approachSpeed;
-			moveY += (deltaY / norm) * approachSpeed;
+			// Approach the center-side of the enemy so knockback pushes toward center, not lava.
+			const center = (ARENA_MIN + ARENA_MAX) / 2;
+			const toCenterX = center - enemy.position.x;
+			const toCenterY = center - enemy.position.y;
+			const toCenterDist = Math.sqrt(toCenterX * toCenterX + toCenterY * toCenterY) || 1;
+			const approachDirX = deltaX / norm + (toCenterX / toCenterDist) * centerBias;
+			const approachDirY = deltaY / norm + (toCenterY / toCenterDist) * centerBias;
+			const approachMag = Math.sqrt(approachDirX * approachDirX + approachDirY * approachDirY) || 1;
+			moveX += (approachDirX / approachMag) * approachSpeed;
+			moveY += (approachDirY / approachMag) * 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;
+			if (position.x < ARENA_MIN + WALL_BUFFER && rx < 0) rx = 0;
+			if (position.x > ARENA_MAX - WALL_BUFFER && rx > 0) rx = 0;
+			if (position.y < ARENA_MIN + WALL_BUFFER && ry < 0) ry = 0;
+			if (position.y > ARENA_MAX - WALL_BUFFER && ry > 0) ry = 0;
 			moveX += rx;
 			moveY += ry;
 		}
 	}
 
 	const mag = Math.sqrt(moveX * moveX + moveY * moveY);
-	if (mag > 100) 
+	if (mag > 1)
 	{
-		moveX = (moveX / mag) * 100;
-		moveY = (moveY / mag) * 100;
+		moveX = moveX / mag;
+		moveY = moveY / mag;
 	}
 
 	const move = {x: moveX, y: moveY};
+	const safeMove = keepOffWalls(position, move);
 
 	// === STEP 1: CHANNELING ===
-	if (state.state === 'channeling') 
+	if (status === 'channeling') 
 	{
 		if (!urgentThreat || urgentThreat.ticksToImpact > shieldCancelThreshold) 
 		{
-			return {move, cancel: true};
+			return cancel().move(safeMove.x, safeMove.y);
 		}
-		return {move: {x: 0, y: 0}};
+		return idle();
 	}
 
 	// === STEP 2: PROGRESSIVE CAST-CANCEL ===
 	if (
-		state.state === 'casting' &&
-    state.castingSpell === 'missile' &&
+		status === 'casting' &&
+    castingSpell === 'missile' &&
     urgentThreat &&
     !urgentThreat.bestDodgeDirection
 	) 
 	{
-		const remainingCast = (state.castDuration ?? 0) - (state.castProgress ?? 0);
+		const remainingCast = ((castProgressData?.total) ?? 0) - ((castProgressData?.current) ?? 0);
 		const defenseTime =
-			state.blinkCooldown === 0
-				? BLINK_CAST_TIME
-				: SHIELD_CAST_TIME + SHIELD_BUFFER;
+			blinkCooldown === 0
+				? RULES.BLINK_CAST_TIME
+				: RULES.SHIELD_CAST_TIME + SHIELD_BUFFER;
 		const willArriveInWindow =
-			urgentThreat.ticksToImpact <= remainingCast + GCD_DURATION + defenseTime;
+			urgentThreat.ticksToImpact <= remainingCast + RULES.GCD_DURATION + defenseTime;
 
 		if (willArriveInWindow) 
 		{
 			const incomingDamage = urgentThreat.projectile.damage;
-			const castRatio = (state.castProgress ?? 0) / (state.castDuration ?? 1);
+			const castRatio = ((castProgressData?.current) ?? 0) / ((castProgressData?.total) ?? 1);
 
-			if (incomingDamage >= state.health || incomingDamage >= cancelHeavyDmg) 
+			if (incomingDamage >= health || incomingDamage >= cancelHeavyDmg) 
 			{
-				return {move, cancel: true};
+				return cancel().move(safeMove.x, safeMove.y);
 			}
 			if (incomingDamage >= cancelMediumDmg && castRatio < cancelCastRatio) 
 			{
-				return {move, cancel: true};
+				return cancel().move(safeMove.x, safeMove.y);
 			}
 		}
 	}
 
-	// === BLINK-DODGE — optimizer-controlled alternative to shield ===
+	// === BLINK-DODGE — dodge undodgeable threats by blinking away ===
 	if (
-		preferBlinkDodge &&
-    state.state === 'idle' &&
-    urgentThreat &&
-    state.blinkCooldown === 0 &&
-    (!urgentThreat.bestDodgeDirection || shouldForceShield(urgentThreat)) &&
-    urgentThreat.ticksToImpact >= BLINK_CAST_TIME &&
-    urgentThreat.ticksToImpact <= blinkWindowMax
-	) 
+		status === 'idle' &&
+		urgentThreat &&
+		blinkCooldown === 0 &&
+		(!urgentThreat.bestDodgeDirection || shouldForceShield(urgentThreat)) &&
+		urgentThreat.ticksToImpact >= RULES.BLINK_CAST_TIME &&
+		urgentThreat.ticksToImpact <= blinkWindowMax
+	)
 	{
 		const blinkTarget = getBlinkToIncreaseDistance(
-			state.position,
+			position,
 			enemy.position,
-			state.projectiles,
+			projectiles,
 			MIN_BLINK_ESCAPE_DISTANCE,
 		);
-		if (blinkTarget) 
+		if (blinkTarget)
 		{
-			return {
-				move: {x: 0, y: 0},
-				startCast: {spell: 'blink', target: blinkTarget},
-			};
+			const capped = capBlinkDistance(blinkTarget);
+			return blink(capped.x, capped.y);
 		}
 	}
 
 	// === STEP 3: SHIELD — undodgeable or high-damage homing threats ===
 	if (
-		state.state === 'idle' &&
+		status === 'idle' &&
     urgentThreat &&
     (!urgentThreat.bestDodgeDirection || shouldForceShield(urgentThreat))
-	) 
+	)
 	{
+		if (urgentThreat.canBlockInTime && urgentThreat.ticksToStartShield <= SHIELD_BUFFER)
+		{
+			return shield();
+		}
+		if (urgentThreat.canBlockInTime)
+		{
+			return shield();
+		}
+	}
+
+	// === Preemptive shield — shield when enemy is casting a missile at close range ===
+	if (
+		status === 'idle' &&
+		distance < 300 &&
+		enemy.status === 'casting' &&
+		enemy.castingSpell === 'missile'
+	)
+	{
+		const remainingCast = (enemy.castDuration ?? 0) - (enemy.castProgress ?? 0);
+		const estimatedFlightTicks = distance / 8;
+		const ticksUntilHit = remainingCast + estimatedFlightTicks;
+
 		if (
-			urgentThreat.canBlockInTime &&
-      urgentThreat.ticksToStartShield <= SHIELD_BUFFER
-		) 
+			ticksUntilHit >= RULES.SHIELD_CAST_TIME &&
+			ticksUntilHit < RULES.SHIELD_CAST_TIME + 15
+		)
 		{
-			return {
-				move: {x: 0, y: 0},
-				startCast: {spell: 'shield'},
-			};
+			return shield();
 		}
 	}
 
 	// === STEP 5: PROACTIVE BLINK KITING ===
 	if (
-		state.state === 'idle' &&
-    state.blinkCooldown === 0 &&
+		status === 'idle' &&
+    blinkCooldown === 0 &&
     (!urgentThreat || urgentThreat.bestDodgeDirection !== null)
 	) 
 	{
 		const closingRate = getClosingRate(
-			state.position,
+			position,
 			enemy.position,
 			enemy.velocity,
 		);
@@ -359,24 +402,25 @@ export const Infernalist: WizardFunction = ({state}) =>
 		) 
 		{
 			const blinkTarget = getBlinkToIncreaseDistance(
-				state.position,
+				position,
 				enemy.position,
-				state.projectiles,
+				projectiles,
 				MIN_BLINK_ESCAPE_DISTANCE,
 			);
-			if (blinkTarget) 
+			if (blinkTarget)
 			{
-				return {
-					move: {x: 0, y: 0},
-					startCast: {spell: 'blink', target: blinkTarget},
-				};
+				const capped = capBlinkDistance(blinkTarget);
+				return blink(capped.x, capped.y);
 			}
 		}
 	}
 
 	// === STEP 6: OFFENSE ===
-	if (state.state === 'idle') 
+	if (status === 'idle')
 	{
+		const reposition = getPreCastReposition(position, enemy.position);
+		if (reposition) return moveAction(reposition.x, reposition.y);
+
 		const enemyHP = Math.ceil(enemy.health);
 		const vulnerabilityTicks = getEnemyVulnerabilityTicks(enemy);
 
@@ -387,7 +431,7 @@ export const Infernalist: WizardFunction = ({state}) =>
 			const punishBudget = vulnerabilityTicks - flightTimeEstimate;
 			const nextThreatTime = urgentThreat?.ticksToImpact ?? Infinity;
 			const safeBudget =
-				nextThreatTime - GCD_DURATION - SHIELD_CAST_TIME - SHIELD_BUFFER;
+				nextThreatTime - RULES.GCD_DURATION - RULES.SHIELD_CAST_TIME - SHIELD_BUFFER;
 			const effectiveBudget = Math.min(
 				punishBudget,
 				safeBudget,
@@ -399,12 +443,12 @@ export const Infernalist: WizardFunction = ({state}) =>
 				const config = fitMissileToBudget(effectiveBudget, distance, {
 					minTurnRate: 0,
 					maxDamage: enemyHP,
-					lastMissileConfig: state.lastMissileConfig,
+					lastMissileConfig: lastMissileConfig,
 				});
 
 				if (config && config.damage >= MIN_USEFUL_DAMAGE) 
 				{
-					const castTime = getMissileCastTime(config, state.lastMissileConfig);
+					const castTime = getMissileCastTime(config, lastMissileConfig);
 					const actualFlight = distance / config.speed;
 
 					if (
@@ -419,17 +463,9 @@ export const Infernalist: WizardFunction = ({state}) =>
 									enemy.position,
 									enemy.velocity,
 									config.speed,
-									state.position,
+									position,
 								);
-						return {
-							move,
-							startCast: {
-								spell: 'missile',
-								config,
-								missileAI: config.turnRate > 0 ? HomingAI : StraightAI,
-								direction: angleTo(state.position, aimTarget),
-							},
-						};
+						return missile(config, config.turnRate > 0 ? HomingAI : StraightAI, angleTo(position, aimTarget)).move(safeMove.x, safeMove.y);
 					}
 				}
 			}
@@ -438,55 +474,39 @@ export const Infernalist: WizardFunction = ({state}) =>
 		// --- STANDARD MODE: warmup-consistent homing missiles ---
 		const nextThreatTime = urgentThreat?.ticksToImpact ?? Infinity;
 		const safeBudget =
-			nextThreatTime - GCD_DURATION - SHIELD_CAST_TIME - SHIELD_BUFFER;
+			nextThreatTime - RULES.GCD_DURATION - RULES.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,
+			lastMissileConfig: lastMissileConfig,
 		});
 
-		if (
-			config &&
-      config.damage >= minDmg &&
-      isSafeToAttack(threats, safeAttackCastEstimate)
-		) 
+		if (config && config.damage >= minDmg)
 		{
-			return {
-				move,
-				startCast: {
-					spell: 'missile',
-					config,
-					missileAI: HomingAI,
-					direction: angleTo(state.position, enemy.position),
-				},
-			};
+			const actualCastTime = getMissileCastTime(config, lastMissileConfig);
+			if (isSafeToAttack(threats, actualCastTime))
+			{
+				return missile(config, HomingAI, angleTo(position, enemy.position)).move(safeMove.x, safeMove.y);
+			}
 		}
 
-		// Fallback: fire bigger missile, accept incoming hit
-		if (!config || config.damage < minDmg) 
+		// Fallback: fire bigger missile, accept incoming hit — but only if no undodgeable threat
+		if (!config || config.damage < minDmg)
 		{
 			config = fitMissileToBudget(MAX_CAST_BUDGET, distance, {
 				minTurnRate,
 				maxDamage: enemyHP,
-				lastMissileConfig: state.lastMissileConfig,
+				lastMissileConfig: lastMissileConfig,
 			});
-			if (config) 
+			if (config && (!urgentThreat || urgentThreat.bestDodgeDirection !== null))
 			{
-				return {
-					move,
-					startCast: {
-						spell: 'missile',
-						config,
-						missileAI: HomingAI,
-						direction: angleTo(state.position, enemy.position),
-					},
-				};
+				return missile(config, HomingAI, angleTo(position, enemy.position)).move(safeMove.x, safeMove.y);
 			}
 		}
 	}
 
-	return {move};
-};
+	return moveAction(safeMove.x, safeMove.y);
+}