@vibemancer/core 0.1.4 → 0.1.6

package/src/bots/berserker/01_Stormchaser.ts

@@ -1,16 +1,18 @@
-import {WizardFunction, MissileAIFunction} from '../../types.js';
+import type {FinalAction, MissileFunction} from '../../hooks/index.js';
+import {usePosition, useEnemy, useStatus, useBlinkCooldown, useHealth, useTick, useThreats, 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 {interceptAngle, moveInDirection} from '../../utils/movement.js';
 import {getMissileCastTime} from '../../utils/combat.js';
-import {ARENA_SIZE, GCD_DURATION, SHIELD_CAST_TIME} from '../../rules.js';
+import {RULES, ARENA_MIN, ARENA_MAX} from '../../rules.js';
 import {
-	getThreats,
 	getMostUrgentThreat,
 	getDodgeDirectionForMovement,
 	isSafeToAttack,
 	getBlinkToCenter,
 	shouldForceShield,
+	keepOffWalls,
+	getPreCastReposition,
 } from '../shared.js';
 import {useParam} from '../../engine/params-runtime.js';
 const WALL_BUFFER = 80;
@@ -29,25 +31,24 @@ const QUICK_CONFIG = {damage: 10, speed: 5, turnRate: 1, duration: 80};
 /**
  * Predictive homing missile AI - leads the target.
  */
-const StormchaserMissileAI: MissileAIFunction = ({
-	worldState,
-	missileState,
-}) => 
+const StormchaserMissileAI: MissileFunction = () =>
 {
-	const enemy = worldState.enemies[0];
-	if (!enemy) return {};
+	const ctx = getMissileContext();
+	const enemy = ctx.worldState.enemies[0];
+	if (enemy.health <= 0) return flyStraight();
 
 	const angle = interceptAngle(
-		missileState.position,
+		ctx.position,
 		enemy.position,
 		enemy.velocity,
-		missileState.speed,
+		ctx.speed,
 	);
-	if (angle !== null) 
+	if (angle !== null)
 	{
-		return {turnToward: moveInDirection(missileState.position, angle, 100)};
+		const target = moveInDirection(ctx.position, angle, 100);
+		return turnToward(target.x, target.y);
 	}
-	return {turnToward: enemy.position};
+	return turnToward(enemy.position.x, enemy.position.y);
 };
 
 /**
@@ -56,10 +57,10 @@ const StormchaserMissileAI: 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
+		position.x < ARENA_MIN + WALL_BUFFER ||
+    position.x > ARENA_MAX - WALL_BUFFER ||
+    position.y < ARENA_MIN + WALL_BUFFER ||
+    position.y > ARENA_MAX - WALL_BUFFER
 	);
 }
 
@@ -77,12 +78,22 @@ function combatMove(
 	strafeIntensity: number,
 	approachSpeed: number,
 	distanceDeadZone: number,
-): {x: number; y: number} 
+	centerBias: number,
+): {x: number; y: number}
 {
 	const deltaX = enemy.position.x - position.x;
 	const deltaY = enemy.position.y - position.y;
 	const normalizedDistance = currentDistance > 0 ? currentDistance : 1;
 
+	// 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 / normalizedDistance + (toCenterX / toCenterDist) * centerBias;
+	const approachDirY = deltaY / normalizedDistance + (toCenterY / toCenterDist) * centerBias;
+	const approachMag = Math.sqrt(approachDirX * approachDirX + approachDirY * approachDirY) || 1;
+
 	// Perpendicular directions for strafing
 	const strafeClockwise = {
 		x: -deltaY / normalizedDistance,
@@ -112,16 +123,16 @@ function combatMove(
 			y: position.y + strafeCounterClockwise.y * 100,
 		};
 		const scoreClockwise = Math.min(
-			futureClockwise.x,
-			ARENA_SIZE - futureClockwise.x,
-			futureClockwise.y,
-			ARENA_SIZE - futureClockwise.y,
+			futureClockwise.x - ARENA_MIN,
+			ARENA_MAX - futureClockwise.x,
+			futureClockwise.y - ARENA_MIN,
+			ARENA_MAX - futureClockwise.y,
 		);
 		const scoreCounterClockwise = Math.min(
-			futureCounterClockwise.x,
-			ARENA_SIZE - futureCounterClockwise.x,
-			futureCounterClockwise.y,
-			ARENA_SIZE - futureCounterClockwise.y,
+			futureCounterClockwise.x - ARENA_MIN,
+			ARENA_MAX - futureCounterClockwise.x,
+			futureCounterClockwise.y - ARENA_MIN,
+			ARENA_MAX - futureCounterClockwise.y,
 		);
 		strafeDirection =
 			scoreClockwise > scoreCounterClockwise
@@ -138,36 +149,36 @@ function combatMove(
 	// When actively dodging, commit fully — no approach/retreat dilution
 	if (dodgeDirection) 
 	{
-		return {x: strafeDirection.x * 100, y: strafeDirection.y * 100};
+		return {x: strafeDirection.x, y: strafeDirection.y};
 	}
 
 	let moveX = strafeDirection.x * strafeIntensity;
 	let moveY = strafeDirection.y * strafeIntensity;
 
 	// Distance management (tighter band than other bots, only when not dodging)
-	if (currentDistance > targetDistance + distanceDeadZone) 
+	if (currentDistance > targetDistance + distanceDeadZone)
 	{
-		moveX += (deltaX / normalizedDistance) * approachSpeed;
-		moveY += (deltaY / normalizedDistance) * approachSpeed;
+		moveX += (approachDirX / approachMag) * approachSpeed;
+		moveY += (approachDirY / approachMag) * approachSpeed;
 	}
 	else if (currentDistance < targetDistance - distanceDeadZone) 
 	{
 		let retreatX = -(deltaX / normalizedDistance) * approachSpeed;
 		let retreatY = -(deltaY / normalizedDistance) * approachSpeed;
-		if (position.x < WALL_BUFFER && retreatX < 0) retreatX = 0;
-		if (position.x > ARENA_SIZE - WALL_BUFFER && retreatX > 0) retreatX = 0;
-		if (position.y < WALL_BUFFER && retreatY < 0) retreatY = 0;
-		if (position.y > ARENA_SIZE - WALL_BUFFER && retreatY > 0) retreatY = 0;
+		if (position.x < ARENA_MIN + WALL_BUFFER && retreatX < 0) retreatX = 0;
+		if (position.x > ARENA_MAX - WALL_BUFFER && retreatX > 0) retreatX = 0;
+		if (position.y < ARENA_MIN + WALL_BUFFER && retreatY < 0) retreatY = 0;
+		if (position.y > ARENA_MAX - WALL_BUFFER && retreatY > 0) retreatY = 0;
 		moveX += retreatX;
 		moveY += retreatY;
 	}
 
 	// Normalize to max speed
 	const magnitude = Math.sqrt(moveX * moveX + moveY * moveY);
-	if (magnitude > 100) 
+	if (magnitude > 1)
 	{
-		moveX = (moveX / magnitude) * 100;
-		moveY = (moveY / magnitude) * 100;
+		moveX = moveX / magnitude;
+		moveY = moveY / magnitude;
 	}
 
 	return {x: moveX, y: moveY};
@@ -189,9 +200,20 @@ function combatMove(
  *
  * TIER: 1 (base)
  */
-export const Stormchaser: WizardFunction = ({state}) => 
+export function Stormchaser(): FinalAction
 {
-	const targetDistance = useParam('targetDistance', 191, {
+	const position = usePosition();
+	const enemy = useEnemy();
+	const status = useStatus();
+	const blinkCooldown = useBlinkCooldown();
+	const health = useHealth();
+	const tick = useTick();
+	const threats = useThreats();
+	const castingSpell = useCastingSpell();
+	const castProgressData = useCastProgress();
+
+
+	const targetDistance = useParam('targetDistance', 263, {
 		range: 150,
 		min: 0,
 	});
@@ -200,24 +222,24 @@ export const Stormchaser: WizardFunction = ({state}) =>
 		min: 1,
 		steps: 5,
 	});
-	const strafeCyclePeriod = useParam('strafeCyclePeriod', 130, {
+	const strafeCyclePeriod = useParam('strafeCyclePeriod', 205, {
 		range: 75,
 		min: 80,
 		max: 300,
 	});
-	const strafeIntensity = useParam('strafeIntensity', 42, {
-		range: 40,
-		min: 20,
-		max: 100,
+	const strafeIntensity = useParam('strafeIntensity', 0.93, {
+		range: 0.4,
+		min: 0.2,
+		max: 1,
 		steps: 7,
 	});
-	const approachSpeed = useParam('approachSpeed', 68, {
-		range: 30,
-		min: 10,
-		max: 70,
+	const approachSpeed = useParam('approachSpeed', 0.38, {
+		range: 0.3,
+		min: 0.1,
+		max: 0.7,
 		steps: 7,
 	});
-	const distanceDeadZone = useParam('distanceDeadZone', 26, {
+	const distanceDeadZone = useParam('distanceDeadZone', 15, {
 		range: 25,
 		min: 10,
 		max: 60,
@@ -228,7 +250,7 @@ export const Stormchaser: WizardFunction = ({state}) =>
 		min: 50,
 		max: 300,
 	});
-	const blinkWindowMax = useParam('blinkWindowMax', 25, {
+	const blinkWindowMax = useParam('blinkWindowMax', 80, {
 		range: 30,
 		min: 15,
 		max: 80,
@@ -240,82 +262,99 @@ export const Stormchaser: WizardFunction = ({state}) =>
 		max: 150,
 		steps: 7,
 	});
-	const attackRange = useParam('attackRange', 676, {
+	const attackRange = useParam('attackRange', 697, {
 		range: 200,
 		min: 300,
 		max: 800,
 	});
-	const healthDamageRatio = useParam('healthDamageRatio', 5, {
+	const healthDamageRatio = useParam('healthDamageRatio', 4.5, {
 		range: 2,
 		min: 0.5,
 		max: 5,
 		steps: 7,
 	});
+	const centerBias = useParam('centerBias', 0.13, {
+		range: 0.4,
+		min: 0,
+		max: 0.8,
+		steps: 5,
+	});
+	const maxBlinkDistance = useParam('maxBlinkDistance', 300, {
+		range: 100,
+		min: 50,
+		max: 300,
+		steps: 7,
+	});
+
+	const distance = distanceTo(position, enemy.position);
 
-	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);
-
 	// Analyze threats using simulation
-	const threats = getThreats(state);
 	const urgentThreat = getMostUrgentThreat(threats);
 
 	// === DEFENSE: Handle channeling state ===
-	if (state.state === 'channeling') 
+	if (status === 'channeling') 
 	{
 		// Cancel shield if no imminent danger
 		if (!urgentThreat || urgentThreat.ticksToImpact > shieldCancelThreshold) 
 		{
-			return {move: {x: 0, y: 0}, cancel: true};
+			return cancel();
 		}
-		return {move: {x: 0, y: 0}};
+		return idle();
 	}
 
 	// === DEFENSE: Cancel missile cast for threats arriving during vulnerability window ===
 	if (
-		state.state === 'casting' &&
-    state.castingSpell === 'missile' &&
+		status === 'casting' &&
+    castingSpell === 'missile' &&
     urgentThreat
 	) 
 	{
-		const remainingCast = (state.castDuration ?? 0) - (state.castProgress ?? 0);
+		const remainingCast = ((castProgressData?.total) ?? 0) - ((castProgressData?.current) ?? 0);
 		const incomingDamage = urgentThreat.projectile.damage;
 		const arrivesInGCD =
 			urgentThreat.ticksToImpact > remainingCast &&
-      urgentThreat.ticksToImpact <= remainingCast + GCD_DURATION;
+      urgentThreat.ticksToImpact <= remainingCast + RULES.GCD_DURATION;
 
 		// Cancel for undodgeable threats when trade isn't worth it
 		if (!urgentThreat.bestDodgeDirection) 
 		{
 			const canSurviveHit =
-				state.health > incomingDamage * healthDamageRatio + 1;
+				health > incomingDamage * healthDamageRatio + 1;
 			const tradeWorthIt =
 				canSurviveHit && incomingDamage <= QUICK_CONFIG.damage;
 			if (
 				!tradeWorthIt &&
         remainingCast > cancelMinRemainingCast &&
         urgentThreat.ticksToImpact <=
-          remainingCast + GCD_DURATION + SHIELD_CAST_TIME + 1
+          remainingCast + RULES.GCD_DURATION + RULES.SHIELD_CAST_TIME + 1
 			) 
 			{
-				const dodgeDir = getDodgeDirectionForMovement(threats, state.position);
+				const dodgeDir = getDodgeDirectionForMovement(threats, position);
 				const cancelMove = combatMove(
-					state.position,
+					position,
 					enemy,
 					distance,
 					targetDistance,
 					dodgeDir,
-					state.tick,
+					tick,
 					strafeCyclePeriod,
 					strafeIntensity,
 					approachSpeed,
 					distanceDeadZone,
+					centerBias,
 				);
-				return {move: cancelMove, cancel: true};
+				const safeCancelMove = keepOffWalls(position, cancelMove);
+				return cancel().move(safeCancelMove.x, safeCancelMove.y);
 			}
 		}
 
@@ -323,24 +362,26 @@ export const Stormchaser: WizardFunction = ({state}) =>
 		// At low health, surviving is more important than finishing the attack.
 		if (
 			arrivesInGCD &&
-      state.health <= incomingDamage + 1 &&
+      health <= incomingDamage + 1 &&
       remainingCast > 10
 		) 
 		{
-			const dodgeDir = getDodgeDirectionForMovement(threats, state.position);
+			const dodgeDir = getDodgeDirectionForMovement(threats, position);
 			const cancelMove = combatMove(
-				state.position,
+				position,
 				enemy,
 				distance,
 				targetDistance,
 				dodgeDir,
-				state.tick,
+				tick,
 				strafeCyclePeriod,
 				strafeIntensity,
 				approachSpeed,
 				distanceDeadZone,
+				centerBias,
 			);
-			return {move: cancelMove, cancel: true};
+			const safeCancelMove = keepOffWalls(position, cancelMove);
+			return cancel().move(safeCancelMove.x, safeCancelMove.y);
 		}
 	}
 
@@ -348,27 +389,25 @@ export const Stormchaser: WizardFunction = ({state}) =>
 	// Blink dodges the incoming missile — no GCD after, so can immediately fire back.
 	// Only shield when blink is on cooldown.
 	if (
-		state.state === 'idle' &&
+		status === 'idle' &&
     urgentThreat &&
-    state.blinkCooldown === 0 &&
+    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);
 	}
 
 	// === DEFENSE: Shield threats (when blink is on cooldown) ===
-	if (state.state === 'idle' && urgentThreat) 
+	if (status === 'idle' && urgentThreat) 
 	{
 		const forceShield = shouldForceShield(urgentThreat);
 		const undodgeable = !urgentThreat.bestDodgeDirection;
-		const healthLow = state.health < healthLowThreshold;
+		const healthLow = health < healthLowThreshold;
 		const healthCritical =
-			state.health <= urgentThreat.projectile.damage * healthDamageRatio + 1;
+			health <= urgentThreat.projectile.damage * healthDamageRatio + 1;
 		const shouldShield =
 			forceShield || (undodgeable && healthLow) || healthCritical;
 
@@ -376,60 +415,66 @@ export const Stormchaser: WizardFunction = ({state}) =>
 		{
 			if (urgentThreat.ticksToStartShield <= 3) 
 			{
-				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();
+		}
+	}
+
 	// === MOVEMENT: Smart combat movement ===
-	const dodgeDirection = getDodgeDirectionForMovement(threats, state.position);
+	const dodgeDirection = getDodgeDirectionForMovement(threats, position);
 	const move = combatMove(
-		state.position,
+		position,
 		enemy,
 		distance,
 		targetDistance,
 		dodgeDirection,
-		state.tick,
+		tick,
 		strafeCyclePeriod,
 		strafeIntensity,
 		approachSpeed,
 		distanceDeadZone,
+		centerBias,
 	);
-
+	const safeMove = keepOffWalls(position, move);
 	// === OFFENSE: Attack aggressively while moving ===
-	if (state.state === 'idle' && distance < attackRange) 
+	if (status === 'idle' && distance < attackRange)
 	{
+		const reposition = getPreCastReposition(position, enemy.position);
+		if (reposition) return moveAction(reposition.x, reposition.y);
+
 		// Primary: standard homing missile
 		const standardCastTime = getMissileCastTime(STANDARD_CONFIG);
 		if (isSafeToAttack(threats, standardCastTime)) 
 		{
-			return {
-				move,
-				startCast: {
-					spell: 'missile',
-					config: STANDARD_CONFIG,
-					missileAI: StormchaserMissileAI,
-					direction: angleTo(state.position, enemy.position),
-				},
-			};
+			return missile(STANDARD_CONFIG, StormchaserMissileAI, angleTo(position, enemy.position)).move(safeMove.x, safeMove.y);
 		}
 
 		// Fallback: quick missile under pressure (shorter cast = smaller vulnerability window)
 		const quickCastTime = getMissileCastTime(QUICK_CONFIG);
 		if (isSafeToAttack(threats, quickCastTime)) 
 		{
-			return {
-				move,
-				startCast: {
-					spell: 'missile',
-					config: QUICK_CONFIG,
-					missileAI: StormchaserMissileAI,
-					direction: angleTo(state.position, enemy.position),
-				},
-			};
+			return missile(QUICK_CONFIG, StormchaserMissileAI, angleTo(position, enemy.position)).move(safeMove.x, safeMove.y);
 		}
 
 		// Not safe to attack — wait for threat to pass, then fire
@@ -439,19 +484,16 @@ export const Stormchaser: WizardFunction = ({state}) =>
 	// If all offense checks failed and there's an undodgeable threat, shield it
 	// rather than sitting idle and taking the hit.
 	if (
-		state.state === 'idle' &&
+		status === 'idle' &&
     urgentThreat &&
     !urgentThreat.bestDodgeDirection &&
     urgentThreat.canBlockInTime &&
     urgentThreat.ticksToStartShield <= 3
 	) 
 	{
-		return {
-			move: {x: 0, y: 0},
-			startCast: {spell: 'shield'},
-		};
+		return shield();
 	}
 
 	// Default: just move (dodging/positioning)
-	return {move};
-};
+	return moveAction(safeMove.x, safeMove.y);
+}