@vibemancer/core 0.1.4 → 0.1.5

package/src/bots/melee/02_Nightblade.ts

@@ -1,20 +1,23 @@
-import {WizardFunction} from '../../types.js';
+import type {FinalAction} 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, flyStraight} from '../../hooks/index.js';
 import {distanceTo} from '../../utils/distance.js';
 import {angleTo} from '../../utils/angles.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,
 	getBlinkToDecreaseDistance,
 	shouldForceShield,
-	fitMissileToBudget,
+	fitMissileForEscapingTarget,
 	MAX_CAST_BUDGET,
 	MIN_USEFUL_DAMAGE,
+	keepOffWalls,
+	getPreCastReposition,
 } from '../shared.js';
 import {useParam} from '../../engine/params-runtime.js';
 const WALL_BUFFER = 50;
 const SHIELD_BUFFER = 3;
+const FAST_STAB = {speed: 8, turnRate: 0, duration: 25};
 
 /**
  * Aggressive movement: dodge missiles, close distance, light strafe.
@@ -28,12 +31,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,
@@ -50,10 +63,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 = {
@@ -65,16 +78,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
@@ -90,7 +103,7 @@ function aggressiveMove(
 	// When actively dodging, commit fully
 	if (dodgeDirection) 
 	{
-		return {x: strafeDirection.x * 100, y: strafeDirection.y * 100};
+		return {x: strafeDirection.x, y: strafeDirection.y};
 	}
 
 	// Light strafe + aggressive closing
@@ -98,14 +111,14 @@ function aggressiveMove(
 	let moveY = strafeDirection.y * strafeIntensity;
 
 	// Always close distance aggressively
-	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};
@@ -128,11 +141,25 @@ function aggressiveMove(
  *
  * TIER: 2 (enhanced Shadowblade)
  */
