@vibemancer/core 0.1.0 → 0.1.1

package/src/bots/defensive/01_Turtle.ts

@@ -1,151 +1,151 @@
-import {WizardFunction} from '../../types.js';
-import {angleTo} from '../../utils/angles.js';
-import {GCD_DURATION, SHIELD_CAST_TIME} from '../../rules.js';
-import {getMissileCastTime} from '../../utils/combat.js';
-import {
-	getThreats,
-	getMostUrgentThreat,
-	getBlinkToCenter,
-} from '../shared.js';
-import {useParam} from '../../engine/params-runtime.js';
-
-/**
- * Bot: Turtle
- *
- * BEHAVIOR: Stationary tank with a simple defense-first loop: shield → missile
- * → wait → shield → repeat. Never moves. Always prioritizes having shield
- * ready over dealing damage.
- *
- * COMBAT LOOP:
- * 1. Incoming missile? → Shield immediately (cancel anything else)
- * 2. Hold shield until missile has actually impacted (don't cancel early!)
- * 3. Cancel shield → GCD → Fire one missile → GCD → idle
- * 4. Wait idle for next threat
- * 5. Goto 1
- *
- * CRITICAL: Does NOT cancel shield until incoming missiles have impacted.
- * Shield must be held through impact to actually block damage.
- *
- * Uses damage 10, speed 5, turnRate 1, duration 180 (~81 tick cast).
- * Emergency blinks toward center when caught in GCD with unavoidable hit.
- *
- * NAMING RATIONALE: "Turtling" is the universal gaming term for extreme
- * defensive play. Sits still and blocks everything.
- *
- * PROGRESSION LINE: Turtle → Sentinel → Golem
- * - Turtle (tier 1): Stationary, fixed missiles, always-shield-first
- * - Sentinel (tier 2): Stationary, adaptive missile fitting (fitMissileToBudget)
- * - Golem (tier 3): Future — immovable fortress, perfect timing, punishing hits
- *
- * TIER: 1 (base)
- */
-
-// Homing missile: damage 12, speed 5, turnRate 1, duration 180.
-// Range = 5 × 180 = 900 units.
-const MISSILE_CONFIG = {damage: 12, speed: 5, turnRate: 1, duration: 180};
-
-export const Turtle: WizardFunction = ({state}) => 
-{
-	const shieldBuffer = useParam('shieldBuffer', 3.1, {
-		range: 5,
-		min: 0,
-		steps: 5,
-	});
-	const shieldHoldTicks = useParam('shieldHoldTicks', 5, {
-		range: 5,
-		min: 0,
-		steps: 5,
-	});
-	const ticksToReshield = SHIELD_CAST_TIME + shieldBuffer;
-
-	const enemy = state.enemies[0];
-	if (!enemy) return {move: {x: 0, y: 0}};
-
-	const threats = getThreats(state);
-	const urgentThreat = getMostUrgentThreat(threats);
-
-	const shouldStartShield =
-		urgentThreat !== null &&
-    urgentThreat.ticksToImpact <= SHIELD_CAST_TIME + shieldBuffer;
-
-	// === CHANNELING SHIELD ===
-	// Hold shield until the imminent missile(s) have actually impacted.
-	if (state.state === 'channeling' && state.channelingSpell === 'shield') 
-	{
-		// Don't cancel while a missile is about to hit
-		const imminentThreat = threats.find(
-			(t) => t.willHit && t.ticksToImpact <= shieldHoldTicks,
-		);
-		if (imminentThreat) 
-		{
-			return {move: {x: 0, y: 0}};
-		}
-
-		// Safe to cancel if no next threat, or next threat is far enough to reshield
-		const nextThreat = threats.find((t) => t.willHit);
-		if (!nextThreat || nextThreat.ticksToImpact > ticksToReshield) 
-		{
-			return {move: {x: 0, y: 0}, cancel: true};
-		}
-		// Next threat too soon — keep channeling
-		return {move: {x: 0, y: 0}};
-	}
-
-	// === CASTING SHIELD: let it finish ===
-	if (state.state === 'casting' && state.castingSpell === 'shield') 
-	{
-		return {move: {x: 0, y: 0}};
-	}
-
-	// === NEED TO SHIELD NOW: cancel anything else ===
-	if (shouldStartShield) 
-	{
-		if (state.state === 'casting') 
-		{
-			return {move: {x: 0, y: 0}, cancel: true};
-		}
-		if (state.state === 'idle') 
-		{
-			return {move: {x: 0, y: 0}, startCast: {spell: 'shield'}};
-		}
-	}
-
-	// === EMERGENCY BLINK: missile too close for shield, blink available ===
-	if (
-		state.state === 'idle' &&
-    urgentThreat &&
-    urgentThreat.ticksToImpact < SHIELD_CAST_TIME + shieldBuffer &&
-    urgentThreat.ticksToImpact >= 10 &&
-    state.blinkCooldown === 0
-	) 
-	{
-		return {
-			move: {x: 0, y: 0},
-			startCast: {spell: 'blink', target: getBlinkToCenter(state.position)},
-		};
-	}
-
-	// === ATTACK: one missile if safe window exists ===
-	// Dynamic safe window: actual cast time (with warmup) + GCD + shield + buffer
-	const castTime = getMissileCastTime(MISSILE_CONFIG, state.lastMissileConfig);
-	const safeWindow = castTime + GCD_DURATION + SHIELD_CAST_TIME + shieldBuffer;
-	if (
-		state.state === 'idle' &&
-    (!urgentThreat || urgentThreat.ticksToImpact > safeWindow)
-	) 
-	{
-		return {
-			move: {x: 0, y: 0},
-			startCast: {
-				spell: 'missile',
-				config: MISSILE_CONFIG,
-				missileAI: ({worldState}) => ({
-					turnToward: worldState.enemies[0]?.position,
-				}),
-				direction: angleTo(state.position, enemy.position),
-			},
-		};
-	}
-
-	return {move: {x: 0, y: 0}};
-};
+import {WizardFunction} from '../../types.js';
+import {angleTo} from '../../utils/angles.js';
+import {GCD_DURATION, SHIELD_CAST_TIME} from '../../rules.js';
+import {getMissileCastTime} from '../../utils/combat.js';
+import {
+	getThreats,
+	getMostUrgentThreat,
+	getBlinkToCenter,
+} from '../shared.js';
+import {useParam} from '../../engine/params-runtime.js';
+
+/**
+ * Bot: Turtle
+ *
+ * BEHAVIOR: Stationary tank with a simple defense-first loop: shield → missile
+ * → wait → shield → repeat. Never moves. Always prioritizes having shield
+ * ready over dealing damage.
+ *
+ * COMBAT LOOP:
+ * 1. Incoming missile? → Shield immediately (cancel anything else)
+ * 2. Hold shield until missile has actually impacted (don't cancel early!)
+ * 3. Cancel shield → GCD → Fire one missile → GCD → idle
+ * 4. Wait idle for next threat
+ * 5. Goto 1
+ *
+ * CRITICAL: Does NOT cancel shield until incoming missiles have impacted.
+ * Shield must be held through impact to actually block damage.
+ *
+ * Uses damage 10, speed 5, turnRate 1, duration 180 (~81 tick cast).
+ * Emergency blinks toward center when caught in GCD with unavoidable hit.
+ *
+ * NAMING RATIONALE: "Turtling" is the universal gaming term for extreme
+ * defensive play. Sits still and blocks everything.
+ *
+ * PROGRESSION LINE: Turtle → Sentinel → Golem
+ * - Turtle (tier 1): Stationary, fixed missiles, always-shield-first
+ * - Sentinel (tier 2): Stationary, adaptive missile fitting (fitMissileToBudget)
+ * - Golem (tier 3): Future — immovable fortress, perfect timing, punishing hits
+ *
+ * TIER: 1 (base)
+ */
+
+// Homing missile: damage 12, speed 5, turnRate 1, duration 180.
+// Range = 5 × 180 = 900 units.
+const MISSILE_CONFIG = {damage: 12, speed: 5, turnRate: 1, duration: 180};
+
+export const Turtle: WizardFunction = ({state}) => 
+{
+	const shieldBuffer = useParam('shieldBuffer', 3.1, {
+		range: 5,
+		min: 0,
+		steps: 5,
+	});
+	const shieldHoldTicks = useParam('shieldHoldTicks', 5, {
+		range: 5,
+		min: 0,
+		steps: 5,
+	});
+	const ticksToReshield = SHIELD_CAST_TIME + shieldBuffer;
+
+	const enemy = state.enemies[0];
+	if (!enemy) return {move: {x: 0, y: 0}};
+
+	const threats = getThreats(state);
+	const urgentThreat = getMostUrgentThreat(threats);
+
+	const shouldStartShield =
+		urgentThreat !== null &&
+    urgentThreat.ticksToImpact <= SHIELD_CAST_TIME + shieldBuffer;
+
+	// === CHANNELING SHIELD ===
+	// Hold shield until the imminent missile(s) have actually impacted.
+	if (state.state === 'channeling' && state.channelingSpell === 'shield') 
+	{
+		// Don't cancel while a missile is about to hit
+		const imminentThreat = threats.find(
+			(t) => t.willHit && t.ticksToImpact <= shieldHoldTicks,
+		);
+		if (imminentThreat) 
+		{
+			return {move: {x: 0, y: 0}};
+		}
+
+		// Safe to cancel if no next threat, or next threat is far enough to reshield
+		const nextThreat = threats.find((t) => t.willHit);
+		if (!nextThreat || nextThreat.ticksToImpact > ticksToReshield) 
+		{
+			return {move: {x: 0, y: 0}, cancel: true};
+		}
+		// Next threat too soon — keep channeling
+		return {move: {x: 0, y: 0}};
+	}
+
+	// === CASTING SHIELD: let it finish ===
+	if (state.state === 'casting' && state.castingSpell === 'shield') 
+	{
+		return {move: {x: 0, y: 0}};
+	}
+
+	// === NEED TO SHIELD NOW: cancel anything else ===
+	if (shouldStartShield) 
+	{
+		if (state.state === 'casting') 
+		{
+			return {move: {x: 0, y: 0}, cancel: true};
+		}
+		if (state.state === 'idle') 
+		{
+			return {move: {x: 0, y: 0}, startCast: {spell: 'shield'}};
+		}
+	}
+
+	// === EMERGENCY BLINK: missile too close for shield, blink available ===
+	if (
+		state.state === 'idle' &&
+    urgentThreat &&
+    urgentThreat.ticksToImpact < SHIELD_CAST_TIME + shieldBuffer &&
+    urgentThreat.ticksToImpact >= 10 &&
+    state.blinkCooldown === 0
+	) 
+	{
+		return {
+			move: {x: 0, y: 0},
+			startCast: {spell: 'blink', target: getBlinkToCenter(state.position)},
+		};
+	}
+
+	// === ATTACK: one missile if safe window exists ===
+	// Dynamic safe window: actual cast time (with warmup) + GCD + shield + buffer
+	const castTime = getMissileCastTime(MISSILE_CONFIG, state.lastMissileConfig);
+	const safeWindow = castTime + GCD_DURATION + SHIELD_CAST_TIME + shieldBuffer;
+	if (
+		state.state === 'idle' &&
+    (!urgentThreat || urgentThreat.ticksToImpact > safeWindow)
+	) 
+	{
+		return {
+			move: {x: 0, y: 0},
+			startCast: {
+				spell: 'missile',
+				config: MISSILE_CONFIG,
+				missileAI: ({worldState}) => ({
+					turnToward: worldState.enemies[0]?.position,
+				}),
+				direction: angleTo(state.position, enemy.position),
+			},
+		};
+	}
+
+	return {move: {x: 0, y: 0}};
+};

