@vibemancer/core 0.1.4 → 0.1.5

package/src/bots/standalone/Critter.ts

@@ -1,5 +1,7 @@
-import {WizardFunction} from '../../types.js';
-import {ARENA_WIDTH, ARENA_HEIGHT} from '../../rules.js';
+import type {FinalAction} from '../../hooks/index.js';
+import {useStatus, useBlinkCooldown, useRandom, usePosition, move as moveAction, missile, shield, blink, cancel, getMissileContext, turnToward, flyStraight} from '../../hooks/index.js';
+import {avoidLava} from '../shared.js';
+import {ARENA_MIN, ARENA_MAX} from '../../rules.js';
 
 /**
  * Bot: Critter
@@ -19,71 +21,63 @@ import {ARENA_WIDTH, ARENA_HEIGHT} from '../../rules.js';
  * "Hogger" bot could be an elite critter: same chaotic spirit but actually dangerous
  * (like the famous WoW elite that wipes unprepared lowbies).
  */
-export const Critter: WizardFunction = ({state, random}) => 
+export function Critter(): FinalAction
 {
-	// Use the engine-provided random function (seeded, isolated, deterministic)
-	// World-space movement: random x/y in [-100, 100] range
-	const move = {
-		x: random() * 200 - 100, // -100 to 100
-		y: random() * 200 - 100, // -100 to 100
-	};
+	const status = useStatus();
+	const blinkCooldown = useBlinkCooldown();
+	const random = useRandom();
+	const position = usePosition();
 
-	if (state.state === 'idle' && random() > 0.95) 
+	const rawMove = {x: random() * 2 - 1, y: random() * 2 - 1};
+	const safe = avoidLava(position, rawMove);
+	const mx = safe.x;
+	const my = safe.y;
+
+	if (status === 'idle' && random() > 0.95)
 	{
 		const spellRoll = random();
-		if (spellRoll > 0.6) 
+		if (spellRoll > 0.6)
 		{
-			return {
-				move,
-				startCast: {
-					spell: 'missile',
-					config: {
-						damage: Math.floor(random() * 20) + 5,
-						speed: random() * 5 + 2,
-						turnRate: random() * 3,
-						duration: Math.floor(random() * 200) + 100,
-					},
-					// Missile AI gets its own random from engine - use it for random targeting
-					missileAI: ({random: missileRandom}) => ({
-						turnToward:
-              missileRandom() > 0.5
-              	? {
-              		x: missileRandom() * ARENA_WIDTH,
-              		y: missileRandom() * ARENA_HEIGHT,
-              	}
-              	: undefined,
-					}),
-					direction: random() * 360,
+			return missile(
+				{
+					damage: Math.floor(random() * 20) + 5,
+					speed: random() * 5 + 2,
+					turnRate: random() * 3,
+					duration: Math.floor(random() * 200) + 100,
+				},
+				// Missile AI gets its own random from engine - use it for random targeting
+				() => 
+				{
+					const ctx = getMissileContext();
+					if (ctx.random() > 0.5)
+					{
+						return turnToward(ARENA_MIN + ctx.random() * (ARENA_MAX - ARENA_MIN), ARENA_MIN + ctx.random() * (ARENA_MAX - ARENA_MIN));
+					}
+					return flyStraight();
 				},
-			};
+				random() * 360,
+			).move(mx, my);
 		}
-		else if (spellRoll > 0.3) 
+		else if (spellRoll > 0.3)
 		{
-			return {
-				move,
-				startCast: {spell: 'shield'},
-			};
+			return shield().move(mx, my);
 		}
-		else if (state.blinkCooldown === 0) 
+		else if (blinkCooldown === 0)
 		{
-			return {
-				move,
-				startCast: {
-					spell: 'blink',
-					target: {x: random() * ARENA_WIDTH, y: random() * ARENA_HEIGHT},
-				},
-			};
+			const margin = 50;
+			return blink(ARENA_MIN + margin + random() * (ARENA_MAX - ARENA_MIN - margin * 2), ARENA_MIN + margin + random() * (ARENA_MAX - ARENA_MIN - margin * 2));
 		}
 	}
 
 	if (
-		(state.state === 'casting' || state.state === 'channeling') &&
+		(status === 'casting' || status === 'channeling') &&
     random() > 0.98
-	) 
+	)
 	{
-		return {move, cancel: true};
+		return cancel().move(mx, my);
 	}
 
-	// Override auto-aim with random direction — Critter doesn't know where anything is
-	return {move, aimDirection: random() * 360};
-};
+	// Critter doesn't know where anything is — just move randomly
+	// Note: aimDirection override is not supported by hooks API, so we just move randomly
+	return moveAction(mx, my);
+}

