@vibemancer/core 0.1.4 → 0.1.6

package/src/bots/registry.ts

@@ -20,12 +20,15 @@
  * | Berserker  | Stormchaser    | Stormcaller       | Stormforger     |
  * | Kiter      | Spellspinner   | Spellweaver       | Spellbinder     |
  *
- * Standalone: TargetDummy, Critter, Hogger, Rookie, Doombringer
+ * Standalone: TargetDummy, Critter, Hogger, Rookie, Doombringer, Hero
+ *   (Hero is the adaptive SHOWCASE — the #1 reference bot users build their own to beat.
+ *    Deliberately kept as a single isolated bot, NOT a tier line: writing adaptive bots is
+ *    the game, so the roster ships one exemplar and players make the rest.)
  * Reserved: Spellslinger (future volume-of-fire archetype)
  *
  */
 
-import {WizardFunction} from '../types.js';
+import type {WizardFunction} from '../hooks/types.js';
 import {TargetDummy} from './standalone/TargetDummy.js';
 import {Critter} from './standalone/Critter.js';
 import {Rookie} from './standalone/Rookie.js';
@@ -55,8 +58,9 @@ import {Stormforger} from './berserker/03_Stormforger.js';
 import {Spellspinner} from './kiter/01_Spellspinner.js';
 import {Spellweaver} from './kiter/02_Spellweaver.js';
 import {Spellbinder} from './kiter/03_Spellbinder.js';
+import {Hero} from './Hero.js';
 
-export interface BotEntry
+export interface WizardEntry
 {
 	name: string;
 	ai: WizardFunction;
@@ -65,17 +69,17 @@ export interface BotEntry
 	group: string; // progression line name or 'Standalone'
 }
 
-export interface BotGroup
+export interface WizardGroup
 {
 	label: string;
-	bots: BotEntry[];
+	bots: WizardEntry[];
 }
 
 /**
  * All bots organized by progression line.
  * Each group contains bots from the same archetype, ordered by tier.
  */
