@vibemancer/core 0.1.4 → 0.1.5

package/src/bots/defensive/03_Golem.ts

@@ -1,14 +1,10 @@
-import {WizardFunction, MissileAIFunction} from '../../types.js';
+import type {FinalAction, MissileFunction} from '../../hooks/index.js';
+import {usePosition, useEnemy, useStatus, useBlinkCooldown, useHealth, useThreats, useLastMissileConfig, useCastingSpell, useCastProgress, idle, missile, move, shield, blink, cancel, getMissileContext, turnToward, flyStraight} from '../../hooks/index.js';
 import {distanceTo} from '../../utils/distance.js';
 import {angleTo} from '../../utils/angles.js';
-import {
-	GCD_DURATION,
-	SHIELD_CAST_TIME,
-	BLINK_CAST_TIME,
-} from '../../rules.js';
+import {RULES} from '../../rules.js';
 import {getMissileCastTime, getLeadPosition} from '../../utils/combat.js';
 import {
-	getThreats,
 	getMostUrgentThreat,
 	getBlinkToCenter,
 	fitMissileToBudget,
@@ -16,6 +12,8 @@ import {
 	MAX_CAST_BUDGET,
 	MIN_USEFUL_DAMAGE,
 	getEnemyVulnerabilityTicks,
+	keepOffWalls,
+	getLavaEvade,
 } from '../shared.js';
 import {useParam} from '../../engine/params-runtime.js';
 
@@ -25,16 +23,17 @@ const SHIELD_HOLD_TICKS = 5;
 /**
  * Standard homing missile AI — tracks enemy position.
  */
-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();
 };
 
 /**
  * Straight missile AI — no homing, flies in initial direction.
  */
-const StraightAI: MissileAIFunction = () => ({});
+const StraightAI: MissileFunction = () => flyStraight();
 
 /**
  * Bot: Golem
@@ -54,12 +53,23 @@ const StraightAI: MissileAIFunction = () => ({});
  * PROGRESSION LINE: Turtle → Sentinel → Golem
  * TIER: 3 (elite Defensive line)
  */