package/src/bots/standalone/Doombringer.ts

@@ -1,17 +1,18 @@
-import {WizardFunction, MissileAIFunction} from '../../types.js';
+import type {FinalAction, MissileFunction} from '../../hooks/index.js';
+import {usePosition, useEnemy, useStatus, useBlinkCooldown, useThreats, idle, missile, shield, blink, cancel, getMissileContext, turnToward, flyStraight} from '../../hooks/index.js';
 import {angleTo} from '../../utils/angles.js';
 import {distanceTo} from '../../utils/distance.js';
 import {fitMissileToBudget} from '../../utils/combat.js';
 import {
-	getThreats,
 	getMostUrgentThreat,
 	getBlinkToCenter,
 } from '../shared.js';
 
-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();
 };
 
 /**
@@ -24,68 +25,63 @@ const HomingAI: MissileAIFunction = ({worldState}) =>
  *
  * STANDALONE — no tier progression. Benchmark/test bot.
  */
-export const Doombringer: WizardFunction = ({state}) => 
+export function Doombringer(): FinalAction
 {
-	const enemy = state.enemies[0];
-	if (!enemy) 
+	const position = usePosition();
+	const enemy = useEnemy();
+	const status = useStatus();
+	const blinkCooldown = useBlinkCooldown();
+	const threats = useThreats();
+
+	if (enemy.health <= 0)
 	{
-		return {move: {x: 0, y: 0}};
+		return idle();
 	}
 
-	const distance = distanceTo(state.position, enemy.position);
-	const threats = getThreats(state);
+	const distance = distanceTo(position, enemy.position);
 	const urgentThreat = getMostUrgentThreat(threats);
 
 	// === DEFENSE: Handle channeling ===
-	if (state.state === 'channeling') 
+	if (status === 'channeling')
 	{
-		if (!urgentThreat || urgentThreat.ticksToImpact > 150) 
+		if (!urgentThreat || urgentThreat.ticksToImpact > 150)
 		{
-			return {move: {x: 0, y: 0}, cancel: true};
+			return cancel();
 		}
-		return {move: {x: 0, y: 0}};
+		return idle();
 	}
 
 	// === DEFENSE: Shield undodgeable threats ===
 	if (
-		state.state === 'idle' &&
+		status === 'idle' &&
     urgentThreat &&
     !urgentThreat.bestDodgeDirection
-	) 
+	)
 	{
-		if (urgentThreat.canBlockInTime && urgentThreat.ticksToStartShield <= 3) 
+		if (urgentThreat.canBlockInTime && urgentThreat.ticksToStartShield <= 3)
 		{
-			return {
-				move: {x: 0, y: 0},
-				startCast: {spell: 'shield'},
-			};
+			return shield();
 		}
-		else if (!urgentThreat.canBlockInTime && state.blinkCooldown === 0) 
+		else if (!urgentThreat.canBlockInTime && blinkCooldown === 0)
 		{
-			return {
-				move: {x: 0, y: 0},
-				startCast: {spell: 'blink', target: getBlinkToCenter(state.position)},
-			};
+			const t = getBlinkToCenter(position);
+			return blink(t.x, t.y);
 		}
 	}
 
 	// === OFFENSE: Fire max-damage homing missile (no damage cap) ===
-	if (state.state === 'idle') 
+	if (status === 'idle')
 	{
 		const config = fitMissileToBudget(Infinity, distance, {minTurnRate: 0.5});
-		if (config) 
+		if (config)
 		{
-			return {
-				move: {x: 0, y: 0},
-				startCast: {
-					spell: 'missile',
-					config,
-					missileAI: HomingAI,
-					direction: angleTo(state.position, enemy.position),
-				},
-			};
+			return missile(
+				config,
+				HomingAI,
+				angleTo(position, enemy.position),
+			).move(0, 0);
 		}
 	}
 
-	return {move: {x: 0, y: 0}};
-};
+	return idle();
+}

package/src/bots/standalone/Hogger.ts

@@ -1,28 +1,31 @@
-import {WizardFunction, MissileAIFunction} from '../../types.js';
-import {angleTo} from '../../utils/angles.js';
+import type {FinalAction, MissileFunction} from '../../hooks/index.js';
+import {usePosition, useEnemy, useStatus, useBlinkCooldown, useRandom, useThreats, idle, move as moveAction, missile, shield, blink, cancel, getMissileContext, turnToward, flyStraight} from '../../hooks/index.js';
 import {distanceTo} from '../../utils/distance.js';
