@vibemancer/core 0.1.0 → 0.1.2

package/src/bots/melee/01_Shadowblade.ts

@@ -1,270 +1,270 @@
-import {WizardFunction} from '../../types.js';
-import {distanceTo} from '../../utils/distance.js';
-import {ARENA_SIZE} from '../../rules.js';
-import {
-	getThreats,
-	getMostUrgentThreat,
-	getDodgeDirectionForMovement,
-	getBlinkToDecreaseDistance,
-	shouldForceShield,
-} from '../shared.js';
-import {useParam} from '../../engine/params-runtime.js';
-const WALL_BUFFER = 50;
-
-// Melee stab: 20 damage, speed 8, 3-hit kill.
-const STAB_CONFIG = {damage: 20, speed: 8, turnRate: 0, duration: 10};
-
-/**
- * Aggressive movement: dodge missiles using threat analysis, close distance, light strafe.
- */
-function aggressiveMove(
-	position: {x: number; y: number},
-	enemy: {position: {x: number; y: number}},
-	currentDistance: number,
-	dodgeDirection: {x: number; y: number} | null,
-	tick: number,
-	strafeCyclePeriod: number,
-	strafeIntensity: number,
-	approachSpeed: 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;
-
-	const strafeClockwise = {
-		x: -deltaY / normalizedDistance,
-		y: deltaX / normalizedDistance,
-	};
-	const strafeCounterClockwise = {
-		x: deltaY / normalizedDistance,
-		y: -deltaX / normalizedDistance,
-	};
-
-	let strafeDirection: {x: number; y: number};
-
-	if (dodgeDirection) 
-	{
-		strafeDirection = dodgeDirection;
-	}
-	else if (
-		position.x < WALL_BUFFER ||
-    position.x > ARENA_SIZE - WALL_BUFFER ||
-    position.y < WALL_BUFFER ||
-    position.y > ARENA_SIZE - WALL_BUFFER
-	) 
-	{
-		const futureClockwise = {
-			x: position.x + strafeClockwise.x * 100,
-			y: position.y + strafeClockwise.y * 100,
-		};
-		const futureCounterClockwise = {
-			x: position.x + strafeCounterClockwise.x * 100,
-			y: position.y + strafeCounterClockwise.y * 100,
-		};
-		const scoreClockwise = Math.min(
-			futureClockwise.x,
-			ARENA_SIZE - futureClockwise.x,
-			futureClockwise.y,
-			ARENA_SIZE - futureClockwise.y,
-		);
-		const scoreCounterClockwise = Math.min(
-			futureCounterClockwise.x,
-			ARENA_SIZE - futureCounterClockwise.x,
-			futureCounterClockwise.y,
-			ARENA_SIZE - futureCounterClockwise.y,
-		);
-		strafeDirection =
-			scoreClockwise > scoreCounterClockwise
-				? strafeClockwise
-				: strafeCounterClockwise;
-	}
-	else 
-	{
-		const cycle = Math.floor(tick / strafeCyclePeriod) % 2;
-		strafeDirection = cycle === 0 ? strafeClockwise : strafeCounterClockwise;
-	}
-
-	// When actively dodging, commit fully
-	if (dodgeDirection) 
-	{
-		return {x: strafeDirection.x * 100, y: strafeDirection.y * 100};
-	}
-
-	// Light strafe + aggressive closing
-	let moveX = strafeDirection.x * strafeIntensity;
-	let moveY = strafeDirection.y * strafeIntensity;
-
-	// Always close distance aggressively (melee wants to be in the enemy's face)
-	moveX += (deltaX / normalizedDistance) * approachSpeed;
-	moveY += (deltaY / normalizedDistance) * approachSpeed;
-
-	const magnitude = Math.sqrt(moveX * moveX + moveY * moveY);
-	if (magnitude > 100) 
-	{
-		moveX = (moveX / magnitude) * 100;
-		moveY = (moveY / magnitude) * 100;
-	}
-
-	return {x: moveX, y: moveY};
-}
-
-/**
- * Bot: Shadowblade
- *
- * BEHAVIOR: Melee assassin. Blinks to the enemy, then lands devastating point-blank
- * stab attacks (15 damage, 30u range, ~60 tick cast = 2-hit kill). Runs directly
- * at the enemy with minimal strafe, shields undodgeable threats. The entire
- * strategy is: get close, stab, kill. Simple and brutal.
- *
- * PROGRESSION LINE: Shadowblade → Nightblade → Voidblade
- * - Shadowblade (tier 1): Offensive blink, melee stabs, basic shield
- * - Nightblade (tier 2): + missile-aware blinks, adaptive stabs, timed defense
- * - Voidblade (tier 3): Future — perfect assassination timing, inescapable engages
- *
- * TIER: 1 (base)
- */
-export const Shadowblade: WizardFunction = ({state}) => 
-{
-	const stabRange = useParam('stabRange', 76, {
-		range: 30,
-		min: 20,
-		max: 80,
-		steps: 5,
-	});
-	const strafeCyclePeriod = useParam('strafeCyclePeriod', 252, {
-		range: 75,
-		min: 80,
-		max: 300,
-	});
-	const strafeIntensity = useParam('strafeIntensity', 55, {
-		range: 30,
-		min: 10,
-		max: 80,
-		steps: 7,
-	});
-	const approachSpeed = useParam('approachSpeed', 61, {
-		range: 20,
-		min: 50,
-		max: 100,
-		steps: 7,
-	});
-	const shieldCancelThreshold = useParam('shieldCancelThreshold', 150, {
-		range: 75,
-		min: 50,
-		max: 300,
-	});
-	const blinkWindowMax = useParam('blinkWindowMax', 23, {
-		range: 30,
-		min: 15,
-		max: 80,
-		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);
-
-	// Cancel shield if no longer needed
-	if (state.state === 'channeling') 
-	{
-		if (!urgentThreat || urgentThreat.ticksToImpact > shieldCancelThreshold) 
-		{
-			return {move: {x: 0, y: 0}, cancel: true};
-		}
-		return {move: {x: 0, y: 0}};
-	}
-
-	if (state.state === 'idle') 
-	{
-		// === BLINK: Dodge missile + close gap simultaneously (first priority) ===
-		// Wait until the missile is close (<=40 ticks) so the blink actually dodges it.
-		// Blinking too early means the missile can still re-track. Too late (<10) and the
-		// blink cast won't complete in time.
-		if (
-			urgentThreat &&
-      state.blinkCooldown === 0 &&
-      distance > stabRange &&
-      urgentThreat.ticksToImpact >= 10 &&
-      urgentThreat.ticksToImpact <= blinkWindowMax
-		) 
-		{
-			const blinkTarget =
-				getBlinkToDecreaseDistance(
-					state.position,
-					enemy.position,
-					state.projectiles,
-				) ?? enemy.position;
-			return {
-				move: {x: 0, y: 0},
-				startCast: {spell: 'blink', target: blinkTarget},
-			};
-		}
-
-		// Pre-stab shield: already at melee range, survival beats landing another stab.
-		// Gated to stab range so out-of-range threats wait for the blink window.
-		if (
-			urgentThreat &&
-      distance < stabRange &&
-      (!urgentThreat.bestDodgeDirection || shouldForceShield(urgentThreat)) &&
-      urgentThreat.canBlockInTime &&
-      urgentThreat.ticksToStartShield <= 3
-		)
-		{
-			return {
-				move: {x: 0, y: 0},
-				startCast: {spell: 'shield'},
-			};
-		}
-
-		// Melee stab when close enough (offense over defense at melee range)
-		if (distance < stabRange)
-		{
-			return {
-				move: {x: 0, y: 0},
-				startCast: {
-					spell: 'missile',
-					config: STAB_CONFIG,
-					missileAI: () => ({}), // Non-homing, point blank
-				},
-			};
-		}
-
-		// === DEFENSE: Shield undodgeable threats (only when blink can't handle it) ===
-		// Don't shield if blink is available — wait for the blink window instead.
-		if (
-			urgentThreat &&
-      (!urgentThreat.bestDodgeDirection || shouldForceShield(urgentThreat)) &&
-      urgentThreat.canBlockInTime &&
-      urgentThreat.ticksToStartShield <= 3 &&
-      (state.blinkCooldown > 0 || urgentThreat.ticksToImpact < 10)
-		)
-		{
-			return {
-				move: {x: 0, y: 0},
-				startCast: {spell: 'shield'},
-			};
-		}
-	}
-
-	// Aggressive movement — always close distance
-	const dodgeDirection = getDodgeDirectionForMovement(threats, state.position);
-	const move = aggressiveMove(
-		state.position,
-		enemy,
-		distance,
-		dodgeDirection,
-		state.tick,
-		strafeCyclePeriod,
-		strafeIntensity,
-		approachSpeed,
-	);
-	return {move};
-};
+import {WizardFunction} from '../../types.js';
+import {distanceTo} from '../../utils/distance.js';
+import {ARENA_SIZE} from '../../rules.js';
+import {
+	getThreats,
+	getMostUrgentThreat,
+	getDodgeDirectionForMovement,
+	getBlinkToDecreaseDistance,
+	shouldForceShield,
+} from '../shared.js';
+import {useParam} from '../../engine/params-runtime.js';
+const WALL_BUFFER = 50;
+
+// Melee stab: 20 damage, speed 8, 3-hit kill.
+const STAB_CONFIG = {damage: 20, speed: 8, turnRate: 0, duration: 10};
+
+/**
+ * Aggressive movement: dodge missiles using threat analysis, close distance, light strafe.
+ */
+function aggressiveMove(
+	position: {x: number; y: number},
+	enemy: {position: {x: number; y: number}},
+	currentDistance: number,
+	dodgeDirection: {x: number; y: number} | null,
+	tick: number,
+	strafeCyclePeriod: number,
+	strafeIntensity: number,
+	approachSpeed: 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;
+
+	const strafeClockwise = {
+		x: -deltaY / normalizedDistance,
+		y: deltaX / normalizedDistance,
+	};
+	const strafeCounterClockwise = {
+		x: deltaY / normalizedDistance,
+		y: -deltaX / normalizedDistance,
+	};
+
+	let strafeDirection: {x: number; y: number};
+
+	if (dodgeDirection) 
+	{
+		strafeDirection = dodgeDirection;
+	}
+	else if (
+		position.x < WALL_BUFFER ||
+    position.x > ARENA_SIZE - WALL_BUFFER ||
+    position.y < WALL_BUFFER ||
+    position.y > ARENA_SIZE - WALL_BUFFER
+	) 
+	{
+		const futureClockwise = {
+			x: position.x + strafeClockwise.x * 100,
+			y: position.y + strafeClockwise.y * 100,
+		};
+		const futureCounterClockwise = {
+			x: position.x + strafeCounterClockwise.x * 100,
+			y: position.y + strafeCounterClockwise.y * 100,
+		};
+		const scoreClockwise = Math.min(
+			futureClockwise.x,
+			ARENA_SIZE - futureClockwise.x,
+			futureClockwise.y,
+			ARENA_SIZE - futureClockwise.y,
+		);
+		const scoreCounterClockwise = Math.min(
+			futureCounterClockwise.x,
+			ARENA_SIZE - futureCounterClockwise.x,
+			futureCounterClockwise.y,
+			ARENA_SIZE - futureCounterClockwise.y,
+		);
+		strafeDirection =
+			scoreClockwise > scoreCounterClockwise
+				? strafeClockwise
+				: strafeCounterClockwise;
+	}
+	else 
+	{
+		const cycle = Math.floor(tick / strafeCyclePeriod) % 2;
+		strafeDirection = cycle === 0 ? strafeClockwise : strafeCounterClockwise;
+	}
+
+	// When actively dodging, commit fully
+	if (dodgeDirection) 
+	{
+		return {x: strafeDirection.x * 100, y: strafeDirection.y * 100};
+	}
+
+	// Light strafe + aggressive closing
+	let moveX = strafeDirection.x * strafeIntensity;
+	let moveY = strafeDirection.y * strafeIntensity;
+
+	// Always close distance aggressively (melee wants to be in the enemy's face)
+	moveX += (deltaX / normalizedDistance) * approachSpeed;
+	moveY += (deltaY / normalizedDistance) * approachSpeed;
+
+	const magnitude = Math.sqrt(moveX * moveX + moveY * moveY);
+	if (magnitude > 100) 
+	{
+		moveX = (moveX / magnitude) * 100;
+		moveY = (moveY / magnitude) * 100;
+	}
+
+	return {x: moveX, y: moveY};
+}
+
+/**
+ * Bot: Shadowblade
+ *
+ * BEHAVIOR: Melee assassin. Blinks to the enemy, then lands devastating point-blank
+ * stab attacks (15 damage, 30u range, ~60 tick cast = 2-hit kill). Runs directly
+ * at the enemy with minimal strafe, shields undodgeable threats. The entire
+ * strategy is: get close, stab, kill. Simple and brutal.
+ *
+ * PROGRESSION LINE: Shadowblade → Nightblade → Voidblade
+ * - Shadowblade (tier 1): Offensive blink, melee stabs, basic shield
+ * - Nightblade (tier 2): + missile-aware blinks, adaptive stabs, timed defense
+ * - Voidblade (tier 3): Future — perfect assassination timing, inescapable engages
+ *
+ * TIER: 1 (base)
+ */
+export const Shadowblade: WizardFunction = ({state}) => 
+{
+	const stabRange = useParam('stabRange', 76, {
+		range: 30,
+		min: 20,
+		max: 80,
+		steps: 5,
+	});
+	const strafeCyclePeriod = useParam('strafeCyclePeriod', 252, {
+		range: 75,
+		min: 80,
+		max: 300,
+	});
+	const strafeIntensity = useParam('strafeIntensity', 55, {
+		range: 30,
+		min: 10,
+		max: 80,
+		steps: 7,
+	});
+	const approachSpeed = useParam('approachSpeed', 61, {
+		range: 20,
+		min: 50,
+		max: 100,
+		steps: 7,
+	});
+	const shieldCancelThreshold = useParam('shieldCancelThreshold', 150, {
+		range: 75,
+		min: 50,
+		max: 300,
+	});
+	const blinkWindowMax = useParam('blinkWindowMax', 23, {
+		range: 30,
+		min: 15,
+		max: 80,
+		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);
+
+	// Cancel shield if no longer needed
+	if (state.state === 'channeling') 
+	{
+		if (!urgentThreat || urgentThreat.ticksToImpact > shieldCancelThreshold) 
+		{
+			return {move: {x: 0, y: 0}, cancel: true};
+		}
+		return {move: {x: 0, y: 0}};
+	}
+
+	if (state.state === 'idle') 
+	{
+		// === BLINK: Dodge missile + close gap simultaneously (first priority) ===
+		// Wait until the missile is close (<=40 ticks) so the blink actually dodges it.
+		// Blinking too early means the missile can still re-track. Too late (<10) and the
+		// blink cast won't complete in time.
+		if (
+			urgentThreat &&
+      state.blinkCooldown === 0 &&
+      distance > stabRange &&
+      urgentThreat.ticksToImpact >= 10 &&
+      urgentThreat.ticksToImpact <= blinkWindowMax
+		) 
+		{
+			const blinkTarget =
+				getBlinkToDecreaseDistance(
+					state.position,
+					enemy.position,
+					state.projectiles,
+				) ?? enemy.position;
+			return {
+				move: {x: 0, y: 0},
+				startCast: {spell: 'blink', target: blinkTarget},
+			};
+		}
+
+		// Pre-stab shield: already at melee range, survival beats landing another stab.
+		// Gated to stab range so out-of-range threats wait for the blink window.
+		if (
+			urgentThreat &&
+      distance < stabRange &&
+      (!urgentThreat.bestDodgeDirection || shouldForceShield(urgentThreat)) &&
+      urgentThreat.canBlockInTime &&
+      urgentThreat.ticksToStartShield <= 3
+		)
+		{
+			return {
+				move: {x: 0, y: 0},
+				startCast: {spell: 'shield'},
+			};
+		}
+
+		// Melee stab when close enough (offense over defense at melee range)
+		if (distance < stabRange)
+		{
+			return {
+				move: {x: 0, y: 0},
+				startCast: {
+					spell: 'missile',
+					config: STAB_CONFIG,
+					missileAI: () => ({}), // Non-homing, point blank
+				},
+			};
+		}
+
+		// === DEFENSE: Shield undodgeable threats (only when blink can't handle it) ===
+		// Don't shield if blink is available — wait for the blink window instead.
+		if (
+			urgentThreat &&
+      (!urgentThreat.bestDodgeDirection || shouldForceShield(urgentThreat)) &&
+      urgentThreat.canBlockInTime &&
+      urgentThreat.ticksToStartShield <= 3 &&
+      (state.blinkCooldown > 0 || urgentThreat.ticksToImpact < 10)
+		)
+		{
+			return {
+				move: {x: 0, y: 0},
+				startCast: {spell: 'shield'},
+			};
+		}
+	}
+
+	// Aggressive movement — always close distance
+	const dodgeDirection = getDodgeDirectionForMovement(threats, state.position);
+	const move = aggressiveMove(
+		state.position,
+		enemy,
+		distance,
+		dodgeDirection,
+		state.tick,
+		strafeCyclePeriod,
+		strafeIntensity,
+		approachSpeed,
+	);
+	return {move};
+};