-export const BOT_GROUPS: BotGroup[] = [
+export const BOT_GROUPS: WizardGroup[] = [
 	{
 		label: 'Standalone',
 		bots: [
@@ -84,6 +88,7 @@ export const BOT_GROUPS: BotGroup[] = [
 			{name: 'Rookie', ai: Rookie, description: 'Basic homing missiles', group: 'Standalone'},
 			{name: 'Hogger', ai: Hogger, description: 'Chaotic elite — random but dangerous', group: 'Standalone'},
 			{name: 'Doombringer', ai: Doombringer, description: 'Single max-damage shot benchmark', group: 'Standalone'},
+			{name: 'Hero', ai: Hero, description: 'Adaptive SHOWCASE (#1 of 30, beats 28/29) — the reference bot players build their own to beat. Reads each opponent and counters: range/missile-style classification, hard-homing defense, finisher, plus signature-triggered modes — center-hold vs the max-damage shot, anti-sniper (shield-piercing + cadence yomi + range buffer), and reactive delegation that switches strategy when it detects it is being hard-countered, and a mirror-detector (holds distance vs a foe firing its own missile config) that makes the Archmage mirror an even matchup. Has NO losing matchup — beats 28 of 29 and draws its own mirror.', group: 'Standalone'},
 		],
 	},
 	{
@@ -153,7 +158,7 @@ export const BOT_GROUPS: BotGroup[] = [
 ];
 
 // Flat map for lookup by name
-const BOT_MAP = new Map<string, BotEntry>();
+const BOT_MAP = new Map<string, WizardEntry>();
 for (const group of BOT_GROUPS)
 {
 	for (const bot of group.bots)
@@ -168,38 +173,40 @@ for (const group of BOT_GROUPS)
  * To update: run `npm run tournament`
  */
 const ALL_BOTS_ORDER = [
-	'TargetDummy',   // #1  (1 pts,    0W)
-	'Critter',       // #2  (1 pts,    0W)
-	'Hogger',        // #3  (9 pts,   29W)
-	'Bonemancer',    // #4  (9 pts,   32W)
-	'Rookie',        // #5  (9 pts,   38W)
-	'Turtle',        // #6  (27 pts,  90W)
-	'Spellspinner',  // #7  (27 pts, 104W)
-	'Flamecaller',   // #8  (28 pts, 103W)
-	'Doombringer',   // #9  (30 pts, 108W)
-	'Golem',         // #10 (30 pts, 126W)
-	'Sentinel',      // #11 (30 pts,  98W)
-	'Shadowblade',   // #12 (33 pts, 120W)
-	'Stormchaser',   // #13 (36 pts, 116W)
-	'Warmage',       // #14 (39 pts, 144W)
-	'Battlemage',    // #15 (45 pts, 141W)
-	'Spellweaver',   // #16 (45 pts, 164W)
-	'Stormcaller',   // #17 (48 pts, 170W)
-	'Pyromancer',    // #18 (48 pts, 161W)
-	'Lich',          // #19 (51 pts, 165W)
-	'Archlich',      // #20 (58 pts, 184W)
-	'Infernalist',   // #21 (60 pts, 197W)
-	'Stormforger',   // #22 (60 pts, 211W)
-	'Spellshot',     // #23 (63 pts, 196W)
-	'Spelltracer',   // #24 (63 pts, 186W)
-	'Spellbinder',   // #25 (66 pts, 199W)
-	'Archmage',      // #26 (72 pts, 229W)
-	'Nightblade',    // #27 (72 pts, 230W)
-	'Spellseeker',   // #28 (76 pts, 243W)
-	'Voidblade',     // #29 (78 pts, 258W)
+	// Weakest → strongest, per the 30-bot round-robin (npm run tournament, 2026-06-16).
+	'TargetDummy',   // 0 pts
+	'Critter',       // 3
+	'Bonemancer',    // 12
+	'Hogger',        // 12
+	'Rookie',        // 15
+	'Turtle',        // 36
+	'Flamecaller',   // 37
+	'Spellseeker',   // 39
+	'Stormchaser',   // 39  (dropped — Hero now beats it via the berserker counter)
+	'Nightblade',    // 39
+	'Battlemage',    // 40
+	'Spellweaver',   // 42
+	'Stormforger',   // 42
+	'Archmage',      // 43  (dropped — Hero now DRAWS the mirror instead of losing it)
+	'Spellspinner',  // 44
+	'Sentinel',      // 45
+	'Pyromancer',    // 45
+	'Shadowblade',   // 45
+	'Archlich',      // 46  (Hero beats it via reactive delegation to Spellshot)
+	'Spellbinder',   // 48
+	'Warmage',       // 51
+	'Doombringer',   // 51
+	'Golem',         // 55
+	'Stormcaller',   // 59
+	'Voidblade',     // 61
+	'Lich',          // 62
+	'Infernalist',   // 63
+	'Spelltracer',   // 67
+	'Spellshot',     // 70  (#2 — the sniper champion; Hero beats it head-to-head)
+	'Hero',          // 85  (#1 — adaptive; beats 28 of 29 and DRAWS its Archmage mirror → no losing matchup)
 ];
 
-export const ALL_BOTS: BotEntry[] = ALL_BOTS_ORDER.map((name) =>
+export const ALL_BOTS: WizardEntry[] = ALL_BOTS_ORDER.map((name) =>
 {
 	const bot = BOT_MAP.get(name);
 	if (!bot) throw new Error(`Bot "${name}" not found in BOT_GROUPS`);

package/src/bots/shared.ts

@@ -8,10 +8,166 @@ import {GameState, Position, ProjectileState} from '../types.js';
 import {analyzeThreats} from '../hooks/threat-analysis.js';
 import type {AnalyzedThreat} from '../hooks/types.js';
 import {distanceTo} from '../utils/distance.js';
-import {ARENA_SIZE, BLINK_RANGE, GCD_DURATION, SHIELD_CAST_TIME, WIZARD_RADIUS} from '../rules.js';
+import {RULES, WIZARD_RADIUS, ARENA_MIN, ARENA_MAX} from '../rules.js';
+
+const LAVA_SAFE_MIN = ARENA_MIN + WIZARD_RADIUS + 2;
+const LAVA_SAFE_MAX = ARENA_MAX - WIZARD_RADIUS - 2;
+
+/**
+ * Clamp a movement vector so the wizard doesn't walk into lava.
+ */
+export function avoidLava(position: Position, move: {x: number; y: number}): {x: number; y: number}
+{
+	let {x, y} = move;
+	if (position.x <= LAVA_SAFE_MIN && x < 0) x = 0;
+	if (position.x >= LAVA_SAFE_MAX && x > 0) x = 0;
+	if (position.y <= LAVA_SAFE_MIN && y < 0) y = 0;
+	if (position.y >= LAVA_SAFE_MAX && y > 0) y = 0;
+	return {x, y};
+}
+
+/**
+ * Distance from the lava-safe boundary at which a wizard starts steering back
+ * toward center. Sized to exceed a single missile's knockback reach so a bot that
+ * holds this margin can't be punched through the border by one hit.
+ */
+const WALL_DANGER = 110;
+
+/**
+ * Wall-recovery steering — the wall-awareness every bot needs so it never gets
+ * cornered into lava (by knockback drift or by tight kiting).
+ *
+ * In the open interior this returns `desiredMove` unchanged (a stationary bot
+ * passing {0,0} stays put). As the wizard nears a wall it blends in a push toward
+ * arena center, growing stronger the closer to the edge and fully overriding any
+ * outward move at the boundary, so the wizard actively un-corners itself instead
+ * of drifting in. The result never contains a component pointing further into lava.
+ */
+export function keepOffWalls(position: Position, desiredMove: {x: number; y: number} = {x: 0, y: 0}): {x: number; y: number}
+{
+	let cx = 0;
+	let cy = 0;
+	const distLeft = position.x - LAVA_SAFE_MIN;
+	const distRight = LAVA_SAFE_MAX - position.x;
+	const distTop = position.y - LAVA_SAFE_MIN;
+	const distBottom = LAVA_SAFE_MAX - position.y;
+	if (distLeft < WALL_DANGER) cx += (WALL_DANGER - Math.max(0, distLeft)) / WALL_DANGER;
+	if (distRight < WALL_DANGER) cx -= (WALL_DANGER - Math.max(0, distRight)) / WALL_DANGER;
+	if (distTop < WALL_DANGER) cy += (WALL_DANGER - Math.max(0, distTop)) / WALL_DANGER;
+	if (distBottom < WALL_DANGER) cy -= (WALL_DANGER - Math.max(0, distBottom)) / WALL_DANGER;
+
+	const urgency = Math.min(1, Math.max(Math.abs(cx), Math.abs(cy)));
+	if (urgency <= 0) return desiredMove;
+
+	// Normalize an over-long desired move so the blend weights stay meaningful.
+	const mag = Math.hypot(desiredMove.x, desiredMove.y);
+	const dir = mag > 1 ? {x: desiredMove.x / mag, y: desiredMove.y / mag} : desiredMove;
+	const blended = {
+		x: dir.x * (1 - urgency) + cx * urgency,
+		y: dir.y * (1 - urgency) + cy * urgency,
+	};
+	return avoidLava(position, blended);
+}
+
+export interface LavaEvade
+{
+	action: 'blink' | 'move';
+	x: number;
+	y: number;
+}
+
+/** Max distance a single missile of `damage` can knock a wizard (decaying-impulse sum). */
+function knockbackReach(damage: number): number
+{
+	const over = damage - RULES.KNOCKBACK_DAMAGE_THRESHOLD;
+	return over > 0 ? (over * RULES.KNOCKBACK_SPEED_PER_DAMAGE) / (1 - RULES.KNOCKBACK_DECAY) : 0;
+}
+
+/** Distance from `pos` along (dx,dy) until it crosses the lava-safe boundary (∞ if never). */
+function distToLavaAlong(pos: Position, dx: number, dy: number): number
+{
+	let t = Infinity;
+	if (dx > 1e-6) t = Math.min(t, (LAVA_SAFE_MAX - pos.x) / dx);
+	else if (dx < -1e-6) t = Math.min(t, (LAVA_SAFE_MIN - pos.x) / dx);
+	if (dy > 1e-6) t = Math.min(t, (LAVA_SAFE_MAX - pos.y) / dy);
+	else if (dy < -1e-6) t = Math.min(t, (LAVA_SAFE_MIN - pos.y) / dy);
+	return Math.max(0, t);
+}
+
+/**
+ * Emergency lava-evade — the skill that makes a knockback lava death the bot's fault.
+ *
+ * Knockback ignores shields, so a damaging missile that would shove this wizard past
+ * the lava border (in the away-from-enemy direction it gets knocked) is a death you
+ * can only avoid by NOT being hit. When such a hit is imminent this returns a blink
+ * clear of it — toward center — if blink is ready, else a dodge; to be taken with TOP
+ * priority, AHEAD of shielding. Returns null when no incoming hit would reach lava
+ * (run the normal defense). If you're cornered with blink down and can't dodge, it
+ * returns null and you eat it — you messed up.
+ */
+export function getLavaEvade(
+	position: Position,
+	enemyPos: Position,
+	threats: AnalyzedThreat[],
+	blinkCooldown: number,
+	horizonTicks = 40,
+): LavaEvade | null
+{
+	const ax = position.x - enemyPos.x;
+	const ay = position.y - enemyPos.y;
+	const amag = Math.hypot(ax, ay) || 1;
+	const distToWall = distToLavaAlong(position, ax / amag, ay / amag);
+
+	for (const threat of threats)
+	{
+		if (!threat.willHit || threat.ticksToImpact > horizonTicks) continue;
+		const reach = knockbackReach(threat.projectile.damage);
+		if (reach <= 0 || reach + WIZARD_RADIUS < distToWall) continue; // this hit can't reach lava
+
+		// A lava-lethal hit is imminent — must not get hit (shields don't stop knockback).
+		if (blinkCooldown === 0 && threat.ticksToImpact >= RULES.BLINK_CAST_TIME)
+		{
+			const target = getBlinkToCenter(position);
+			return {action: 'blink', x: target.x, y: target.y};
+		}
+		const dodge = getDodgeDirectionForMovement([threat], position);
+		if (dodge)
+		{
+			const safe = keepOffWalls(position, dodge);
+			return {action: 'move', x: safe.x, y: safe.y};
+		}
+		const recenter = keepOffWalls(position);
+		if (recenter.x !== 0 || recenter.y !== 0) return {action: 'move', x: recenter.x, y: recenter.y};
+		return null; // cornered, blink down, can't dodge — you messed up
+	}
+	return null;
+}
+
+/**
+ * Pre-cast wall discipline. A bot committed to a long cast can't react for its whole
+ * cast time, so casting near a wall means a knockback lava death — its own fault. If
+ * there isn't `margin` units of room toward the away-from-enemy wall (where knockback
+ * shoves it), this returns a move toward arena center to take FIRST, before the cast;
+ * else null (safe to commit).
+ */
+export function getPreCastReposition(position: Position, enemyPos: Position, margin?: number): {x: number; y: number} | null
+{
+	// Default margin = the reach of a solid (damage-30) hit + a buffer, so it scales
+	// with the ruleset's knockback (a heavier-knockback ruleset demands more room).
+	const safeMargin = margin ?? knockbackReach(30) + WIZARD_RADIUS + 30;
+	const ax = position.x - enemyPos.x;
+	const ay = position.y - enemyPos.y;
+	const amag = Math.hypot(ax, ay) || 1;
+	if (distToLavaAlong(position, ax / amag, ay / amag) >= safeMargin) return null;
+	const center = (ARENA_MIN + ARENA_MAX) / 2;
+	const cx = center - position.x;
+	const cy = center - position.y;
+	const cmag = Math.hypot(cx, cy) || 1;
+	return {x: cx / cmag, y: cy / cmag};
+}
 
 // Re-export public utility so bots can import from shared
-export {fitMissileToBudget} from '../utils/combat.js';
+export {fitMissileToBudget, fitMissileForEscapingTarget} from '../utils/combat.js';
 
 // T2 bots: max cast time when no threats are incoming (~2s)
 export const MAX_CAST_BUDGET = 200;
@@ -61,12 +217,14 @@ export function getMostUrgentThreat(threats: AnalyzedThreat[]): AnalyzedThreat |
 
 /**
  * Determine if a threat should force a shield even when a dodge direction exists.
- * High-damage homing missiles are too risky to dodge — the missile tracks the wizard
- * and the dodge often fails. Shield instead to guarantee survival.
+ * - High-damage homing missiles are too risky to dodge (missile tracks you)
+ * - Close-range threats arrive before you can strafe clear (need ~10 ticks to dodge)
  */
 export function shouldForceShield(threat: AnalyzedThreat): boolean
 {
-	return threat.projectile.damage >= 25 && threat.projectile.turnRate > 0;
+	if (threat.projectile.damage >= 25 && threat.projectile.turnRate > 0) return true;
+	if (threat.ticksToImpact <= 12 && threat.projectile.damage >= 10) return true;
+	return false;
 }
 
 /**
@@ -126,8 +284,8 @@ export function getDodgeDirectionForMovement(
 	// Tiebreaker for dead-center missiles: pick the side further from walls
 	const futureA = {x: myPos.x + dodgeCCW.x * 100, y: myPos.y + dodgeCCW.y * 100};
 	const futureB = {x: myPos.x + dodgeCW.x * 100, y: myPos.y + dodgeCW.y * 100};
-	const scoreA = Math.min(futureA.x, ARENA_SIZE - futureA.x, futureA.y, ARENA_SIZE - futureA.y);
-	const scoreB = Math.min(futureB.x, ARENA_SIZE - futureB.x, futureB.y, ARENA_SIZE - futureB.y);
+	const scoreA = Math.min(futureA.x - ARENA_MIN, ARENA_MAX - futureA.x, futureA.y - ARENA_MIN, ARENA_MAX - futureA.y);
+	const scoreB = Math.min(futureB.x - ARENA_MIN, ARENA_MAX - futureB.x, futureB.y - ARENA_MIN, ARENA_MAX - futureB.y);
 
 	return scoreA >= scoreB ? dodgeCCW : dodgeCW;
 }
@@ -143,8 +301,8 @@ export function getDodgeDirectionForMovement(
 export function isSafeToAttack(
 	threats: AnalyzedThreat[],
 	castTicks: number,
-	gcdTicks: number = GCD_DURATION,
-	shieldCastTicks: number = SHIELD_CAST_TIME,
+	gcdTicks: number = RULES.GCD_DURATION,
+	shieldCastTicks: number = RULES.SHIELD_CAST_TIME,
 ): boolean
 {
 	// No threats = safe
@@ -188,8 +346,8 @@ export function isSafeToAttack(
  */
 export function getBlinkToCenter(pos: Position): Position
 {
-	const centerX = ARENA_SIZE / 2;
-	const centerY = ARENA_SIZE / 2;
+	const centerX = (ARENA_MIN + ARENA_MAX) / 2;
+	const centerY = (ARENA_MIN + ARENA_MAX) / 2;
 	const dx = centerX - pos.x;
 	const dy = centerY - pos.y;
 	const dist = Math.sqrt(dx * dx + dy * dy);
@@ -197,8 +355,8 @@ export function getBlinkToCenter(pos: Position): Position
 	if (dist === 0) return {x: centerX, y: centerY};
 
 	return {
-		x: pos.x + (dx / dist) * BLINK_RANGE,
-		y: pos.y + (dy / dist) * BLINK_RANGE,
+		x: Math.max(LAVA_SAFE_MIN, Math.min(LAVA_SAFE_MAX, pos.x + (dx / dist) * RULES.BLINK_RANGE)),
+		y: Math.max(LAVA_SAFE_MIN, Math.min(LAVA_SAFE_MAX, pos.y + (dy / dist) * RULES.BLINK_RANGE)),
 	};
 }
 
@@ -207,7 +365,7 @@ export function getBlinkToCenter(pos: Position): Position
 // ============================================================================
 
 // Post-blink vulnerability: shield cast time before wizard can defend (blink has no GCD)
-const POST_BLINK_VULNERABILITY = SHIELD_CAST_TIME;
+const POST_BLINK_VULNERABILITY = RULES.SHIELD_CAST_TIME;
 
 // Approximate hit radius for missile safety (wizard radius + typical missile radius)
 const HIT_RADIUS = WIZARD_RADIUS + 3;
@@ -273,7 +431,7 @@ function findBestBlinkTarget(
 	if (currentDist < 0.01)
 	{
 		// Overlapping: fallback to toward center
-		baseAngle = Math.atan2(ARENA_SIZE / 2 - myPos.y, ARENA_SIZE / 2 - myPos.x);
+		baseAngle = Math.atan2((ARENA_MIN + ARENA_MAX) / 2 - myPos.y, (ARENA_MIN + ARENA_MAX) / 2 - myPos.x);
 	}
 	else
 	{
@@ -288,8 +446,8 @@ function findBestBlinkTarget(
 
 	// For decrease: don't overshoot past enemy
 	const maxBlinkDist = goal === 'decrease'
-		? Math.min(BLINK_RANGE, currentDist)
-		: BLINK_RANGE;
+		? Math.min(RULES.BLINK_RANGE, currentDist)
+		: RULES.BLINK_RANGE;
 
 	let bestTarget: Position | null = null;
 	let bestScore = -Infinity;
@@ -304,8 +462,8 @@ function findBestBlinkTarget(
 			const angle = baseAngle + (i * 2 * Math.PI) / ANGLE_CANDIDATES;
 
 			// Candidate position (clamped with wall buffer to prevent wall-hugging)
-			const cx = Math.max(BLINK_WALL_MARGIN, Math.min(ARENA_SIZE - BLINK_WALL_MARGIN, myPos.x + Math.cos(angle) * blinkDist));
-			const cy = Math.max(BLINK_WALL_MARGIN, Math.min(ARENA_SIZE - BLINK_WALL_MARGIN, myPos.y + Math.sin(angle) * blinkDist));
+			const cx = Math.max(ARENA_MIN + BLINK_WALL_MARGIN, Math.min(ARENA_MAX - BLINK_WALL_MARGIN, myPos.x + Math.cos(angle) * blinkDist));
+			const cy = Math.max(ARENA_MIN + BLINK_WALL_MARGIN, Math.min(ARENA_MAX - BLINK_WALL_MARGIN, myPos.y + Math.sin(angle) * blinkDist));
 
 			// Skip if clamping made this a non-blink
 			if (distanceTo(myPos, {x: cx, y: cy}) < 10) continue;
@@ -317,7 +475,7 @@ function findBestBlinkTarget(
 			const distScore = goal === 'increase' ? enemyDist : -enemyDist;
 
 			// Penalize distance from arena center (prevents corner-trapping)
-			const center = ARENA_SIZE / 2;
+			const center = (ARENA_MIN + ARENA_MAX) / 2;
 			const distFromCenter = distanceTo(candidate, {x: center, y: center});
 
 			// Missile danger penalty
@@ -448,23 +606,25 @@ export function getClosingRate(
  * GCD-locked → remaining GCD. Idle/channeling → 0.
  */
 export function getEnemyVulnerabilityTicks(enemy: {
-	state: string;
-	castingSpell?: string;
+	state?: string;
+	status?: string;
+	castingSpell?: string | null;
 	castProgress?: number;
 	castDuration?: number;
 	gcdRemaining?: number;
 }): number
 {
-	if (enemy.state === 'casting')
+	const enemyState = enemy.status ?? enemy.state;
+	if (enemyState === 'casting')
 	{
 		const remainingCast = (enemy.castDuration ?? 0) - (enemy.castProgress ?? 0);
 		if (enemy.castingSpell === 'missile')
 		{
-			return remainingCast + GCD_DURATION;
+			return remainingCast + RULES.GCD_DURATION;
 		}
 		return remainingCast;
 	}
-	if (enemy.state === 'gcd_locked')
+	if (enemyState === 'gcd_locked')
 	{
 		return enemy.gcdRemaining ?? 0;
 	}