-import {ARENA_SIZE} from '../../rules.js';
+import {angleTo} from '../../utils/angles.js';
+import {ARENA_MIN, ARENA_MAX} from '../../rules.js';
 import {
-	getThreats,
 	getMostUrgentThreat,
 	getDodgeDirectionForMovement,
 	getBlinkToCenter,
+	avoidLava,
 } from '../shared.js';
+import {useParam} from '../../engine/params-runtime.js';
 const WALL_BUFFER = 60;
-const WALL_PUSH = 30; // How hard to push away from walls
+const WALL_PUSH = 0.3; // How hard to push away from walls
 
 /**
  * Homing AI that sometimes forgets what it's doing.
  */
-const ChaoticHoming: MissileAIFunction = ({worldState, random}) => 
+const ChaoticHoming: MissileFunction = () =>
 {
-	const enemy = worldState.enemies[0];
+	const ctx = getMissileContext();
+	const enemy = ctx.worldState.enemies[0];
 	// 80% chance to actually track, 20% chance to just fly straight
-	if (random() < 0.8) 
+	if (ctx.random() < 0.8)
 	{
-		return {turnToward: enemy?.position};
+		return enemy ? turnToward(enemy.position.x, enemy.position.y) : flyStraight();
 	}
-	return {};
+	return flyStraight();
 };
 
 /**
@@ -45,140 +48,173 @@ const ChaoticHoming: MissileAIFunction = ({worldState, random}) =>
  *
  * STANDALONE — no tier progression. There's only one Hogger.
  */
-export const Hogger: WizardFunction = ({state, random}) => 
+export function Hogger(): FinalAction
 {
-	const enemy = state.enemies[0];
-	if (!enemy) 
+	const position = usePosition();
+	const enemy = useEnemy();
+	const status = useStatus();
+	const blinkCooldown = useBlinkCooldown();
+	const random = useRandom();
+	const threats = useThreats();
+
+
+	const centerBias = useParam('centerBias', 0.71, {
+		range: 0.4,
+		min: 0,
+		max: 0.8,
+		steps: 5,
+	});
+	const maxBlinkDistance = useParam('maxBlinkDistance', 224, {
+		range: 100,
+		min: 50,
+		max: 300,
+		steps: 7,
+	});
+
+	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);
+	if (enemy.health <= 0)
+	{
+		return idle();
+	}
+
+	const distance = distanceTo(position, enemy.position);
 	const urgentThreat = getMostUrgentThreat(threats);
 
 	// Erratic movement: mostly toward/away from enemy with random strafe
-	const deltaX = enemy.position.x - state.position.x;
-	const deltaY = enemy.position.y - state.position.y;
+	const deltaX = enemy.position.x - position.x;
+	const deltaY = enemy.position.y - position.y;
 	const normalizedDistance = distance > 0 ? distance : 1;
 
 	// Dodge if there's a real threat
-	const dodgeDirection = getDodgeDirectionForMovement(threats, state.position);
+	const dodgeDirection = getDodgeDirectionForMovement(threats, position);
 
 	let moveX: number;
 	let moveY: number;
 
-	if (dodgeDirection) 
+	if (dodgeDirection)
 	{
 		// Actually dodge (Hogger isn't stupid)
-		moveX = dodgeDirection.x * 100;
-		moveY = dodgeDirection.y * 100;
+		moveX = dodgeDirection.x;
+		moveY = dodgeDirection.y;
 	}
