@vibemancer/core 0.1.4 → 0.1.5

package/src/bots/melee/03_Voidblade.ts

@@ -1,28 +1,32 @@
-import {WizardFunction} from '../../types.js';
+import type {FinalAction, MissileAction} from '../../hooks/index.js';
+import {usePosition, useEnemy, useStatus, useBlinkCooldown, useTick, useThreats, useProjectiles, useLastMissileConfig, useCastingSpell, useCastProgress, idle, move as moveAction, missile, shield, blink, cancel, flyStraight, getMissileContext, turnToward} from '../../hooks/index.js';
 import {distanceTo} from '../../utils/distance.js';
 import {angleTo} from '../../utils/angles.js';
+import {RULES, ARENA_MIN, ARENA_MAX} from '../../rules.js';
 import {
-	ARENA_SIZE,
-	GCD_DURATION,
-	SHIELD_CAST_TIME,
-	BLINK_CAST_TIME,
-} from '../../rules.js';
-import {
-	getThreats,
 	getMostUrgentThreat,
 	getDodgeDirectionForMovement,
 	getBlinkToDecreaseDistance,
 	shouldForceShield,
-	fitMissileToBudget,
+	fitMissileForEscapingTarget,
 	MIN_USEFUL_DAMAGE,
 	getEnemyVulnerabilityTicks,
+	keepOffWalls,
+	getPreCastReposition,
 } from '../shared.js';
-import {getMissileCastTime} from '../../utils/combat.js';
+import {getMissileCastTime, getLeadPosition} from '../../utils/combat.js';
 import {useParam} from '../../engine/params-runtime.js';
 
 const WALL_BUFFER = 50;
 const SHIELD_BUFFER = 3;
 
+const HomingStabAI = (): MissileAction =>
+{
+	const ctx = getMissileContext();
+	const enemy = ctx.worldState.enemies[0];
+	return enemy ? turnToward(enemy.position.x, enemy.position.y) : flyStraight();
+};
+
 /**
  * Aggressive movement: dodge missiles, close distance, light strafe.
  */
