@vibemancer/core 0.1.0 → 0.1.1

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

@@ -1,220 +1,220 @@
-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,
-	fitMissileToBudget,
-	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;
-
-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 normalizedDistance = Math.sqrt(deltaX * deltaX + deltaY * deltaY);
-	if (normalizedDistance === 0) return {x: 0, y: 0};
-
-	const cw = {x: -deltaY / normalizedDistance, y: deltaX / normalizedDistance};
-	const ccw = {x: deltaY / normalizedDistance, y: -deltaX / normalizedDistance};
-
-	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: Archlich
- *
- * BEHAVIOR: Lich's proven core (mobile homing specialist) plus vulnerability
- * exploitation. Defense, movement, and standard offense are identical to Lich.
- * The T3 advantage: when the enemy is locked in GCD/cast, fires fast straight
- * punish missiles that land during the vulnerability window.
- *
- * PROGRESSION LINE: Bonemancer → Lich → Archlich
- * TIER: 3 (elite Homing line)
- */
-export const Archlich: WizardFunction = ({state}) =>
-{
-	// Same params as Lich — Archlich is Lich + punish mode (disabled by default, optimizer tunes)
-	const targetDistance = useParam('targetDistance', 737, {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 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 punishMinVulnerability = useParam('punishMinVulnerability', 500, {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);
-	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);
-
-	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 nd = distance > 0 ? distance : 1;
-		if (distance > targetDistance + distanceDeadZone)
-		{
-			moveX += (dx / nd) * approachSpeed;
-			moveY += (dy / nd) * approachSpeed;
-		}
-		else if (distance < targetDistance - distanceDeadZone)
-		{
-			moveX -= (dx / nd) * approachSpeed;
-			moveY -= (dy / nd) * approachSpeed;
-		}
-	}
-	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};
-
-	// === DEFENSE: identical to Lich ===
-	if (state.state === 'channeling')
-	{
-		if (!urgentThreat || urgentThreat.ticksToImpact > shieldCancelThreshold) return {move, cancel: true};
-		return {move: {x: 0, y: 0}};
-	}
-
-	if (state.state === 'casting' && state.castingSpell === 'missile' && urgentThreat && urgentThreat.projectile.damage >= state.health)
-	{
-		const rem = (state.castDuration ?? 0) - (state.castProgress ?? 0);
-		if (urgentThreat.ticksToImpact <= rem + GCD_DURATION + SHIELD_CAST_TIME + SHIELD_BUFFER) return {move, cancel: true};
-	}
-
-	if (state.state === 'idle' && urgentThreat && state.blinkCooldown === 0 && urgentThreat.ticksToImpact >= 10 && urgentThreat.ticksToImpact <= blinkWindowMax)
-	{
-		return {move: {x: 0, y: 0}, startCast: {spell: 'blink', target: getBlinkToCenter(state.position)}};
-	}
-
-	if (state.state === 'idle' && urgentThreat)
-	{
-		const forceShield = shouldForceShield(urgentThreat);
-		const undodgeable = !urgentThreat.bestDodgeDirection;
-		const healthLow = state.health < shieldHealthThreshold;
-		const healthCritical = state.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'}};
-		}
-	}
-
-	// === 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 enemyHP = Math.ceil(enemy.health);
-
-		// T3 PUNISH: fast straight missiles during vulnerability
-		const vulnTicks = getEnemyVulnerabilityTicks(enemy);
-		if (vulnTicks >= punishMinVulnerability && distance < 300)
-		{
-			const flight = distance / flightTimeDivisor;
-			const pBudget = vulnTicks - flight;
-			const ntt = urgentThreat?.ticksToImpact ?? Infinity;
-			const sBudget = ntt - GCD_DURATION - 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});
-				if (cfg && cfg.damage >= MIN_USEFUL_DAMAGE)
-				{
-					const ct = getMissileCastTime(cfg, state.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)}};
-					}
-				}
-			}
-		}
-
-		// STANDARD MODE: identical to Lich
-		let ntt = urgentThreat?.ticksToImpact ?? Infinity;
-		if (enemy.state === '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 budget = Math.min(sBudget, MAX_CAST_BUDGET);
-		const minDmg = Math.min(MIN_USEFUL_DAMAGE, enemyHP);
-		const cfg = fitMissileToBudget(budget, distance, {minTurnRate, lastMissileConfig: state.lastMissileConfig});
-		if (cfg && cfg.damage >= minDmg)
-		{
-			return {move, startCast: {spell: 'missile', config: cfg, missileAI: HomingAI, direction: angleTo(state.position, enemy.position)}};
-		}
-	}
-
-	return {move};
-};
+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,
+	fitMissileToBudget,
+	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;
+
+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 normalizedDistance = Math.sqrt(deltaX * deltaX + deltaY * deltaY);
+	if (normalizedDistance === 0) return {x: 0, y: 0};
+
+	const cw = {x: -deltaY / normalizedDistance, y: deltaX / normalizedDistance};
+	const ccw = {x: deltaY / normalizedDistance, y: -deltaX / normalizedDistance};
+
+	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: Archlich
+ *
+ * BEHAVIOR: Lich's proven core (mobile homing specialist) plus vulnerability
+ * exploitation. Defense, movement, and standard offense are identical to Lich.
+ * The T3 advantage: when the enemy is locked in GCD/cast, fires fast straight
+ * punish missiles that land during the vulnerability window.
+ *
+ * PROGRESSION LINE: Bonemancer → Lich → Archlich
+ * TIER: 3 (elite Homing line)
+ */
+export const Archlich: WizardFunction = ({state}) =>
+{
+	// Same params as Lich — Archlich is Lich + punish mode (disabled by default, optimizer tunes)
+	const targetDistance = useParam('targetDistance', 737, {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 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 punishMinVulnerability = useParam('punishMinVulnerability', 500, {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);
+	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);
+
+	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 nd = distance > 0 ? distance : 1;
+		if (distance > targetDistance + distanceDeadZone)
+		{
+			moveX += (dx / nd) * approachSpeed;
+			moveY += (dy / nd) * approachSpeed;
+		}
+		else if (distance < targetDistance - distanceDeadZone)
+		{
+			moveX -= (dx / nd) * approachSpeed;
+			moveY -= (dy / nd) * approachSpeed;
+		}
+	}
+	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};
+
+	// === DEFENSE: identical to Lich ===
+	if (state.state === 'channeling')
+	{
+		if (!urgentThreat || urgentThreat.ticksToImpact > shieldCancelThreshold) return {move, cancel: true};
+		return {move: {x: 0, y: 0}};
+	}
+
+	if (state.state === 'casting' && state.castingSpell === 'missile' && urgentThreat && urgentThreat.projectile.damage >= state.health)
+	{
+		const rem = (state.castDuration ?? 0) - (state.castProgress ?? 0);
+		if (urgentThreat.ticksToImpact <= rem + GCD_DURATION + SHIELD_CAST_TIME + SHIELD_BUFFER) return {move, cancel: true};
+	}
+
+	if (state.state === 'idle' && urgentThreat && state.blinkCooldown === 0 && urgentThreat.ticksToImpact >= 10 && urgentThreat.ticksToImpact <= blinkWindowMax)
+	{
+		return {move: {x: 0, y: 0}, startCast: {spell: 'blink', target: getBlinkToCenter(state.position)}};
+	}
+
+	if (state.state === 'idle' && urgentThreat)
+	{
+		const forceShield = shouldForceShield(urgentThreat);
+		const undodgeable = !urgentThreat.bestDodgeDirection;
+		const healthLow = state.health < shieldHealthThreshold;
+		const healthCritical = state.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'}};
+		}
+	}
+
+	// === 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 enemyHP = Math.ceil(enemy.health);
+
+		// T3 PUNISH: fast straight missiles during vulnerability
+		const vulnTicks = getEnemyVulnerabilityTicks(enemy);
+		if (vulnTicks >= punishMinVulnerability && distance < 300)
+		{
+			const flight = distance / flightTimeDivisor;
+			const pBudget = vulnTicks - flight;
+			const ntt = urgentThreat?.ticksToImpact ?? Infinity;
+			const sBudget = ntt - GCD_DURATION - 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});
+				if (cfg && cfg.damage >= MIN_USEFUL_DAMAGE)
+				{
+					const ct = getMissileCastTime(cfg, state.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)}};
+					}
+				}
+			}
+		}
+
+		// STANDARD MODE: identical to Lich
+		let ntt = urgentThreat?.ticksToImpact ?? Infinity;
+		if (enemy.state === '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 budget = Math.min(sBudget, MAX_CAST_BUDGET);
+		const minDmg = Math.min(MIN_USEFUL_DAMAGE, enemyHP);
+		const cfg = fitMissileToBudget(budget, distance, {minTurnRate, lastMissileConfig: state.lastMissileConfig});
+		if (cfg && cfg.damage >= minDmg)
+		{
+			return {move, startCast: {spell: 'missile', config: cfg, missileAI: HomingAI, direction: angleTo(state.position, enemy.position)}};
+		}
+	}
+
+	return {move};
+};