-	else 
+	else
 	{
 		// Random strafe component
 		const perpX = -deltaY / normalizedDistance;
 		const perpY = deltaX / normalizedDistance;
-		const strafeIntensity = random() * 80 - 40; // -40 to 40
+		const strafeIntensity = random() * 0.8 - 0.4; // -0.4 to 0.4
 
 		// Approach/retreat: prefer medium range (250-400), but sometimes just wander
-		let approachIntensity = 0;
-		if (distance > 400) 
+		let approachIntensity: number;
+		if (distance > 400)
 		{
-			approachIntensity = 40 + random() * 30; // approach
+			approachIntensity = 0.4 + random() * 0.3; // approach
 		}
-		else if (distance < 200) 
+		else if (distance < 200)
 		{
-			approachIntensity = -(30 + random() * 30); // retreat
+			approachIntensity = -(0.3 + random() * 0.3); // retreat
 		}
-		else 
+		else
 		{
-			approachIntensity = random() * 60 - 30; // random walk
+			approachIntensity = random() * 0.6 - 0.3; // random walk
 		}
 
+		// Approach the center-side of the enemy so knockback pushes toward center, not lava.
+		let approachX = deltaX / normalizedDistance;
+		let approachY = deltaY / normalizedDistance;
+		if (approachIntensity > 0)
+		{
+			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 adX = approachX + (toCenterX / toCenterDist) * centerBias;
+			const adY = approachY + (toCenterY / toCenterDist) * centerBias;
+			const adMag = Math.sqrt(adX * adX + adY * adY) || 1;
+			approachX = adX / adMag;
+			approachY = adY / adMag;
+		}
 		moveX =
 			perpX * strafeIntensity +
-      (deltaX / normalizedDistance) * approachIntensity;
+      approachX * approachIntensity;
 		moveY =
 			perpY * strafeIntensity +
-      (deltaY / normalizedDistance) * approachIntensity;
+      approachY * approachIntensity;
 
 		// Wall avoidance (Hogger doesn't like corners)
-		if (state.position.x < WALL_BUFFER) moveX += WALL_PUSH;
-		if (state.position.x > ARENA_SIZE - WALL_BUFFER) moveX -= WALL_PUSH;
-		if (state.position.y < WALL_BUFFER) moveY += WALL_PUSH;
-		if (state.position.y > ARENA_SIZE - WALL_BUFFER) moveY -= WALL_PUSH;
+		if (position.x < ARENA_MIN + WALL_BUFFER) moveX += WALL_PUSH;
+		if (position.x > ARENA_MAX - WALL_BUFFER) moveX -= WALL_PUSH;
+		if (position.y < ARENA_MIN + WALL_BUFFER) moveY += WALL_PUSH;
+		if (position.y > ARENA_MAX - WALL_BUFFER) moveY -= WALL_PUSH;
 	}
 
 	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;
 	}
 
 	const move = {x: moveX, y: moveY};
+	const safeMove = avoidLava(position, move);
 
 	// === DEFENSE: Shield if in real danger ===
-	if (state.state === 'channeling') 
+	if (status === 'channeling')
 	{
-		if (!urgentThreat || urgentThreat.ticksToImpact > 120) 
+		if (!urgentThreat || urgentThreat.ticksToImpact > 120)
 		{
-			return {move, cancel: true};
+			return cancel().move(safeMove.x, safeMove.y);
 		}
-		return {move: {x: 0, y: 0}};
+		return idle();
 	}
 
 	if (
-		state.state === 'idle' &&
+		status === 'idle' &&
     urgentThreat &&
     !urgentThreat.bestDodgeDirection
-	) 
+	)
 	{
-		if (urgentThreat.canBlockInTime && urgentThreat.ticksToStartShield <= 3) 
+		if (urgentThreat.canBlockInTime && urgentThreat.ticksToStartShield <= 3)
 		{
-			return {
-				move: {x: 0, y: 0},
-				startCast: {spell: 'shield'},
-			};
+			return shield();
 		}
-		else if (!urgentThreat.canBlockInTime && state.blinkCooldown === 0) 
+		else if (!urgentThreat.canBlockInTime && blinkCooldown === 0)
 		{
-			return {
-				move: {x: 0, y: 0},
-				startCast: {spell: 'blink', target: getBlinkToCenter(state.position)},
-			};
+			const blinkTarget = capBlinkDistance(getBlinkToCenter(position));
+			return blink(blinkTarget.x, blinkTarget.y);
 		}
 	}
 
 	// === OFFENSE: Random blink (sometimes offensive, sometimes random) ===
-	if (state.state === 'idle' && state.blinkCooldown === 0 && random() < 0.03) 
+	if (status === 'idle' && blinkCooldown === 0 && random() < 0.03)
 	{
 		// 60% chance blink toward enemy, 40% chance random blink
-		if (random() < 0.6 && distance > 300) 
+		if (random() < 0.6 && distance > 300)
 		{
-			return {
-				move: {x: 0, y: 0},
-				startCast: {spell: 'blink', target: enemy.position},
-			};
+			const capped = capBlinkDistance(enemy.position);
+			return blink(capped.x, capped.y);
 		}
-		else 
+		else
 		{
-			return {
-				move: {x: 0, y: 0},
-				startCast: {
-					spell: 'blink',
-					target: {
-						x: 100 + random() * 600,
-						y: 100 + random() * 600,
-					},
-				},
-			};
+			const capped = capBlinkDistance({
+				x: 100 + random() * 600,
+				y: 100 + random() * 600,
+			});
+			return blink(capped.x, capped.y);
 		}
 	}
 
 	// === OFFENSE: Chaotic missiles ===