-export const Nightblade: WizardFunction = ({state}) => 
+export function Nightblade(): FinalAction
 {
-	const stabRange = useParam('stabRange', 263, {range: 38, min: 0, steps: 5});
+	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();
+
+
+	const stabRange = useParam('stabRange', 142, {range: 38, min: 0, steps: 5});
 	const stabRangeVsCasting = stabRange + 20;
-	const preemptiveShieldRange = useParam('preemptiveShieldRange', 261, {
+	const preemptiveShieldRange = useParam('preemptiveShieldRange', 94, {
 		range: 85,
 		min: 0,
 		steps: 7,
@@ -143,22 +170,22 @@ export const Nightblade: WizardFunction = ({state}) =>
 		max: 1,
 		steps: 5,
 	});
-	const minTurnRate = useParam('minTurnRate', -11.4, {range: 5.25, steps: 5});
-	const strafeCyclePeriod = useParam('strafeCyclePeriod', 300, {
+	const minTurnRate = useParam('minTurnRate', 0, {range: 2, min: 0, steps: 5});
+	const strafeCyclePeriod = useParam('strafeCyclePeriod', 174, {
 		range: 75,
 		min: 80,
 		max: 300,
 	});
-	const strafeIntensity = useParam('strafeIntensity', 22, {
-		range: 30,
-		min: 10,
-		max: 80,
+	const strafeIntensity = useParam('strafeIntensity', 0.2, {
+		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', 0.98, {
+		range: 0.2,
+		min: 0.5,
+		max: 1,
 		steps: 7,
 	});
 	const shieldCancelThreshold = useParam('shieldCancelThreshold', 50, {
@@ -166,13 +193,13 @@ export const Nightblade: WizardFunction = ({state}) =>
 		min: 50,
 		max: 300,
 	});
-	const blinkWindowMax = useParam('blinkWindowMax', 19, {
+	const blinkWindowMax = useParam('blinkWindowMax', 15, {
 		range: 30,
 		min: 15,
 		max: 80,
 		steps: 7,
 	});
-	const flightTimeDivisor = useParam('flightTimeDivisor', 12, {
+	const flightTimeDivisor = useParam('flightTimeDivisor', 11, {
 		range: 4,
 		min: 2,
 		max: 12,
@@ -184,43 +211,67 @@ export const Nightblade: WizardFunction = ({state}) =>
 		max: 100,
 		steps: 7,
 	});
-	const meleeAbortRange = useParam('meleeAbortRange', 200, {
+	const meleeAbortRange = useParam('meleeAbortRange', 178, {
 		range: 50,
 		min: 50,
 		max: 200,
 		steps: 7,
 	});
+	const useDynamicStab =
+		useParam('useDynamicStab', 0, {min: 0, max: 1, steps: 2}) >= 0.5;
+	const stabDamage = Math.round(useParam('stabDamage', 23, {
+		range: 10,
+		min: 5,
+		max: 25,
+		steps: 7,
+	}));
+	const centerBias = useParam('centerBias', 0.7, {
+		range: 0.4,
+		min: 0,
+		max: 0.8,
+		steps: 5,
+	});
+	const maxBlinkDistance = useParam('maxBlinkDistance', 200, {
+		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);
-
-	const threats = getThreats(state);
 	const urgentThreat = getMostUrgentThreat(threats);
 
-	const dodgeDirection = getDodgeDirectionForMovement(threats, state.position);
+	const dodgeDirection = getDodgeDirectionForMovement(threats, position);
 	const move = aggressiveMove(
-		state.position,
+		position,
 		enemy,
 		distance,
 		dodgeDirection,
-		state.tick,
+		tick,
 		strafeCyclePeriod,
 		strafeIntensity,
 		approachSpeed,
+		centerBias,
 	);
-
+	const safeMove = keepOffWalls(position, move);
 	// === DEFENSE: Handle channeling ===
-	if (state.state === 'channeling') 
+	if (status === 'channeling') 
 	{
 		// Keep shield up if enemy is about to fire at close range (preemptive shield scenario)
 		const enemyFiringSoon =
 			distance < preemptiveShieldRange &&
-      enemy.state === 'casting' &&
+      enemy.status === 'casting' &&
       enemy.castingSpell === 'missile' &&
       (enemy.castDuration ?? 0) -
         (enemy.castProgress ?? 0) +
@@ -231,27 +282,27 @@ export const Nightblade: 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();
 	}
 
 	// === DEFENSE: Cancel missile cast for LETHAL incoming damage ===
 	// DPS trade: we accepted the hit when we started casting. Only cancel to survive.
 	if (
-		state.state === 'casting' &&
-    state.castingSpell === 'missile' &&
+		status === 'casting' &&
+    castingSpell === 'missile' &&
     urgentThreat &&
-    urgentThreat.projectile.damage >= state.health
+    urgentThreat.projectile.damage >= health
 	) 
 	{
-		const remainingCast = (state.castDuration ?? 0) - (state.castProgress ?? 0);
+		const remainingCast = ((castProgressData?.total) ?? 0) - ((castProgressData?.current) ?? 0);
 		if (
 			urgentThreat.ticksToImpact <=
-      remainingCast + GCD_DURATION + SHIELD_CAST_TIME + SHIELD_BUFFER
+      remainingCast + RULES.GCD_DURATION + RULES.SHIELD_CAST_TIME + SHIELD_BUFFER
 		) 
 		{
-			return {move, cancel: true};
+			return cancel().move(safeMove.x, safeMove.y);
 		}
 	}
 
@@ -259,51 +310,46 @@ export const Nightblade: WizardFunction = ({state}) =>
 	// Melee missiles are non-homing with short range (~63u). If the enemy blinked away,
 	// continuing the cast is wasted time while we're vulnerable.
 	if (
-		state.state === 'casting' &&
-    state.castingSpell === 'missile' &&
+		status === 'casting' &&
+    castingSpell === 'missile' &&
     distance > meleeAbortRange
 	) 
 	{
-		return {move, cancel: true};
+		return cancel().move(safeMove.x, safeMove.y);
 	}
 
 	// === BLINK: Dodge missile + close gap simultaneously (first priority) ===
 	// Blink both dodges the incoming missile AND closes distance — better than shielding.
 	// Only shield when blink is on cooldown.
 	if (
-		state.state === 'idle' &&
+		status === 'idle' &&
     urgentThreat &&
-    state.blinkCooldown === 0 &&
+    blinkCooldown === 0 &&
     distance > stabRange &&
     urgentThreat.ticksToImpact >= 10 &&
     urgentThreat.ticksToImpact <= blinkWindowMax
 	) 
 	{
-		const blinkTarget =
+		const rawBlinkTarget =
 			getBlinkToDecreaseDistance(
-				state.position,
+				position,
 				enemy.position,
-				state.projectiles,
+				projectiles,
 			) ?? enemy.position;
-		return {
-			move: {x: 0, y: 0},
-			startCast: {spell: 'blink', target: blinkTarget},
-		};
+		const blinkTarget = capBlinkDistance(rawBlinkTarget);
+		return blink(blinkTarget.x, blinkTarget.y);
 	}
 
 	// === DEFENSE: Shield lethal/high-damage undodgeable threats — survival over offense ===
 	if (
-		state.state === 'idle' &&
+		status === 'idle' &&
     urgentThreat &&
     (!urgentThreat.bestDodgeDirection || shouldForceShield(urgentThreat)) &&
-    urgentThreat.projectile.damage >= state.health &&
+    urgentThreat.projectile.damage >= health &&
     urgentThreat.canBlockInTime
 	) 
 	{
-		return {
-			move: {x: 0, y: 0},
-			startCast: {spell: 'shield'},
-		};
+		return shield();
 	}
 
 	// === OFFENSE: Budget-based melee stab when close enough ===
@@ -311,28 +357,31 @@ export const Nightblade: WizardFunction = ({state}) =>
 	// before needing to shield. Also stabs from farther when enemy is casting/channeling
 	// (they move at 0.5 or 0 speed, so the cast delay doesn't let them dodge).
 	const effectiveStabRange =
-		enemy.state === 'casting' || enemy.state === 'channeling'
+		enemy.status === 'casting' || enemy.status === 'channeling'
 			? stabRangeVsCasting
 			: stabRange;
 	// Skip offense when a lethal missile could reach us during cast+GCD — dodge at full speed instead
-	const myProjectileIds = new Set(state.myProjectiles.map((p) => p.id));
-	const hasNearbyLethalMissile = state.projectiles.some(
+	const myProjectileIds = new Set(myProjectiles.map((p) => p.id));
+	const hasNearbyLethalMissile = projectiles.some(
 		(p) =>
 			!myProjectileIds.has(p.id) &&
-      p.damage >= state.health &&
-      distanceTo(state.position, p.position) / p.speed <
-        MAX_CAST_BUDGET + GCD_DURATION,
+      p.damage >= health &&
+      distanceTo(position, p.position) / p.speed <
+        MAX_CAST_BUDGET + RULES.GCD_DURATION,
 	);
 	if (
-		state.state === 'idle' &&
+		status === 'idle' &&
     distance < effectiveStabRange &&
     !hasNearbyLethalMissile
-	) 
+	)
 	{
+		const reposition = getPreCastReposition(position, enemy.position);
+		if (reposition) return moveAction(reposition.x, reposition.y);
+
 		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);
@@ -344,65 +393,63 @@ export const Nightblade: WizardFunction = ({state}) =>
 		}
 
 		const safeBudget =
-			nextThreatTime - GCD_DURATION - SHIELD_CAST_TIME - SHIELD_BUFFER;
+			nextThreatTime - RULES.GCD_DURATION - RULES.SHIELD_CAST_TIME - SHIELD_BUFFER;
 		const budgetTicks = Math.min(safeBudget, MAX_CAST_BUDGET);
 		const enemyHP = Math.ceil(enemy.health);
 		const minDmg = Math.min(MIN_USEFUL_DAMAGE, enemyHP);
-		let config = fitMissileToBudget(budgetTicks, distance, {
-			minTurnRate,
-			maxDamage: enemyHP,
-			lastMissileConfig: state.lastMissileConfig,
-		});
-
-		// If budget too small for useful stab, fire bigger and accept the hit
-		// Only accept small hits (< 25% HP) — don't trade away large chunks of health
-		// Never accept when enemy is actively casting (their missile WILL arrive during our long cast)
+		const stabConfig = {damage: stabDamage, speed: FAST_STAB.speed, turnRate: FAST_STAB.turnRate, duration: FAST_STAB.duration};
+
+		let config = useDynamicStab
+			? fitMissileForEscapingTarget(budgetTicks, distance, {
+				minTurnRate,
+				maxDamage: enemyHP,
+				lastMissileConfig: lastMissileConfig,
+			})
+			: null;
+
+		// If dynamic fitting failed, try bigger budget accepting a hit
 		const enemyCasting =
-			enemy.state === 'casting' && enemy.castingSpell === 'missile';
+			enemy.status === 'casting' && enemy.castingSpell === 'missile';
 		if (
+			useDynamicStab &&
 			(!config || config.damage < minDmg) &&
-      !enemyCasting &&
-      (!urgentThreat ||
-        urgentThreat.projectile.damage < state.health * acceptHitFraction)
-		) 
+			!enemyCasting &&
+			(!urgentThreat ||
+				urgentThreat.projectile.damage < health * acceptHitFraction)
+		)
 		{
-			config = fitMissileToBudget(MAX_CAST_BUDGET, distance, {
+			config = fitMissileForEscapingTarget(MAX_CAST_BUDGET, distance, {
 				minTurnRate,
 				maxDamage: enemyHP,
-				lastMissileConfig: state.lastMissileConfig,
+				lastMissileConfig: lastMissileConfig,
 			});
 		}
 
-		if (config) 
+		// Fallback to fixed fast stab
+		if (!config || config.damage < minDmg)
 		{
-			return {
-				move,
-				startCast: {
-					spell: 'missile',
-					config,
-					missileAI: () => ({}),
-					direction: angleTo(state.position, enemy.position),
-				},
-			};
+			config = stabConfig;
+		}
+
+		if (config)
+		{
+			return missile(config, () => flyStraight(), angleTo(position, enemy.position)).move(safeMove.x, safeMove.y);
 		}
 	}
 
 	// === DEFENSE: Shield undodgeable or high-damage homing threats (only when blink can't handle it) ===
 	if (
-		state.state === 'idle' &&
+		status === 'idle' &&
     urgentThreat &&
     (!urgentThreat.bestDodgeDirection || shouldForceShield(urgentThreat))
 	) 
 	{
 		if (
 			urgentThreat.canBlockInTime &&
-      (state.blinkCooldown > 0 || urgentThreat.ticksToImpact < 10)
+      (blinkCooldown > 0 || urgentThreat.ticksToImpact < 10)
 		) 
 		{
-			return {
-				move: {x: 0, y: 0},
-				startCast: {spell: 'shield'},
-			};
+			return shield();
 		}
 	}
 
@@ -410,9 +457,9 @@ export const Nightblade: WizardFunction = ({state}) =>
 	// At melee range, missiles arrive almost instantly after launch — too fast to react.
 	// Shield BEFORE the missile launches. Trigger when shield will finish BEFORE missile hits.
 	if (
-		state.state === 'idle' &&
+		status === 'idle' &&
     distance < preemptiveShieldRange &&
-    enemy.state === 'casting' &&
+    enemy.status === 'casting' &&
     enemy.castingSpell === 'missile'
 	) 
 	{
@@ -420,18 +467,15 @@ export const Nightblade: WizardFunction = ({state}) =>
 		const estimatedFlightTicks = distance / flightTimeDivisor;
 		const ticksUntilHit = remainingCast + estimatedFlightTicks;
 		// Shield when hit is close enough that we MUST start now, but far enough that
-		// the shield finishes in time. The window: SHIELD_CAST_TIME <= ticksUntilHit < SHIELD_CAST_TIME+15
+		// the shield finishes in time. The window: RULES.SHIELD_CAST_TIME <= ticksUntilHit < RULES.SHIELD_CAST_TIME+15
 		if (
-			ticksUntilHit >= SHIELD_CAST_TIME &&
-      ticksUntilHit < SHIELD_CAST_TIME + 15
+			ticksUntilHit >= RULES.SHIELD_CAST_TIME &&
+      ticksUntilHit < RULES.SHIELD_CAST_TIME + 15
 		) 
 		{
-			return {
-				move: {x: 0, y: 0},
-				startCast: {spell: 'shield'},
-			};
+			return shield();
 		}
 	}
 
-	return {move};
-};
+	return moveAction(safeMove.x, safeMove.y);
+}