-export const Golem: WizardFunction = ({state}) => 
+export function Golem(): FinalAction
 {
+	const position = usePosition();
+	const enemy = useEnemy();
+	const status = useStatus();
+	const blinkCooldown = useBlinkCooldown();
+	const health = useHealth();
+	const threats = useThreats();
+	const lastMissileConfig = useLastMissileConfig();
+	const castingSpell = useCastingSpell();
+	const castProgressData = useCastProgress();
+
+
 	// Positive turn rate ensures homing missiles that hit moving targets.
 	// Hardcoded — optimizer incorrectly pushes this negative for stationary matchups.
 	const minTurnRate = 0.5;
-	const preemptiveShieldRange = useParam('preemptiveShieldRange', 150, {
+	const preemptiveShieldRange = useParam('preemptiveShieldRange', 65, {
 		range: 85,
 		min: 0,
 		steps: 7,
@@ -68,44 +78,44 @@ export const Golem: WizardFunction = ({state}) =>
 		range: 75,
 		min: 10,
 	});
-	const punishMinVulnerability = useParam('punishMinVulnerability', 310, {
+	const punishMinVulnerability = useParam('punishMinVulnerability', 293, {
 		range: 30,
 		min: 10,
 		steps: 5,
 	});
 	const preferBlinkDodge =
 		useParam('preferBlinkDodge', 1, {min: 0, max: 1, steps: 2}) >= 0.5;
-	const cancelHeavyDmg = useParam('cancelHeavyDmg', 14, {
+	const cancelHeavyDmg = useParam('cancelHeavyDmg', 26, {
 		range: 15,
 		min: 5,
 		max: 40,
 		steps: 5,
 	});
-	const cancelMediumDmg = useParam('cancelMediumDmg', 12, {
+	const cancelMediumDmg = useParam('cancelMediumDmg', 21, {
 		range: 10,
 		min: 3,
 		max: 25,
 		steps: 5,
 	});
-	const cancelCastRatio = useParam('cancelCastRatio', 0.8, {
+	const cancelCastRatio = useParam('cancelCastRatio', 1, {
 		range: 0.4,
 		min: 0.3,
 		max: 1.0,
 		steps: 5,
 	});
-	const cancelLightDmg = useParam('cancelLightDmg', 8, {
+	const cancelLightDmg = useParam('cancelLightDmg', 1, {
 		range: 5,
 		min: 1,
 		max: 15,
 		steps: 5,
 	});
-	const cancelEarlyCastRatio = useParam('cancelEarlyCastRatio', 0.7, {
+	const cancelEarlyCastRatio = useParam('cancelEarlyCastRatio', 0.66, {
 		range: 0.3,
 		min: 0.0,
 		max: 0.7,
 		steps: 5,
 	});
-	const blinkWindowMax = useParam('blinkWindowMax', 50, {
+	const blinkWindowMax = useParam('blinkWindowMax', 52, {
 		range: 40,
 		min: 20,
 		max: 120,
@@ -117,82 +127,85 @@ export const Golem: WizardFunction = ({state}) =>
 		max: 15,
 		steps: 5,
 	});
-	const flightTimeDivisor = useParam('flightTimeDivisor', 9.5, {
+	const flightTimeDivisor = useParam('flightTimeDivisor', 3.1, {
 		range: 4,
 		min: 2,
 		max: 12,
 		steps: 5,
 	});
 
-	const enemy = state.enemies[0];
-	const threats = getThreats(state);
 	const urgentThreat = getMostUrgentThreat(threats);
 	const hittingThreats = threats.filter((t) => t.willHit);
 
+	// Lava-evade: a knockback-lethal hit near a wall must be dodged/blinked, not
+	// shielded — knockback ignores shields. Highest priority.
+	const lavaEvade = getLavaEvade(position, enemy.position, threats, blinkCooldown);
+	if (lavaEvade) return lavaEvade.action === 'blink' ? blink(lavaEvade.x, lavaEvade.y) : move(lavaEvade.x, lavaEvade.y);
+
 	// === STEP 1: CHANNELING — hold through volleys, cancel when safe ===
-	if (state.state === 'channeling' && state.channelingSpell === 'shield') 
+	if (status === 'channeling' && 'shield' === 'shield') 
 	{
 		// Hold if any missile is about to hit
 		const imminentThreat = hittingThreats.find(
 			(t) => t.ticksToImpact <= SHIELD_HOLD_TICKS,
 		);
-		if (imminentThreat) 
+		if (imminentThreat)
 		{
-			return {move: {x: 0, y: 0}};
+			{ const h = keepOffWalls(position); return (h.x !== 0 || h.y !== 0) ? move(h.x, h.y) : idle(); }
 		}
 
 		// Hold if next threat will arrive before we can reshield
 		const nextHitting = hittingThreats[0];
-		const ticksToReshield = SHIELD_CAST_TIME + SHIELD_BUFFER;
-		if (nextHitting && nextHitting.ticksToImpact <= ticksToReshield) 
+		const ticksToReshield = RULES.SHIELD_CAST_TIME + SHIELD_BUFFER;
+		if (nextHitting && nextHitting.ticksToImpact <= ticksToReshield)
 		{
-			return {move: {x: 0, y: 0}};
+			{ const h = keepOffWalls(position); return (h.x !== 0 || h.y !== 0) ? move(h.x, h.y) : idle(); }
 		}
 
 		// Cancel shield if no threat or threat is far enough
-		if (!nextHitting || nextHitting.ticksToImpact > shieldCancelThreshold) 
+		if (!nextHitting || nextHitting.ticksToImpact > shieldCancelThreshold)
 		{
-			return {move: {x: 0, y: 0}, cancel: true};
+			return cancel();
 		}
-		return {move: {x: 0, y: 0}};
+		{ const h = keepOffWalls(position); return (h.x !== 0 || h.y !== 0) ? move(h.x, h.y) : idle(); }
 	}
 
 	// If casting shield, let it finish
-	if (state.state === 'casting' && state.castingSpell === 'shield') 
+	if (status === 'casting' && castingSpell === 'shield')
 	{
-		return {move: {x: 0, y: 0}};
+		{ const h = keepOffWalls(position); return (h.x !== 0 || h.y !== 0) ? move(h.x, h.y) : idle(); }
 	}
 
 	// === STEP 2: PROGRESSIVE CAST-CANCEL — evaluate damage tradeoff ===
 	if (
-		state.state === 'casting' &&
-    state.castingSpell === 'missile' &&
+		status === 'casting' &&
+    castingSpell === 'missile' &&
     urgentThreat
 	) 
 	{
 		// Sentinel is stationary — can't dodge. Must always consider canceling.
-		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);
 
 			// Always cancel for lethal or heavy damage
-			if (incomingDamage >= state.health || incomingDamage >= cancelHeavyDmg) 
+			if (incomingDamage >= health || incomingDamage >= cancelHeavyDmg) 
 			{
-				return {move: {x: 0, y: 0}, cancel: true};
+				return cancel();
 			}
 			// Significant damage + early/mid cast: cancel
 			if (incomingDamage >= cancelMediumDmg && castRatio < cancelCastRatio) 
 			{
-				return {move: {x: 0, y: 0}, cancel: true};
+				return cancel();
 			}
 			// Medium damage + very early cast: cancel
 			if (
@@ -200,7 +213,7 @@ export const Golem: WizardFunction = ({state}) =>
         castRatio < cancelEarlyCastRatio
 			) 
 			{
-				return {move: {x: 0, y: 0}, cancel: true};
+				return cancel();
 			}
 		}
 	}
@@ -208,42 +221,36 @@ export const Golem: WizardFunction = ({state}) =>
 	// === STEP 3: BLINK-DODGE — 100% damage avoidance (optimizer-controlled) ===
 	if (
 		preferBlinkDodge &&
-    state.state === 'idle' &&
+    status === 'idle' &&
     urgentThreat &&
-    state.blinkCooldown === 0 &&
-    urgentThreat.ticksToImpact >= BLINK_CAST_TIME &&
+    blinkCooldown === 0 &&
+    urgentThreat.ticksToImpact >= RULES.BLINK_CAST_TIME &&
     urgentThreat.ticksToImpact <= blinkWindowMax
 	) 
 	{
-		return {
-			move: {x: 0, y: 0},
-			startCast: {spell: 'blink', target: getBlinkToCenter(state.position)},
-		};
+		return blink(getBlinkToCenter(position).x, getBlinkToCenter(position).y);
 	}
 
 	// === STEP 3b: SHIELD — fallback when blink unavailable (90% block) ===
 	if (
-		state.state === 'idle' &&
+		status === 'idle' &&
     urgentThreat &&
     urgentThreat.canBlockInTime &&
     urgentThreat.ticksToStartShield <= SHIELD_BUFFER
 	) 
 	{
-		return {
-			move: {x: 0, y: 0},
-			startCast: {spell: 'shield'},
-		};
+		return shield();
 	}
 
 	// === STEP 4: PREEMPTIVE SHIELD — enemy casting at close range ===
 	if (
-		state.state === 'idle' &&
+		status === 'idle' &&
     enemy &&
-    enemy.state === 'casting' &&
+    enemy.status === 'casting' &&
     enemy.castingSpell === 'missile'
 	) 
 	{
-		const distance = distanceTo(state.position, enemy.position);
+		const distance = distanceTo(position, enemy.position);
 		if (distance < preemptiveShieldRange) 
 		{
 			const remainingCast =
@@ -252,25 +259,22 @@ export const Golem: WizardFunction = ({state}) =>
 			const ticksUntilHit = remainingCast + estimatedFlightTicks;
 			if (
 				ticksUntilHit <
-        SHIELD_CAST_TIME + SHIELD_BUFFER + preemptiveShieldBuffer
+        RULES.SHIELD_CAST_TIME + SHIELD_BUFFER + preemptiveShieldBuffer
 			) 
 			{
-				return {
-					move: {x: 0, y: 0},
-					startCast: {spell: 'shield'},
-				};
+				return shield();
 			}
 		}
 	}
 
 	// === STEP 5: OFFENSE — punish mode + standard counterattack ===
-	if (state.state === 'idle' && enemy) 
+	if (status === 'idle' && enemy) 
 	{
 		const offenseDefenseTime =
-			state.blinkCooldown === 0
-				? BLINK_CAST_TIME
-				: SHIELD_CAST_TIME + SHIELD_BUFFER;
-		const distance = distanceTo(state.position, enemy.position);
+			blinkCooldown === 0
+				? RULES.BLINK_CAST_TIME
+				: RULES.SHIELD_CAST_TIME + SHIELD_BUFFER;
+		const distance = distanceTo(position, enemy.position);
 		const enemyHP = Math.ceil(enemy.health);
 		const vulnerabilityTicks = getEnemyVulnerabilityTicks(enemy);
 
@@ -280,7 +284,7 @@ export const Golem: WizardFunction = ({state}) =>
 			const flightTimeEstimate = distance / flightTimeDivisor;
 			const punishBudget = vulnerabilityTicks - flightTimeEstimate;
 			const nextThreatTime = urgentThreat?.ticksToImpact ?? Infinity;
-			const safeBudget = nextThreatTime - GCD_DURATION - offenseDefenseTime;
+			const safeBudget = nextThreatTime - RULES.GCD_DURATION - offenseDefenseTime;
 			const effectiveBudget = Math.min(
 				punishBudget,
 				safeBudget,
@@ -292,12 +296,12 @@ export const Golem: 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 (
@@ -312,17 +316,9 @@ export const Golem: WizardFunction = ({state}) =>
 									enemy.position,
 									enemy.velocity,
 									config.speed,
-									state.position,
+									position,
 								);
-						return {
-							move: {x: 0, y: 0},
-							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(keepOffWalls(position).x, keepOffWalls(position).y);
 					}
 				}
 			}
@@ -330,28 +326,20 @@ export const Golem: WizardFunction = ({state}) =>
 
 		// --- STANDARD MODE: adaptive homing in safe windows ---
 		const nextThreatTime = urgentThreat?.ticksToImpact ?? Infinity;
-		const safeBudget = nextThreatTime - GCD_DURATION - offenseDefenseTime;
+		const safeBudget = nextThreatTime - RULES.GCD_DURATION - offenseDefenseTime;
 		const budgetTicks = Math.min(safeBudget, MAX_CAST_BUDGET);
 
 		const config = fitMissileToBudget(budgetTicks, distance, {
 			minTurnRate,
 			maxDamage: enemyHP,
-			lastMissileConfig: state.lastMissileConfig,
+			lastMissileConfig: lastMissileConfig,
 		});
 
 		if (config && config.damage >= Math.min(MIN_USEFUL_DAMAGE, enemyHP)) 
 		{
-			return {
-				move: {x: 0, y: 0},
-				startCast: {
-					spell: 'missile',
-					config,
-					missileAI: config.turnRate > 0 ? HomingAI : StraightAI,
-					direction: angleTo(state.position, enemy.position),
-				},
-			};
+			return missile(config, config.turnRate > 0 ? HomingAI : StraightAI, angleTo(position, enemy.position)).move(keepOffWalls(position).x, keepOffWalls(position).y);
 		}
 	}
 
-	return {move: {x: 0, y: 0}};
-};
+	{ const h = keepOffWalls(position); return (h.x !== 0 || h.y !== 0) ? move(h.x, h.y) : idle(); }
+}