@vibemancer/core 0.1.4 → 0.1.6

package/src/bots/homing/03_Archlich.ts

@@ -1,10 +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, useMyProjectiles, 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} from '../../rules.js';
+import {RULES, ARENA_MIN, ARENA_MAX} from '../../rules.js';
 import {getMissileCastTime, getLeadPosition} from '../../utils/combat.js';
 import {
-	getThreats,
 	getMostUrgentThreat,
 	getDodgeDirectionForMovement,
 	getBlinkToCenter,
@@ -13,27 +13,30 @@ import {
 	MAX_CAST_BUDGET,
 	MIN_USEFUL_DAMAGE,
 	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
 	);
 }
 
@@ -64,8 +67,8 @@ 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 sCcw = Math.min(fCcw.x, ARENA_SIZE - fCcw.x, fCcw.y, ARENA_SIZE - fCcw.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_MIN, ARENA_MAX - fCcw.x, fCcw.y - ARENA_MIN, ARENA_MAX - fCcw.y);
 		dir = sCw > sCcw ? cw : ccw;
 	}
 	else
@@ -74,7 +77,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};
 }
 
@@ -89,41 +92,81 @@ function smartStrafe(
  * PROGRESSION LINE: Bonemancer → Lich → Archlich
  * TIER: 3 (elite Homing line)
  */
-export const Archlich: WizardFunction = ({state}) =>
+export function Archlich(): FinalAction
 {
+	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 myProjectiles = useMyProjectiles();
+	const lastMissileConfig = useLastMissileConfig();
+	const castingSpell = useCastingSpell();
+	const castProgressData = useCastProgress();
+
+
 	// Same params as Lich — Archlich is Lich + punish mode (disabled by default, optimizer tunes)
-	const targetDistance = useParam('targetDistance', 737, {range: 175, min: 0});
+	const targetDistance = useParam('targetDistance', 1160, {range: 175, min: 0});
 	const minTurnRate = useParam('minTurnRate', 0.4, {range: 1.5, steps: 5});
 	const shieldHealthThreshold = useParam('shieldHealthThreshold', 99, {range: 23, min: 1, steps: 7});
-	const strafeCyclePeriod = useParam('strafeCyclePeriod', 300, {range: 75, min: 80, max: 300});
-	const strafeIntensity = useParam('strafeIntensity', 96, {range: 40, min: 20, max: 100, steps: 7});
-	const approachSpeed = useParam('approachSpeed', 65, {range: 30, min: 10, max: 70, steps: 7});
-	const distanceDeadZone = useParam('distanceDeadZone', 7, {range: 30, min: 5, max: 80, steps: 7});
+	const strafeCyclePeriod = useParam('strafeCyclePeriod', 181, {range: 75, min: 80, max: 300});
+	const strafeIntensity = useParam('strafeIntensity', 0.98, {range: 0.4, min: 0.2, max: 1, steps: 7});
+	const approachSpeed = useParam('approachSpeed', 0.1, {range: 0.3, min: 0.1, max: 0.7, steps: 7});
+	const distanceDeadZone = useParam('distanceDeadZone', 51, {range: 30, min: 5, max: 80, steps: 7});
 	const shieldCancelThreshold = useParam('shieldCancelThreshold', 150, {range: 75, min: 50, max: 300});
-	const blinkWindowMax = useParam('blinkWindowMax', 38, {range: 30, min: 15, max: 80, steps: 7});
-	const flightTimeDivisor = useParam('flightTimeDivisor', 5.8, {range: 4, min: 2, max: 12, steps: 5});
+	const blinkWindowMax = useParam('blinkWindowMax', 80, {range: 30, min: 15, max: 80, steps: 7});
+	const flightTimeDivisor = useParam('flightTimeDivisor', 6.6, {range: 4, min: 2, max: 12, steps: 5});
 	const punishMinVulnerability = useParam('punishMinVulnerability', 500, {range: 80, min: 30, steps: 7});
+	const centerBias = useParam('centerBias', 0.3, {
+		range: 0.4,
+		min: 0,
+		max: 0.8,
+		steps: 5,
+	});
+	const maxBlinkDistance = useParam('maxBlinkDistance', 283, {
+		range: 100,
+		min: 50,
+		max: 300,
+		steps: 7,
+	});
 
-	const enemy = state.enemies[0];
-	if (!enemy) return {move: {x: 0, y: 0}};
+	function capBlinkDistance(target: {x: number; y: number}): {x: number; y: number}
+	{
+		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 strafe = smartStrafe(state.position, enemy, dodgeDirection, state.tick, strafeCyclePeriod, strafeIntensity);
+	const dodgeDirection = getDodgeDirectionForMovement(threats, position);
+	const strafe = smartStrafe(position, enemy, dodgeDirection, tick, strafeCyclePeriod, strafeIntensity);
 
 	let moveX = strafe.x;
 	let moveY = strafe.y;
 	if (!dodgeDirection)
 	{
-		const dx = enemy.position.x - state.position.x;
-		const dy = enemy.position.y - state.position.y;
+		const dx = enemy.position.x - position.x;
+		const dy = enemy.position.y - position.y;
 		const nd = distance > 0 ? distance : 1;
 		if (distance > targetDistance + distanceDeadZone)
 		{
-			moveX += (dx / nd) * approachSpeed;
-			moveY += (dy / nd) * 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 = dx / nd + (toCenterX / toCenterDist) * centerBias;
+			const approachDirY = dy / nd + (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)
 		{
@@ -132,47 +175,73 @@ export const Archlich: WizardFunction = ({state}) =>
 		}
 	}
 	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);
 
 	// === DEFENSE: identical to Lich ===
-	if (state.state === 'channeling')
+	if (status === 'channeling')
 	{
-		if (!urgentThreat || urgentThreat.ticksToImpact > shieldCancelThreshold) return {move, cancel: true};
-		return {move: {x: 0, y: 0}};
+		if (!urgentThreat || urgentThreat.ticksToImpact > shieldCancelThreshold) return cancel().move(safeMove.x, safeMove.y);
+		return idle();
 	}
 
-	if (state.state === 'casting' && state.castingSpell === 'missile' && urgentThreat && urgentThreat.projectile.damage >= state.health)
+	if (status === 'casting' && castingSpell === 'missile' && urgentThreat && urgentThreat.projectile.damage >= health)
 	{
-		const rem = (state.castDuration ?? 0) - (state.castProgress ?? 0);
-		if (urgentThreat.ticksToImpact <= rem + GCD_DURATION + SHIELD_CAST_TIME + SHIELD_BUFFER) return {move, cancel: true};
+		const rem = ((castProgressData?.total) ?? 0) - ((castProgressData?.current) ?? 0);
+		if (urgentThreat.ticksToImpact <= rem + RULES.GCD_DURATION + RULES.SHIELD_CAST_TIME + SHIELD_BUFFER) return cancel().move(safeMove.x, safeMove.y);
 	}
 
-	if (state.state === 'idle' && urgentThreat && state.blinkCooldown === 0 && urgentThreat.ticksToImpact >= 10 && urgentThreat.ticksToImpact <= blinkWindowMax)
+	if (status === 'idle' && urgentThreat && blinkCooldown === 0 && urgentThreat.ticksToImpact >= 10 && urgentThreat.ticksToImpact <= blinkWindowMax)
 	{
-		return {move: {x: 0, y: 0}, startCast: {spell: 'blink', target: getBlinkToCenter(state.position)}};
+		const blinkTarget = capBlinkDistance(getBlinkToCenter(position));
+		return blink(blinkTarget.x, blinkTarget.y);
 	}
 
-	if (state.state === 'idle' && urgentThreat)
+	if (status === 'idle' && urgentThreat)
 	{
 		const forceShield = shouldForceShield(urgentThreat);
 		const undodgeable = !urgentThreat.bestDodgeDirection;
-		const healthLow = state.health < shieldHealthThreshold;
-		const healthCritical = state.health <= urgentThreat.projectile.damage * 2 + 1;
+		const healthLow = health < shieldHealthThreshold;
+		const healthCritical = health <= urgentThreat.projectile.damage * 2 + 1;
 		if ((forceShield || (undodgeable && healthLow) || healthCritical) && urgentThreat.canBlockInTime && urgentThreat.ticksToStartShield <= SHIELD_BUFFER)
 		{
-			return {move: {x: 0, y: 0}, startCast: {spell: 'shield'}};
+			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 (
+			ticksUntilHit >= RULES.SHIELD_CAST_TIME &&
+			ticksUntilHit < RULES.SHIELD_CAST_TIME + 15
+		)
+		{
+			return shield();
 		}
 	}
 
 	// === OFFENSE ===
-	const myIds = new Set(state.myProjectiles.map((p) => p.id));
-	const hasLethal = state.projectiles.some((p) => !myIds.has(p.id) && p.damage >= state.health && distanceTo(state.position, p.position) / p.speed < MAX_CAST_BUDGET + GCD_DURATION);
-	if (state.state === 'idle' && !hasLethal)
+	const myIds = new Set(myProjectiles.map((p) => p.id));
+	const hasLethal = projectiles.some((p) => !myIds.has(p.id) && p.damage >= health && distanceTo(position, p.position) / p.speed < MAX_CAST_BUDGET + RULES.GCD_DURATION);
+	if (status === 'idle' && !hasLethal)
 	{
+		const reposition = getPreCastReposition(position, enemy.position);
+		if (reposition) return moveAction(reposition.x, reposition.y);
+
 		const enemyHP = Math.ceil(enemy.health);
 
 		// T3 PUNISH: fast straight missiles during vulnerability
@@ -182,18 +251,18 @@ export const Archlich: WizardFunction = ({state}) =>
 			const flight = distance / flightTimeDivisor;
 			const pBudget = vulnTicks - flight;
 			const ntt = urgentThreat?.ticksToImpact ?? Infinity;
-			const sBudget = ntt - GCD_DURATION - SHIELD_CAST_TIME - SHIELD_BUFFER;
+			const sBudget = ntt - RULES.GCD_DURATION - RULES.SHIELD_CAST_TIME - SHIELD_BUFFER;
 			const eBudget = Math.min(pBudget, sBudget, MAX_CAST_BUDGET);
 			if (eBudget > 0)
 			{
-				const cfg = fitMissileToBudget(eBudget, distance, {minTurnRate: 0, maxDamage: enemyHP, lastMissileConfig: state.lastMissileConfig});
+				const cfg = fitMissileToBudget(eBudget, distance, {minTurnRate: 0, maxDamage: enemyHP, lastMissileConfig: lastMissileConfig});
 				if (cfg && cfg.damage >= MIN_USEFUL_DAMAGE)
 				{
-					const ct = getMissileCastTime(cfg, state.lastMissileConfig);
+					const ct = getMissileCastTime(cfg, lastMissileConfig);
 					if (ct + distance / cfg.speed < vulnTicks)
 					{
-						const aim = cfg.turnRate > 0 ? enemy.position : getLeadPosition(enemy.position, enemy.velocity, cfg.speed, state.position);
-						return {move, startCast: {spell: 'missile', config: cfg, missileAI: cfg.turnRate > 0 ? HomingAI : StraightAI, direction: angleTo(state.position, aim)}};
+						const aim = cfg.turnRate > 0 ? enemy.position : getLeadPosition(enemy.position, enemy.velocity, cfg.speed, position);
+						return missile(cfg, cfg.turnRate > 0 ? HomingAI : StraightAI, angleTo(position, aim)).move(safeMove.x, safeMove.y);
 					}
 				}
 			}
@@ -201,20 +270,20 @@ export const Archlich: WizardFunction = ({state}) =>
 
 		// STANDARD MODE: identical to Lich
 		let ntt = urgentThreat?.ticksToImpact ?? Infinity;
-		if (enemy.state === 'casting' && enemy.castingSpell === 'missile')
+		if (enemy.status === 'casting' && enemy.castingSpell === 'missile')
 		{
 			const rem = (enemy.castDuration ?? 0) - (enemy.castProgress ?? 0);
 			ntt = Math.min(ntt, rem + distance / flightTimeDivisor);
 		}
-		const sBudget = ntt - GCD_DURATION - SHIELD_CAST_TIME - SHIELD_BUFFER;
+		const sBudget = ntt - RULES.GCD_DURATION - RULES.SHIELD_CAST_TIME - SHIELD_BUFFER;
 		const budget = Math.min(sBudget, MAX_CAST_BUDGET);
 		const minDmg = Math.min(MIN_USEFUL_DAMAGE, enemyHP);
-		const cfg = fitMissileToBudget(budget, distance, {minTurnRate, lastMissileConfig: state.lastMissileConfig});
+		const cfg = fitMissileToBudget(budget, distance, {minTurnRate, lastMissileConfig: lastMissileConfig});
 		if (cfg && cfg.damage >= minDmg)
 		{
-			return {move, startCast: {spell: 'missile', config: cfg, missileAI: HomingAI, direction: angleTo(state.position, enemy.position)}};
+			return missile(cfg, HomingAI, angleTo(position, enemy.position)).move(safeMove.x, safeMove.y);
 		}
 	}
 
-	return {move};
-};
+	return moveAction(safeMove.x, safeMove.y);
+}