-	if (state.state === 'idle' && distance < 500) 
+	if (status === 'idle' && distance < 500)
 	{
 		// Random missile config each time
 		const roll = random();
@@ -187,7 +223,7 @@ export const Hogger: WizardFunction = ({state, random}) =>
 		let turnRate: number;
 		let duration: number;
 
-		if (roll < 0.3) 
+		if (roll < 0.3)
 		{
 			// Fast snipe
 			damage = 8 + Math.floor(random() * 5); // 8-12
@@ -195,7 +231,7 @@ export const Hogger: WizardFunction = ({state, random}) =>
 			turnRate = 0;
 			duration = 80 + Math.floor(random() * 40); // 80-120
 		}
-		else if (roll < 0.7) 
+		else if (roll < 0.7)
 		{
 			// Homing tracker
 			damage = 7 + Math.floor(random() * 5); // 7-11
@@ -203,7 +239,7 @@ export const Hogger: WizardFunction = ({state, random}) =>
 			turnRate = 1 + random() * 2; // 1-3
 			duration = 150 + Math.floor(random() * 100); // 150-250
 		}
-		else 
+		else
 		{
 			// Big slow bomb
 			damage = 12 + Math.floor(random() * 4); // 12-15
@@ -212,17 +248,12 @@ export const Hogger: WizardFunction = ({state, random}) =>
 			duration = 200 + Math.floor(random() * 100); // 200-300
 		}
 
-		return {
-			move,
-			startCast: {
-				spell: 'missile',
-				config: {damage, speed, turnRate, duration},
-				missileAI: ChaoticHoming,
-				direction:
-          angleTo(state.position, enemy.position) + (random() * 20 - 10), // ±10° aim wobble
-			},
-		};
+		return missile(
+			{damage, speed, turnRate, duration},
+			ChaoticHoming,
+			angleTo(position, enemy.position) + (random() * 20 - 10), // ±10° aim wobble
+		).move(safeMove.x, safeMove.y);
 	}
 
-	return {move};
-};
+	return moveAction(safeMove.x, safeMove.y);
+}

package/src/bots/standalone/Rookie.ts

@@ -1,4 +1,5 @@
-import {WizardFunction} from '../../types.js';
+import type {FinalAction} from '../../hooks/index.js';
+import {usePosition, useEnemy, useStatus, idle, missile, flyStraight} from '../../hooks/index.js';
 import {angleTo} from '../../utils/angles.js';
 
 /**
@@ -18,33 +19,30 @@ import {angleTo} from '../../utils/angles.js';
  * STANDALONE — no tier progression. Rookies either learn to play a real class
  * or quit. This bot represents the rock-bottom of "at least it shoots."
  */
-export const Rookie: WizardFunction = ({state}) => 
+export function Rookie(): FinalAction
 {
-	const enemy = state.enemies[0];
-	if (!enemy) 
+	const position = usePosition();
+	const enemy = useEnemy();
+	const status = useStatus();
+
+	if (enemy.health <= 0)
 	{
-		return {move: {x: 0, y: 0}};
+		return idle();
 	}
 
-	if (state.state === 'idle') 
+	if (status === 'idle')
 	{
-		return {
-			move: {x: 0, y: 0},
-			startCast: {
-				spell: 'missile',
-				config: {
-					damage: 10,
-					speed: 5,
-					turnRate: 0,
-					duration: 200,
-				},
-				missileAI: () => ({}),
-				direction: angleTo(state.position, enemy.position),
+		return missile(
+			{
+				damage: 10,
+				speed: 5,
+				turnRate: 0,
+				duration: 200,
 			},
-		};
+			() => flyStraight(),
+			angleTo(position, enemy.position),
+		).move(0, 0);
 	}
 
-	return {
-		move: {x: 0, y: 0},
-	};
-};
+	return idle();
+}

package/src/bots/standalone/TargetDummy.ts

@@ -1,4 +1,5 @@
-import {WizardFunction} from '../../types.js';
+import type {FinalAction} from '../../hooks/index.js';
+import {idle} from '../../hooks/index.js';
 
 /**
  * Bot: TargetDummy
@@ -13,9 +14,7 @@ import {WizardFunction} from '../../types.js';
  *
  * STANDALONE — no tier progression. It's a test fixture, not a combatant.
  */
-export const TargetDummy: WizardFunction = (_props) =>
+export function TargetDummy(): FinalAction
 {
-	return {
-		move: {x: 0, y: 0},
-	};
-};
+	return idle();
+}