@@ -35,12 +39,22 @@ function aggressiveMove(
 	strafeCyclePeriod: number,
 	strafeIntensity: number,
 	approachSpeed: 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;
+
 	const strafeClockwise = {
 		x: -deltaY / normalizedDistance,
 		y: deltaX / normalizedDistance,
@@ -57,10 +71,10 @@ function aggressiveMove(
 		strafeDirection = dodgeDirection;
 	}
 	else if (
-		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
 	) 
 	{
 		const futureClockwise = {
@@ -72,16 +86,16 @@ function aggressiveMove(
 			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
@@ -96,20 +110,20 @@ function aggressiveMove(
 
 	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;
 
-	moveX += (deltaX / normalizedDistance) * approachSpeed;
-	moveY += (deltaY / normalizedDistance) * approachSpeed;
+	moveX += (approachDirX / approachMag) * approachSpeed;
+	moveY += (approachDirY / approachMag) * approachSpeed;
 
 	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};
@@ -137,41 +151,53 @@ function aggressiveMove(
  * PROGRESSION LINE: Shadowblade → Nightblade → Voidblade
  * TIER: 3 (elite Melee line)
  */
-export const Voidblade: WizardFunction = ({state}) => 
+export function Voidblade(): FinalAction
 {
+	const position = usePosition();
+	const enemy = useEnemy();
+	const status = useStatus();
+	const blinkCooldown = useBlinkCooldown();
+	const tick = useTick();
+	const threats = useThreats();
+	const projectiles = useProjectiles();
+	const lastMissileConfig = useLastMissileConfig();
+	const castingSpell = useCastingSpell();
+	const castProgressData = useCastProgress();
+
+
 	const preemptiveShieldRange = useParam('preemptiveShieldRange', 348, {
 		range: 85,
 		min: 50,
 		steps: 7,
 	});
-	const shieldWindow = useParam('shieldWindow', 18, {
+	const shieldWindow = useParam('shieldWindow', 5, {
 		range: 10,
 		min: 5,
 		max: 30,
 		steps: 5,
 	});
-	const punishMinVulnerability = useParam('punishMinVulnerability', 10, {
+	const punishMinVulnerability = useParam('punishMinVulnerability', 15, {
 		range: 15,
 		min: 10,
 		steps: 5,
 	});
 	const preferBlinkDodge =
 		useParam('preferBlinkDodge', 0, {min: 0, max: 1, steps: 2}) >= 0.5;
-	const strafeCyclePeriod = useParam('strafeCyclePeriod', 231, {
+	const strafeCyclePeriod = useParam('strafeCyclePeriod', 230, {
 		range: 75,
 		min: 80,
 		max: 250,
 	});
-	const strafeIntensity = useParam('strafeIntensity', 45, {
-		range: 30,
-		min: 10,
-		max: 80,
+	const strafeIntensity = useParam('strafeIntensity', 0.28, {
+		range: 0.3,
+		min: 0.1,
+		max: 0.8,
 		steps: 7,
 	});
-	const approachSpeed = useParam('approachSpeed', 92, {
-		range: 20,
-		min: 50,
-		max: 100,
+	const approachSpeed = useParam('approachSpeed', 1, {
+		range: 0.2,
+		min: 0.5,
+		max: 1,
 		steps: 7,
 	});
 	const shieldCancelThreshold = useParam('shieldCancelThreshold', 150, {
@@ -185,7 +211,7 @@ export const Voidblade: WizardFunction = ({state}) =>
 		max: 80,
 		steps: 7,
 	});
-	const blinkPastMargin = useParam('blinkPastMargin', 50, {
+	const blinkPastMargin = useParam('blinkPastMargin', 61, {
 		range: 30,
 		min: 20,
 		max: 100,
@@ -203,13 +229,13 @@ export const Voidblade: WizardFunction = ({state}) =>
 		max: 200,
 		steps: 7,
 	});
-	const counterStabRange = useParam('counterStabRange', 27, {
-		range: 20,
+	const counterStabRange = useParam('counterStabRange', 14, {
+		range: 30,
 		min: 10,
-		max: 60,
+		max: 80,
 		steps: 7,
 	});
-	const flightTimeDivisor = useParam('flightTimeDivisor', 7.5, {
+	const flightTimeDivisor = useParam('flightTimeDivisor', 3, {
 		range: 4,
 		min: 3,
 		max: 12,
@@ -221,16 +247,16 @@ export const Voidblade: WizardFunction = ({state}) =>
 		max: 10,
 		steps: 5,
 	});
-	const idleProvokeBudget = useParam('idleProvokeBudget', 37, {
+	const idleProvokeBudget = useParam('idleProvokeBudget', 110, {
 		range: 40,
 		min: 20,
 		max: 120,
 		steps: 7,
 	});
-	const meleeAbortRange = useParam('meleeAbortRange', 50, {
-		range: 50,
+	const meleeAbortRange = useParam('meleeAbortRange', 100, {
+		range: 100,
 		min: 50,
-		max: 200,
+		max: 400,
 		steps: 7,
 	});
 	const enemyFiringSoonThreshold = useParam('enemyFiringSoonThreshold', 50, {
@@ -239,60 +265,136 @@ export const Voidblade: WizardFunction = ({state}) =>
 		max: 100,
 		steps: 7,
 	});
+	const useDynamicStab =
+		useParam('useDynamicStab', 1, {min: 0, max: 1, steps: 2}) >= 0.5;
+	const stabDamage = Math.round(useParam('stabDamage', 5, {
+		range: 10,
+		min: 5,
+		max: 25,
+		steps: 7,
+	}));
+	const centerBias = useParam('centerBias', 0.8, {
+		range: 0.3,
+		min: 0,
+		max: 0.8,
+		steps: 5,
+	});
+	const saveBlinkForChase =
+		useParam('saveBlinkForChase', 0, {min: 0, max: 1, steps: 2}) >= 0.5;
+	const chaseBlinkRange = useParam('chaseBlinkRange', 200, {
+		range: 100,
+		min: 100,
+		max: 400,
+		steps: 5,
+	});
+	const maxBlinkDistance = useParam('maxBlinkDistance', 278, {
+		range: 100,
+		min: 50,
+		max: 300,
+		steps: 7,
+	});
+	const stabTurnRate = useParam('stabTurnRate', 0, {
+		min: 0,
+		max: 1,
+		steps: 5,
+	});
+	const stabSpeed = useParam('stabSpeed', 11.3, {
+		range: 3,
+		min: 5,
+		max: 12,
+		steps: 5,
+	});
+	const stabDuration = Math.round(useParam('stabDuration', 33, {
+		range: 15,
+		min: 15,
+		max: 50,
+		steps: 5,
+	}));
+	const useLeadAiming =
+		useParam('useLeadAiming', 0, {min: 0, max: 1, steps: 2}) >= 0.5;
+	const useHomingAI =
+		useParam('useHomingAI', 0, {min: 0, max: 1, steps: 2}) >= 0.5;
+	const FAST_STAB = {speed: stabSpeed, turnRate: stabTurnRate, duration: stabDuration};
 
-	const enemy = state.enemies[0];
-	if (!enemy) 
-	{
-		return {move: {x: 0, y: 0}};
-	}
+	const distance = distanceTo(position, enemy.position);
+
+	const stabAimAngle = useLeadAiming
+		? angleTo(position, getLeadPosition(enemy.position, enemy.velocity, FAST_STAB.speed, position))
+		: angleTo(position, enemy.position);
+	const stabAI = useHomingAI ? HomingStabAI : (): MissileAction => flyStraight();
 
-	const distance = distanceTo(state.position, enemy.position);
-	const threats = getThreats(state);
 	const urgentThreat = getMostUrgentThreat(threats);
-	const dodgeDirection = getDodgeDirectionForMovement(threats, state.position);
+	const dodgeDirection = getDodgeDirectionForMovement(threats, position);
 	const vulnerabilityTicks = getEnemyVulnerabilityTicks(enemy);
 
 	const move = aggressiveMove(
-		state.position,
+		position,
 		enemy,
 		distance,
 		dodgeDirection,
-		state.tick,
+		tick,
 		strafeCyclePeriod,
 		strafeIntensity,
 		approachSpeed,
+		centerBias,
 	);
+	const safeMove = keepOffWalls(position, move);
+
+	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};
+	}
 
 	// Precompute blink targets — used by blink-dodge and engage-blink.
 	// blinkCloseTarget: from getBlinkToDecreaseDistance (dodge + close gap). Null at melee range.
 	// blinkPastTarget: blink ~200u past enemy (dodge only, loses position). For in-flight missiles only.
 	let blinkCloseTarget: {x: number; y: number} | null = null;
 	let blinkPastTarget: {x: number; y: number} | null = null;
-	if (state.blinkCooldown === 0) 
+	if (blinkCooldown === 0)
 	{
-		blinkCloseTarget = getBlinkToDecreaseDistance(
-			state.position,
+		const rawBlinkTarget = getBlinkToDecreaseDistance(
+			position,
 			enemy.position,
-			state.projectiles,
+			projectiles,
 		);
-		if (!blinkCloseTarget) 
+		if (rawBlinkTarget)
 		{
-			const dx = enemy.position.x - state.position.x;
-			const dy = enemy.position.y - state.position.y;
+			const center = (ARENA_MIN + ARENA_MAX) / 2;
+			const enemyDistToCenter = Math.max(
+				Math.abs(enemy.position.x - center),
+				Math.abs(enemy.position.y - center),
+			);
+			const capped = capBlinkDistance(rawBlinkTarget);
+			const blinkDistToCenter = Math.max(
+				Math.abs(capped.x - center),
+				Math.abs(capped.y - center),
+			);
+			if (blinkDistToCenter <= enemyDistToCenter + 30) blinkCloseTarget = capped;
+		}
+		if (!blinkCloseTarget)
+		{
+			const dx = enemy.position.x - position.x;
+			const dy = enemy.position.y - position.y;
 			const norm = Math.sqrt(dx * dx + dy * dy) || 1;
+			const cappedDist = Math.min(blinkPastDistance, maxBlinkDistance);
 			blinkPastTarget = {
 				x: Math.max(
-					blinkPastMargin,
+					ARENA_MIN + blinkPastMargin,
 					Math.min(
-						ARENA_SIZE - blinkPastMargin,
-						state.position.x + (dx / norm) * blinkPastDistance,
+						ARENA_MAX - blinkPastMargin,
+						position.x + (dx / norm) * cappedDist,
 					),
 				),
 				y: Math.max(
-					blinkPastMargin,
+					ARENA_MIN + blinkPastMargin,
 					Math.min(
-						ARENA_SIZE - blinkPastMargin,
-						state.position.y + (dy / norm) * blinkPastDistance,
+						ARENA_MAX - blinkPastMargin,
+						position.y + (dy / norm) * cappedDist,
 					),
 				),
 			};
@@ -300,12 +402,12 @@ export const Voidblade: WizardFunction = ({state}) =>
 	}
 
 	// === STEP 1: CHANNELING — hold shield until missile passes ===
-	if (state.state === 'channeling') 
+	if (status === 'channeling') 
 	{
 		// Hold shield while there's an active threat OR enemy is about to fire
 		const enemyFiringSoon =
 			distance < preemptiveShieldRange &&
-      enemy.state === 'casting' &&
+      enemy.status === 'casting' &&
       enemy.castingSpell === 'missile' &&
       (enemy.castDuration ?? 0) -
         (enemy.castProgress ?? 0) +
@@ -317,39 +419,39 @@ export const Voidblade: WizardFunction = ({state}) =>
       (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: CAST-CANCEL INTO DEFENSE ===
 	// If we're casting a stab and a missile is incoming, cancel so we can
 	// blink-dodge (if available) or shield. Defense time depends on blink availability.
-	if (state.state === 'casting' && state.castingSpell === 'missile') 
+	if (status === 'casting' && castingSpell === 'missile') 
 	{
 		// Cancel if target escaped melee range
-		if (distance > meleeAbortRange) 
+		if (distance > meleeAbortRange)
 		{
-			return {move, cancel: true};
+			return cancel().move(safeMove.x, safeMove.y);
 		}
 
 		// Defense time: blink (10t) is faster than shield (20t + 3t buffer)
 		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;
 
 		// Cancel for any undodgeable incoming threat we can't finish casting before
 		if (urgentThreat && !urgentThreat.bestDodgeDirection) 
 		{
 			const remainingCast =
-				(state.castDuration ?? 0) - (state.castProgress ?? 0);
+				((castProgressData?.total) ?? 0) - ((castProgressData?.current) ?? 0);
 			const willArriveInWindow =
 				urgentThreat.ticksToImpact <=
-        remainingCast + GCD_DURATION + defenseTime;
-			if (willArriveInWindow) 
+        remainingCast + RULES.GCD_DURATION + defenseTime;
+			if (willArriveInWindow)
 			{
-				return {move, cancel: true};
+				return cancel().move(safeMove.x, safeMove.y);
 			}
 		}
 
@@ -357,28 +459,28 @@ export const Voidblade: WizardFunction = ({state}) =>
 		// at melee range their missile will arrive too fast to react after our cast finishes
 		if (
 			distance < preemptiveShieldRange &&
-      enemy.state === 'casting' &&
+      enemy.status === 'casting' &&
       enemy.castingSpell === 'missile'
 		) 
 		{
 			const remainingEnemyCast =
 				(enemy.castDuration ?? 0) - (enemy.castProgress ?? 0);
 			const remainingOurCast =
-				(state.castDuration ?? 0) - (state.castProgress ?? 0);
+				((castProgressData?.total) ?? 0) - ((castProgressData?.current) ?? 0);
 			const estimatedFlightTicks = distance / enemyFlightTimeDivisor;
 			const ticksUntilEnemyHit = remainingEnemyCast + estimatedFlightTicks;
-			const ticksAfterOurCast = remainingOurCast + GCD_DURATION + defenseTime;
+			const ticksAfterOurCast = remainingOurCast + RULES.GCD_DURATION + defenseTime;
 
 			// If enemy missile will arrive before we can defend after our cast, cancel now
-			if (ticksUntilEnemyHit < ticksAfterOurCast) 
+			if (ticksUntilEnemyHit < ticksAfterOurCast)
 			{
-				return {move, cancel: true};
+				return cancel().move(safeMove.x, safeMove.y);
 			}
 		}
 	}
 
 	// === STEP 3: BLINK-DODGE — 100% damage avoidance (preferred over shield) ===
-	if (state.state === 'idle' && state.blinkCooldown === 0) 
+	if (status === 'idle' && blinkCooldown === 0) 
 	{
 		// Blink target for dodging: close-gap target if available, else blink-past for in-flight only
 		const dodgeBlinkTarget = blinkCloseTarget ?? blinkPastTarget;
@@ -392,10 +494,7 @@ export const Voidblade: WizardFunction = ({state}) =>
       urgentThreat.ticksToImpact <= blinkWindowMax
 		) 
 		{
-			return {
-				move: {x: 0, y: 0},
-				startCast: {spell: 'blink', target: dodgeBlinkTarget},
-			};
+			return blink(dodgeBlinkTarget.x, dodgeBlinkTarget.y);
 		}
 
 		// 3b: Preemptive blink-dodge — only when we have a close-gap target.
@@ -405,7 +504,7 @@ export const Voidblade: WizardFunction = ({state}) =>
 			preferBlinkDodge &&
       blinkCloseTarget &&
       distance < preemptiveShieldRange &&
-      enemy.state === 'casting' &&
+      enemy.status === 'casting' &&
       enemy.castingSpell === 'missile'
 		) 
 		{
@@ -415,29 +514,40 @@ export const Voidblade: WizardFunction = ({state}) =>
 			const ticksUntilHit = remainingCast + estimatedFlightTicks;
 
 			if (
-				ticksUntilHit >= BLINK_CAST_TIME &&
-        ticksUntilHit < BLINK_CAST_TIME + shieldWindow
+				ticksUntilHit >= RULES.BLINK_CAST_TIME &&
+        ticksUntilHit < RULES.BLINK_CAST_TIME + shieldWindow
 			) 
 			{
-				return {
-					move: {x: 0, y: 0},
-					startCast: {spell: 'blink', target: blinkCloseTarget},
-				};
+				return blink(blinkCloseTarget.x, blinkCloseTarget.y);
 			}
 		}
 
 		// 3c: Engage blink — close distance during enemy vulnerability (they can't react)
+		// Skip if saving blink for chase (use blink reactively, not proactively)
 		if (
+			!saveBlinkForChase &&
 			blinkCloseTarget &&
       distance > engageBlinkRange &&
       vulnerabilityTicks >= punishMinVulnerability &&
       (!urgentThreat || urgentThreat.bestDodgeDirection !== null)
-		) 
+		)
 		{
-			return {
-				move: {x: 0, y: 0},
-				startCast: {spell: 'blink', target: blinkCloseTarget},
+			return blink(blinkCloseTarget.x, blinkCloseTarget.y);
+		}
+
+		// 3d: Chase blink — enemy blinked away after we've fought at melee range
+		if (distance > chaseBlinkRange && lastMissileConfig)
+		{
+			const center = (ARENA_MIN + ARENA_MAX) / 2;
+			const toCX = center - enemy.position.x;
+			const toCY = center - enemy.position.y;
+			const toCDist = Math.sqrt(toCX * toCX + toCY * toCY) || 1;
+			const rawChase = {
+				x: enemy.position.x + (toCX / toCDist) * 15,
+				y: enemy.position.y + (toCY / toCDist) * 15,
 			};
+			const chaseTarget = capBlinkDistance(rawChase);
+			return blink(chaseTarget.x, chaseTarget.y);
 		}
 	}
 
@@ -446,25 +556,22 @@ export const Voidblade: WizardFunction = ({state}) =>
 	// 4a: Shield in-flight missiles
 	// Shield when: no blink target at all, or missile too close for blink (<10 ticks)
 	if (
-		state.state === 'idle' &&
+		status === 'idle' &&
     urgentThreat &&
     (!urgentThreat.bestDodgeDirection || shouldForceShield(urgentThreat)) &&
     urgentThreat.canBlockInTime &&
     ((!blinkCloseTarget && !blinkPastTarget) || urgentThreat.ticksToImpact < 10)
-	) 
+	)
 	{
-		return {
-			move: {x: 0, y: 0},
-			startCast: {spell: 'shield'},
-		};
+		return shield();
 	}
 
 	// 4b: Preemptive shield — when blink can't close gap (melee range or cooldown)
 	if (
-		state.state === 'idle' &&
+		status === 'idle' &&
     !blinkCloseTarget &&
     distance < preemptiveShieldRange &&
-    enemy.state === 'casting' &&
+    enemy.status === 'casting' &&
     enemy.castingSpell === 'missile'
 	) 
 	{
@@ -473,26 +580,26 @@ export const Voidblade: WizardFunction = ({state}) =>
 		const ticksUntilHit = remainingCast + estimatedFlightTicks;
 
 		if (
-			ticksUntilHit >= SHIELD_CAST_TIME &&
-      ticksUntilHit < SHIELD_CAST_TIME + shieldWindow
+			ticksUntilHit >= RULES.SHIELD_CAST_TIME &&
+      ticksUntilHit < RULES.SHIELD_CAST_TIME + shieldWindow
 		) 
 		{
-			return {
-				move: {x: 0, y: 0},
-				startCast: {spell: 'shield'},
-			};
+			return shield();
 		}
 	}
 
 	// === STEP 5: COUNTER-STAB — fire during enemy vulnerability ===
 	// Only fire when enemy CAN'T shield (in GCD or mid-cast).
 	// Use small, fast stabs that fit within the vulnerability window.
-	if (state.state === 'idle' && distance < counterStabRange) 
+	if (status === 'idle' && distance < counterStabRange)
 	{
+		const reposition = getPreCastReposition(position, enemy.position);
+		if (reposition) return moveAction(reposition.x, reposition.y);
+
 		const enemyHP = Math.ceil(enemy.health);
 		const flightTime = Math.ceil(distance / flightTimeDivisor) + 1;
 
-		if (vulnerabilityTicks >= punishMinVulnerability) 
+		if (vulnerabilityTicks >= punishMinVulnerability)
 		{
 			// Budget: stab must land while enemy is still vulnerable
 			// castTime + flightTime < vulnerabilityTicks
@@ -502,7 +609,7 @@ export const Voidblade: WizardFunction = ({state}) =>
 			let nextThreatTime = urgentThreat?.ticksToImpact ?? Infinity;
 
 			// Account for enemy's active cast — their missile will arrive after cast completes + flight time
-			if (enemy.state === 'casting' && enemy.castingSpell === 'missile') 
+			if (enemy.status === 'casting' && enemy.castingSpell === 'missile') 
 			{
 				const remainingEnemyCast =
 					(enemy.castDuration ?? 0) - (enemy.castProgress ?? 0);
@@ -515,35 +622,31 @@ export const Voidblade: WizardFunction = ({state}) =>
 
 			// Defense time: blink (10t) is faster than shield (20t + 3t buffer)
 			const defenseTime =
-				state.blinkCooldown === 0
-					? BLINK_CAST_TIME
-					: SHIELD_CAST_TIME + SHIELD_BUFFER;
-			const safeBudget = nextThreatTime - GCD_DURATION - defenseTime;
+				blinkCooldown === 0
+					? RULES.BLINK_CAST_TIME
+					: RULES.SHIELD_CAST_TIME + SHIELD_BUFFER;
+			const safeBudget = nextThreatTime - RULES.GCD_DURATION - defenseTime;
 			const effectiveBudget = Math.min(punishBudget, safeBudget);
 
-			if (effectiveBudget > 0) 
+			if (effectiveBudget > 0)
 			{
-				const config = fitMissileToBudget(effectiveBudget, distance, {
-					minTurnRate: 0,
-					maxDamage: enemyHP,
-					lastMissileConfig: state.lastMissileConfig,
-				});
+				let config = useDynamicStab
+					? fitMissileForEscapingTarget(effectiveBudget, distance, {
+						minTurnRate: 0,
+						maxDamage: enemyHP,
+						lastMissileConfig: lastMissileConfig,
+					})
+					: null;
+
+				if (!config || config.damage < MIN_USEFUL_DAMAGE)
+				{
+					config = {damage: stabDamage, speed: FAST_STAB.speed, turnRate: FAST_STAB.turnRate, duration: FAST_STAB.duration};
+				}
 
-				if (config && config.damage >= MIN_USEFUL_DAMAGE) 
+				const castTime = getMissileCastTime(config, lastMissileConfig);
+				if (castTime <= effectiveBudget && castTime + flightTime <= vulnerabilityTicks)
 				{
-					const castTime = getMissileCastTime(config, state.lastMissileConfig);
-					if (castTime + flightTime <= vulnerabilityTicks) 
-					{
-						return {
-							move,
-							startCast: {
-								spell: 'missile',
-								config,
-								missileAI: () => ({}),
-								direction: angleTo(state.position, enemy.position),
-							},
-						};
-					}
+					return missile(config, stabAI, stabAimAngle).move(safeMove.x, safeMove.y);
 				}
 			}
 		}
@@ -553,30 +656,25 @@ export const Voidblade: WizardFunction = ({state}) =>
 		// Channeling: shield blocks ~90% but 10% still lands. Stabs whittle HP so they
 		// can't just hold shield forever. Why: otherwise the bot waits for a
 		// vulnerability window that a channeling player never opens.
-		if ((enemy.state === 'idle' || enemy.state === 'channeling') && !urgentThreat)
+		if ((enemy.status === 'idle' || enemy.status === 'channeling') && !urgentThreat)
 		{
-			// Use a small budget to keep stabs fast and stay reactive
 			const quickBudget = idleProvokeBudget;
-			const config = fitMissileToBudget(quickBudget, distance, {
-				minTurnRate: 0,
-				maxDamage: enemyHP,
-				lastMissileConfig: state.lastMissileConfig,
-			});
+			let config = useDynamicStab
+				? fitMissileForEscapingTarget(quickBudget, distance, {
+					minTurnRate: 0,
+					maxDamage: enemyHP,
+					lastMissileConfig: lastMissileConfig,
+				})
+				: null;
 
-			if (config) 
+			if (!config)
 			{
-				return {
-					move,
-					startCast: {
-						spell: 'missile',
-						config,
-						missileAI: () => ({}),
-						direction: angleTo(state.position, enemy.position),
-					},
-				};
+				config = {damage: stabDamage, speed: FAST_STAB.speed, turnRate: FAST_STAB.turnRate, duration: FAST_STAB.duration};
 			}
+
+			return missile(config, stabAI, stabAimAngle).move(safeMove.x, safeMove.y);
 		}
 	}
 
-	return {move};
-};
+	return moveAction(safeMove.x, safeMove.y);
+}