@vibemancer/core 0.1.0 → 0.1.2

package/src/bots/standalone/Critter.ts

@@ -1,89 +1,89 @@
-import {WizardFunction} from '../../types.js';
-import {ARENA_WIDTH, ARENA_HEIGHT} from '../../rules.js';
-
-/**
- * Bot: Critter
- *
- * BEHAVIOR: Picks random valid actions each tick — random movement, random spells,
- * random missile configs, random directions. Occasionally cancels its own casts.
- * Uses engine-provided seeded random for deterministic behavior. Useful for
- * finding edge cases in the engine, but completely useless in combat.
- *
- * NAMING RATIONALE: In WoW, critters are the 1-HP ambient mobs (rabbits, squirrels,
- * prairie dogs) that wander around doing nothing useful and die to literally anything.
- * This bot is the wizard equivalent — it flails around randomly and gets destroyed by
- * anyone with a plan. The word "Critter" immediately tells any gamer "this thing is
- * helpless and exists only to fill space."
- *
- * STANDALONE — no tier progression. Critters don't level up. However, a future
- * "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}) => 
-{
-	// 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
-	};
-
-	if (state.state === 'idle' && random() > 0.95) 
-	{
-		const spellRoll = random();
-		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,
-				},
-			};
-		}
-		else if (spellRoll > 0.3) 
-		{
-			return {
-				move,
-				startCast: {spell: 'shield'},
-			};
-		}
-		else if (state.blinkCooldown === 0) 
-		{
-			return {
-				move,
-				startCast: {
-					spell: 'blink',
-					target: {x: random() * ARENA_WIDTH, y: random() * ARENA_HEIGHT},
-				},
-			};
-		}
-	}
-
-	if (
-		(state.state === 'casting' || state.state === 'channeling') &&
-    random() > 0.98
-	) 
-	{
-		return {move, cancel: true};
-	}
-
-	// Override auto-aim with random direction — Critter doesn't know where anything is
-	return {move, aimDirection: random() * 360};
-};
+import {WizardFunction} from '../../types.js';
+import {ARENA_WIDTH, ARENA_HEIGHT} from '../../rules.js';
+
+/**
+ * Bot: Critter
+ *
+ * BEHAVIOR: Picks random valid actions each tick — random movement, random spells,
+ * random missile configs, random directions. Occasionally cancels its own casts.
+ * Uses engine-provided seeded random for deterministic behavior. Useful for
+ * finding edge cases in the engine, but completely useless in combat.
+ *
+ * NAMING RATIONALE: In WoW, critters are the 1-HP ambient mobs (rabbits, squirrels,
+ * prairie dogs) that wander around doing nothing useful and die to literally anything.
+ * This bot is the wizard equivalent — it flails around randomly and gets destroyed by
+ * anyone with a plan. The word "Critter" immediately tells any gamer "this thing is
+ * helpless and exists only to fill space."
+ *
+ * STANDALONE — no tier progression. Critters don't level up. However, a future
+ * "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}) => 
+{
+	// 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
+	};
+
+	if (state.state === 'idle' && random() > 0.95) 
+	{
+		const spellRoll = random();
+		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,
+				},
+			};
+		}
+		else if (spellRoll > 0.3) 
+		{
+			return {
+				move,
+				startCast: {spell: 'shield'},
+			};
+		}
+		else if (state.blinkCooldown === 0) 
+		{
+			return {
+				move,
+				startCast: {
+					spell: 'blink',
+					target: {x: random() * ARENA_WIDTH, y: random() * ARENA_HEIGHT},
+				},
+			};
+		}
+	}
+
+	if (
+		(state.state === 'casting' || state.state === 'channeling') &&
+    random() > 0.98
+	) 
+	{
+		return {move, cancel: true};
+	}
+
+	// Override auto-aim with random direction — Critter doesn't know where anything is
+	return {move, aimDirection: random() * 360};
+};

package/src/bots/standalone/Doombringer.ts

@@ -1,91 +1,91 @@
-import {WizardFunction, MissileAIFunction} from '../../types.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 enemy = worldState.enemies[0];
-	return {turnToward: enemy?.position};
-};
-
-/**
- * Bot: Doombringer
- *
- * BEHAVIOR: Fires a single maximum-damage homing missile with infinite budget.
- * No damage cap — goes for the biggest possible hit. Exists as a benchmark to
- * demonstrate why lower-damage + shield play is superior. Has basic shield
- * defense but no sophisticated tactics. One fat cast, one fat hit.
- *
- * STANDALONE — no tier progression. Benchmark/test bot.
- */
-export const Doombringer: WizardFunction = ({state}) => 
-{
-	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);
-
-	// === DEFENSE: Handle channeling ===
-	if (state.state === 'channeling') 
-	{
-		if (!urgentThreat || urgentThreat.ticksToImpact > 150) 
-		{
-			return {move: {x: 0, y: 0}, cancel: true};
-		}
-		return {move: {x: 0, y: 0}};
-	}
-
-	// === DEFENSE: Shield undodgeable threats ===
-	if (
-		state.state === 'idle' &&
-    urgentThreat &&
-    !urgentThreat.bestDodgeDirection
-	) 
-	{
-		if (urgentThreat.canBlockInTime && urgentThreat.ticksToStartShield <= 3) 
-		{
-			return {
-				move: {x: 0, y: 0},
-				startCast: {spell: 'shield'},
-			};
-		}
-		else if (!urgentThreat.canBlockInTime && state.blinkCooldown === 0) 
-		{
-			return {
-				move: {x: 0, y: 0},
-				startCast: {spell: 'blink', target: getBlinkToCenter(state.position)},
-			};
-		}
-	}
-
-	// === OFFENSE: Fire max-damage homing missile (no damage cap) ===
-	if (state.state === 'idle') 
-	{
-		const config = fitMissileToBudget(Infinity, distance, {minTurnRate: 0.5});
-		if (config) 
-		{
-			return {
-				move: {x: 0, y: 0},
-				startCast: {
-					spell: 'missile',
-					config,
-					missileAI: HomingAI,
-					direction: angleTo(state.position, enemy.position),
-				},
-			};
-		}
-	}
-
-	return {move: {x: 0, y: 0}};
-};
+import {WizardFunction, MissileAIFunction} from '../../types.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 enemy = worldState.enemies[0];
+	return {turnToward: enemy?.position};
+};
+
+/**
+ * Bot: Doombringer
+ *
+ * BEHAVIOR: Fires a single maximum-damage homing missile with infinite budget.
+ * No damage cap — goes for the biggest possible hit. Exists as a benchmark to
+ * demonstrate why lower-damage + shield play is superior. Has basic shield
+ * defense but no sophisticated tactics. One fat cast, one fat hit.
+ *
+ * STANDALONE — no tier progression. Benchmark/test bot.
+ */
+export const Doombringer: WizardFunction = ({state}) => 
+{
+	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);
+
+	// === DEFENSE: Handle channeling ===
+	if (state.state === 'channeling') 
+	{
+		if (!urgentThreat || urgentThreat.ticksToImpact > 150) 
+		{
+			return {move: {x: 0, y: 0}, cancel: true};
+		}
+		return {move: {x: 0, y: 0}};
+	}
+
+	// === DEFENSE: Shield undodgeable threats ===
+	if (
+		state.state === 'idle' &&
+    urgentThreat &&
+    !urgentThreat.bestDodgeDirection
+	) 
+	{
+		if (urgentThreat.canBlockInTime && urgentThreat.ticksToStartShield <= 3) 
+		{
+			return {
+				move: {x: 0, y: 0},
+				startCast: {spell: 'shield'},
+			};
+		}
+		else if (!urgentThreat.canBlockInTime && state.blinkCooldown === 0) 
+		{
+			return {
+				move: {x: 0, y: 0},
+				startCast: {spell: 'blink', target: getBlinkToCenter(state.position)},
+			};
+		}
+	}
+
+	// === OFFENSE: Fire max-damage homing missile (no damage cap) ===
+	if (state.state === 'idle') 
+	{
+		const config = fitMissileToBudget(Infinity, distance, {minTurnRate: 0.5});
+		if (config) 
+		{
+			return {
+				move: {x: 0, y: 0},
+				startCast: {
+					spell: 'missile',
+					config,
+					missileAI: HomingAI,
+					direction: angleTo(state.position, enemy.position),
+				},
+			};
+		}
+	}
+
+	return {move: {x: 0, y: 0}};
+};