package/src/bots/defensive/02_Sentinel.ts

@@ -1,134 +1,134 @@
-import {WizardFunction, MissileActions} from '../../types.js';
-import {angleTo} from '../../utils/angles.js';
-import {GCD_DURATION, SHIELD_CAST_TIME} from '../../rules.js';
-import {getMissileCastTime} from '../../utils/combat.js';
-import {
-	getThreats,
-	getMostUrgentThreat,
-	getBlinkToCenter,
-} from '../shared.js';
-import {useParam} from '../../engine/params-runtime.js';
-
-/**
- * Bot: Sentinel
- *
- * BEHAVIOR: Stationary tank with last-moment shielding AND two-tier offense.
- * Like Turtle, never moves and shields at the last moment. Unlike Turtle,
- * fires bigger missiles (damage 20) when the safe window is large enough,
- * falling back to Turtle's fast missile (damage 12) when pressed.
- *
- * PROGRESSION LINE: Turtle → Sentinel → Golem
- * - Turtle (tier 1): Stationary, fixed missiles, reactive shield timing
- * - Sentinel (tier 2): Stationary, two-tier offense (big + fast missiles)
- * - Golem (tier 3): Immovable fortress, perfect shield timing
- *
- * TIER: 2 (enhanced Turtle)
- */
-export const Sentinel: WizardFunction = ({state}) =>
-{
-	const shieldHoldTicks = useParam('shieldHoldTicks', 2, {
-		range: 5,
-		min: 0,
-		max: 15,
-		steps: 5,
-	});
-
-	const enemy = state.enemies[0];
-
-	const threats = getThreats(state);
-	const urgentThreat = getMostUrgentThreat(threats);
-
-	const SHIELD_BUFFER = 3;
-	const shouldStartShield =
-		urgentThreat !== null &&
-    urgentThreat.ticksToImpact <= SHIELD_CAST_TIME + SHIELD_BUFFER;
-
-	const TICKS_TO_RESHIELD = SHIELD_CAST_TIME + SHIELD_BUFFER;
-	const nextThreat = threats.filter((t) => t.willHit)[1] ?? null;
-	const safeToCancel =
-		!nextThreat || nextThreat.ticksToImpact > TICKS_TO_RESHIELD;
-
-	if (state.state === 'channeling' && state.channelingSpell === 'shield')
-	{
-		const imminentThreat = threats.find(
-			(t) => t.willHit && t.ticksToImpact <= shieldHoldTicks,
-		);
-		if (imminentThreat) return {move: {x: 0, y: 0}};
-		if (safeToCancel) return {move: {x: 0, y: 0}, cancel: true};
-		return {move: {x: 0, y: 0}};
-	}
-
-	if (state.state === 'casting' && state.castingSpell === 'shield')
-	{
-		return {move: {x: 0, y: 0}};
-	}
-
-	if (shouldStartShield)
-	{
-		if (state.state === 'casting') return {move: {x: 0, y: 0}, cancel: true};
-		if (state.state === 'idle')
-		{
-			return {move: {x: 0, y: 0}, startCast: {spell: 'shield'}};
-		}
-	}
-
-	if (
-		state.state === 'idle' &&
-    urgentThreat &&
-    urgentThreat.ticksToImpact < SHIELD_CAST_TIME + SHIELD_BUFFER &&
-    urgentThreat.ticksToImpact >= 10 &&
-    state.blinkCooldown === 0
-	)
-	{
-		return {
-			move: {x: 0, y: 0},
-			startCast: {spell: 'blink', target: getBlinkToCenter(state.position)},
-		};
-	}
-
-	// Two-tier offense: big missile when safe, fast missile otherwise.
-	// Same speed/turnRate/duration → no warmup switching penalty.
-	if (state.state === 'idle' && enemy)
-	{
-		const FAST_MISSILE = {damage: 12, speed: 5, turnRate: 1, duration: 180};
-		const BIG_MISSILE = {damage: 20, speed: 5, turnRate: 1, duration: 180};
-
-		const nextThreatTime = urgentThreat?.ticksToImpact ?? Infinity;
-
-		const bigCast = getMissileCastTime(BIG_MISSILE, state.lastMissileConfig);
-		const bigWindow = bigCast + GCD_DURATION + SHIELD_CAST_TIME + SHIELD_BUFFER;
-		if (!urgentThreat || nextThreatTime > bigWindow)
-		{
-			return {
-				move: {x: 0, y: 0},
-				startCast: {
-					spell: 'missile',
-					config: BIG_MISSILE,
-					missileAI: ({worldState}): MissileActions => ({
-						turnToward: worldState.enemies[0]?.position,
-					}),
-					direction: angleTo(state.position, enemy.position),
-				},
-			};
-		}
-
-		const fastCast = getMissileCastTime(FAST_MISSILE, state.lastMissileConfig);
-		const fastWindow = fastCast + GCD_DURATION + SHIELD_CAST_TIME + SHIELD_BUFFER;
-		if (!urgentThreat || nextThreatTime > fastWindow)
-		{
-			return {
-				move: {x: 0, y: 0},
-				startCast: {
-					spell: 'missile',
-					config: FAST_MISSILE,
-					missileAI: ({worldState}): MissileActions => ({
-						turnToward: worldState.enemies[0]?.position,
-					}),
-					direction: angleTo(state.position, enemy.position),
-				},
-			};
-		}
-	}
-
-	return {move: {x: 0, y: 0}};
-};
+import {WizardFunction, MissileActions} from '../../types.js';
+import {angleTo} from '../../utils/angles.js';
+import {GCD_DURATION, SHIELD_CAST_TIME} from '../../rules.js';
+import {getMissileCastTime} from '../../utils/combat.js';
+import {
+	getThreats,
+	getMostUrgentThreat,
+	getBlinkToCenter,
+} from '../shared.js';
+import {useParam} from '../../engine/params-runtime.js';
+
+/**
+ * Bot: Sentinel
+ *
+ * BEHAVIOR: Stationary tank with last-moment shielding AND two-tier offense.
+ * Like Turtle, never moves and shields at the last moment. Unlike Turtle,
+ * fires bigger missiles (damage 20) when the safe window is large enough,
+ * falling back to Turtle's fast missile (damage 12) when pressed.
+ *
+ * PROGRESSION LINE: Turtle → Sentinel → Golem
+ * - Turtle (tier 1): Stationary, fixed missiles, reactive shield timing
+ * - Sentinel (tier 2): Stationary, two-tier offense (big + fast missiles)
+ * - Golem (tier 3): Immovable fortress, perfect shield timing
+ *
+ * TIER: 2 (enhanced Turtle)
+ */
+export const Sentinel: WizardFunction = ({state}) =>
+{
+	const shieldHoldTicks = useParam('shieldHoldTicks', 2, {
+		range: 5,
+		min: 0,
+		max: 15,
+		steps: 5,
+	});
+
+	const enemy = state.enemies[0];
+
+	const threats = getThreats(state);
+	const urgentThreat = getMostUrgentThreat(threats);
+
+	const SHIELD_BUFFER = 3;
+	const shouldStartShield =
+		urgentThreat !== null &&
+    urgentThreat.ticksToImpact <= SHIELD_CAST_TIME + SHIELD_BUFFER;
+
+	const TICKS_TO_RESHIELD = SHIELD_CAST_TIME + SHIELD_BUFFER;
+	const nextThreat = threats.filter((t) => t.willHit)[1] ?? null;
+	const safeToCancel =
+		!nextThreat || nextThreat.ticksToImpact > TICKS_TO_RESHIELD;
+
+	if (state.state === 'channeling' && state.channelingSpell === 'shield')
+	{
+		const imminentThreat = threats.find(
+			(t) => t.willHit && t.ticksToImpact <= shieldHoldTicks,
+		);
+		if (imminentThreat) return {move: {x: 0, y: 0}};
+		if (safeToCancel) return {move: {x: 0, y: 0}, cancel: true};
+		return {move: {x: 0, y: 0}};
+	}
+
+	if (state.state === 'casting' && state.castingSpell === 'shield')
+	{
+		return {move: {x: 0, y: 0}};
+	}
+
+	if (shouldStartShield)
+	{
+		if (state.state === 'casting') return {move: {x: 0, y: 0}, cancel: true};
+		if (state.state === 'idle')
+		{
+			return {move: {x: 0, y: 0}, startCast: {spell: 'shield'}};
+		}
+	}
+
+	if (
+		state.state === 'idle' &&
+    urgentThreat &&
+    urgentThreat.ticksToImpact < SHIELD_CAST_TIME + SHIELD_BUFFER &&
+    urgentThreat.ticksToImpact >= 10 &&
+    state.blinkCooldown === 0
+	)
+	{
+		return {
+			move: {x: 0, y: 0},
+			startCast: {spell: 'blink', target: getBlinkToCenter(state.position)},
+		};
+	}
+
+	// Two-tier offense: big missile when safe, fast missile otherwise.
+	// Same speed/turnRate/duration → no warmup switching penalty.
+	if (state.state === 'idle' && enemy)
+	{
+		const FAST_MISSILE = {damage: 12, speed: 5, turnRate: 1, duration: 180};
+		const BIG_MISSILE = {damage: 20, speed: 5, turnRate: 1, duration: 180};
+
+		const nextThreatTime = urgentThreat?.ticksToImpact ?? Infinity;
+
+		const bigCast = getMissileCastTime(BIG_MISSILE, state.lastMissileConfig);
+		const bigWindow = bigCast + GCD_DURATION + SHIELD_CAST_TIME + SHIELD_BUFFER;
+		if (!urgentThreat || nextThreatTime > bigWindow)
+		{
+			return {
+				move: {x: 0, y: 0},
+				startCast: {
+					spell: 'missile',
+					config: BIG_MISSILE,
+					missileAI: ({worldState}): MissileActions => ({
+						turnToward: worldState.enemies[0]?.position,
+					}),
+					direction: angleTo(state.position, enemy.position),
+				},
+			};
+		}
+
+		const fastCast = getMissileCastTime(FAST_MISSILE, state.lastMissileConfig);
+		const fastWindow = fastCast + GCD_DURATION + SHIELD_CAST_TIME + SHIELD_BUFFER;
+		if (!urgentThreat || nextThreatTime > fastWindow)
+		{
+			return {
+				move: {x: 0, y: 0},
+				startCast: {
+					spell: 'missile',
+					config: FAST_MISSILE,
+					missileAI: ({worldState}): MissileActions => ({
+						turnToward: worldState.enemies[0]?.position,
+					}),
+					direction: angleTo(state.position, enemy.position),
+				},
+			};
+		}
+	}
+
+	return {move: {x: 0, y: 0}};
+};