@vibemancer/core 0.1.3 → 0.1.5

package/src/engine/bundle-fight.ts

@@ -0,0 +1,242 @@
+/**
+ * Run a fight between two PRECOMPILED bot bundles — the canonical uploaded-wizard
+ * format where each IIFE sets `globalThis.__injectedBot1` (see compileSingleBotBundle).
+ *
+ * Shared by the Cloud Functions matchmaker and the devkit CLI so that a
+ * `handle/botname` fight runs through the exact same engine as the live ladder.
+ *
+ * Both bundles run inside an isolated-vm isolate alongside a "match template" —
+ * the engine + a `__fight` harness that reads the injected bots. The template is
+ * built lazily from the engine source on first use and cached; callers that
+ * already have one (the Cloud Functions committed MATCH_TEMPLATE) pass it in to
+ * skip the esbuild step.
+ *
+ * Execution order inside the isolate: bot1 bundle → bot2 bundle → match template.
+ */
+
+import path from 'node:path';
+import ivm from 'isolated-vm';
+import {build} from 'esbuild';
+import {getEngineDir} from './sandbox-compile.js';
+import type {FightResult, SimulateResult} from './simulation.js';
+
+/** Memory limit per sandbox isolate (MB). */
+const MEMORY_LIMIT_MB = 256;
+/** Timeout per fight (ms). */
+const FIGHT_TIMEOUT_MS = 60_000;
+
+const FREEZE_BANNER = `
+Object.freeze(Object.prototype);
+Object.freeze(Array.prototype);
+Object.freeze(Function.prototype);
+Object.freeze(String.prototype);
+Object.freeze(Number.prototype);
+Object.freeze(Boolean.prototype);
+Object.freeze(RegExp.prototype);
+Object.freeze(Date.prototype);
+Object.freeze(Error.prototype);
+Object.freeze(Map.prototype);
+Object.freeze(Set.prototype);
+Object.freeze(Math);
+Object.freeze(JSON);
+(function() {
+	var g = typeof globalThis !== 'undefined' ? globalThis : typeof self !== 'undefined' ? self : {};
+	var blocked = [
+		'fetch', 'XMLHttpRequest', 'WebSocket', 'EventSource',
+		'importScripts', 'Worker', 'SharedWorker',
+		'Request', 'Response', 'Headers',
+		'navigator', 'BroadcastChannel',
+		'indexedDB', 'caches'
+	];
+	for (var i = 0; i < blocked.length; i++) {
+		try { Object.defineProperty(g, blocked[i], {value: undefined, writable: false, configurable: false}); }
+		catch(e) {}
+	}
+})();
+`;
+
+let cachedTemplate: Promise<string> | null = null;
+
+/**
+ * Build (and cache) the match template: the engine + `__fight`/`__simulate`
+ * harness bundled into a single IIFE string, ready to run after two bot bundles
+ * have set `globalThis.__injectedBot1`/`__injectedBot2`.
+ */
+export function buildMatchTemplate(): Promise<string>
+{
+	if (!cachedTemplate)
+	{
+		cachedTemplate = (async(): Promise<string> =>
+		{
+			const engineDir = getEngineDir();
+			const coreSrc = path.dirname(engineDir).replace(/\\/g, '/');
+
+			const entryPoint = `
+import {fight, simulate} from '${coreSrc}/engine/simulation.ts';
+import {wrapWithParams} from '${coreSrc}/engine/params-runtime.ts';
+
+const __Bot1 = (globalThis as any).__injectedBot1;
+const __Bot2 = (globalThis as any).__injectedBot2;
+
+if (!__Bot1) throw new Error('Bot 1 not injected (set globalThis.__injectedBot1)');
+if (!__Bot2) throw new Error('Bot 2 not injected (set globalThis.__injectedBot2)');
+
+(globalThis as any).__fight = function __fight(options: any) {
+	return fight(__Bot1, __Bot2, options);
+};
+
+(globalThis as any).__simulate = function __simulate(options: any) {
+	const {params1, params2, ...simOptions} = options;
+	const bot1 = params1 ? wrapWithParams(__Bot1, params1) : __Bot1;
+	const bot2 = params2 ? wrapWithParams(__Bot2, params2) : __Bot2;
+	return simulate(bot1, bot2, simOptions);
+};
+`;
+
+			const result = await build({
+				stdin: {contents: entryPoint, resolveDir: engineDir, loader: 'ts'},
+				bundle: true,
+				write: false,
+				format: 'iife',
+				platform: 'neutral',
+				target: 'es2022',
+				banner: {js: FREEZE_BANNER},
+				logLevel: 'error',
+				external: [
+					'isolated-vm', 'esbuild',
+					'node:path', 'node:fs', 'node:url',
+					'node:worker_threads', 'node:crypto', 'node:os', 'node:child_process',
+				],
+			});
+
+			if (!result.outputFiles?.[0]) throw new Error('esbuild produced no match-template output');
+			return result.outputFiles[0].text;
+		})();
+	}
+	return cachedTemplate;
+}
+
+export interface RunBundleFightOptions
+{
+	seed: number;
+	/** Prebuilt match template (e.g. the committed Cloud Functions one). Built lazily if omitted. */
+	matchTemplate?: string;
+	/** Skip per-tick history in the result (smaller copy out of the isolate). Default true. */
+	skipHistory?: boolean;
+}
+
+/**
+ * Run a fight between two compiled `__injectedBot1`-format bundles.
+ *
+ * bundle1 is saved and its global cleared before bundle2 runs, so bot code can
+ * never read the opponent's function off globalThis. Both globals are deleted
+ * after wiring so runtime bot code can't reach them either.
+ */
+export async function runBundleFight(
+	bundle1: string,
+	bundle2: string,
+	options: RunBundleFightOptions,
+): Promise<FightResult>
+{
+	const template = options.matchTemplate ?? await buildMatchTemplate();
+	const skipHistory = options.skipHistory ?? true;
+
+	const code = bundle1
+		+ '\nvar __savedBot1 = globalThis.__injectedBot1;\n'
+		+ 'globalThis.__injectedBot1 = undefined;\n'
+		+ bundle2
+		+ '\nglobalThis.__injectedBot2 = globalThis.__injectedBot1;\n'
+		+ '\nglobalThis.__injectedBot1 = __savedBot1;\n'
+		+ '__savedBot1 = undefined;\n'
+		+ template
+		+ '\ndelete globalThis.__injectedBot1;\ndelete globalThis.__injectedBot2;\n';
+
+	const isolate = new ivm.Isolate({memoryLimit: MEMORY_LIMIT_MB});
+
+	try
+	{
+		const context = await isolate.createContext();
+		const jail = context.global;
+		await jail.set('global', jail.derefInto());
+
+		const script = await isolate.compileScript(code);
+		await script.run(context, {timeout: FIGHT_TIMEOUT_MS});
+
+		const fightFn = await jail.get('__fight');
+		const result = await fightFn.apply(
+			undefined,
+			[new ivm.ExternalCopy({seed: options.seed, skipHistory}).copyInto()],
+			{timeout: FIGHT_TIMEOUT_MS, result: {copy: true}},
+		);
+
+		// eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- isolated-vm returns unknown
+		return result as FightResult;
+	}
+	finally
+	{
+		if (!isolate.isDisposed) isolate.dispose();
+	}
+}
+
+export interface RunBundleSimulateOptions
+{
+	seed?: number;
+	spawnDistance?: number;
+	maxTicks?: number;
+	matchTemplate?: string;
+}
+
+/**
+ * Run a SINGLE match between two compiled bundles, returning the full per-tick
+ * history (for tracing/debugging). Same isolate wiring as runBundleFight, but
+ * calls the template's `__simulate` so the caller gets a SimulateResult.
+ */
+export async function runBundleSimulate(
+	bundle1: string,
+	bundle2: string,
+	options: RunBundleSimulateOptions = {},
+): Promise<SimulateResult>
+{
+	const template = options.matchTemplate ?? await buildMatchTemplate();
+
+	const code = bundle1
+		+ '\nvar __savedBot1 = globalThis.__injectedBot1;\n'
+		+ 'globalThis.__injectedBot1 = undefined;\n'
+		+ bundle2
+		+ '\nglobalThis.__injectedBot2 = globalThis.__injectedBot1;\n'
+		+ '\nglobalThis.__injectedBot1 = __savedBot1;\n'
+		+ '__savedBot1 = undefined;\n'
+		+ template
+		+ '\ndelete globalThis.__injectedBot1;\ndelete globalThis.__injectedBot2;\n';
+
+	const isolate = new ivm.Isolate({memoryLimit: MEMORY_LIMIT_MB});
+
+	try
+	{
+		const context = await isolate.createContext();
+		const jail = context.global;
+		await jail.set('global', jail.derefInto());
+
+		const script = await isolate.compileScript(code);
+		await script.run(context, {timeout: FIGHT_TIMEOUT_MS});
+
+		const simulateFn = await jail.get('__simulate');
+		const simOptions = {
+			seed: options.seed ?? 1,
+			spawnDistance: options.spawnDistance,
+			maxTicks: options.maxTicks,
+		};
+		const result = await simulateFn.apply(
+			undefined,
+			[new ivm.ExternalCopy(simOptions).copyInto()],
+			{timeout: FIGHT_TIMEOUT_MS, result: {copy: true}},
+		);
+
+		// eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- isolated-vm returns unknown
+		return result as SimulateResult;
+	}
+	finally
+	{
+		if (!isolate.isDisposed) isolate.dispose();
+	}
+}

package/src/engine/hooks-runtime.ts

@@ -12,7 +12,7 @@
  * Violating these rules throws an error (detected via hook index validation).
  */
 
-import type {BotContext} from '../hooks/types.js';
+import type {WizardContext, MissileContext} from '../hooks/types.js';
 
 export interface HookState
 {
@@ -63,14 +63,23 @@ function _setCurrentHookIndex(idx: number): void
 {
 	_g.__vibemancer_currentHookIndex = idx;
 }
-function _getCurrentBotContext(): BotContext | null
+function _getCurrentWizardContext(): WizardContext | null
 {
-	// eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- we own __vibemancer_currentBotContext
-	return (_g.__vibemancer_currentBotContext as BotContext | null) ?? null;
+	// eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- we own __vibemancer_currentWizardContext
+	return (_g.__vibemancer_currentWizardContext as WizardContext | null) ?? null;
 }
-function _setCurrentBotContext(ctx: BotContext | null): void
+function _setCurrentWizardContext(ctx: WizardContext | null): void
 {
-	_g.__vibemancer_currentBotContext = ctx;
+	_g.__vibemancer_currentWizardContext = ctx;
+}
+function _getCurrentMissileContext(): MissileContext | null
+{
+	// eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- we own __vibemancer_currentMissileContext
+	return (_g.__vibemancer_currentMissileContext as MissileContext | null) ?? null;
+}
+function _setCurrentMissileContext(ctx: MissileContext | null): void
+{
+	_g.__vibemancer_currentMissileContext = ctx;
 }
 
 /**
@@ -206,10 +215,10 @@ export function runWithHooks<T>(entityId: string, fn: () => T): T
  * Run a bot function with full context (game state + persistence hooks).
  * Use this when you need to set BOTH the entity ID and the game context.
  */
-export function runBotWithContext<T>(entityId: string, context: BotContext, fn: () => T): T
+export function runWizardWithContext<T>(entityId: string, context: WizardContext, fn: () => T): T
 {
-	const previousContext = _getCurrentBotContext();
-	_setCurrentBotContext(context);
+	const previousContext = _getCurrentWizardContext();
+	_setCurrentWizardContext(context);
 
 	try
 	{
@@ -217,18 +226,18 @@ export function runBotWithContext<T>(entityId: string, context: BotContext, fn:
 	}
 	finally
 	{
-		_setCurrentBotContext(previousContext);
+		_setCurrentWizardContext(previousContext);
 	}
 }
 
 /**
  * Run a function with game state context only, preserving the current entity ID.
- * Use this inside wrapNewBot where the entity ID is already set by the outer runWithHooks.
+ * Used by the simulation to set up WizardContext before calling hooks-style bots.
  */
-export function withBotContext<T>(context: BotContext, fn: () => T): T
+export function withWizardContext<T>(context: WizardContext, fn: () => T): T
 {
-	const previousContext = _getCurrentBotContext();
-	_setCurrentBotContext(context);
+	const previousContext = _getCurrentWizardContext();
+	_setCurrentWizardContext(context);
 
 	try
 	{
@@ -236,20 +245,51 @@ export function withBotContext<T>(context: BotContext, fn: () => T): T
 	}
 	finally
 	{
-		_setCurrentBotContext(previousContext);
+		_setCurrentWizardContext(previousContext);
 	}
 }
 
 /**
  * Get the current bot context. Throws if called outside bot execution.
  */
-export function getBotContext(): BotContext
+export function getWizardContext(): WizardContext
 {
-	if (!_getCurrentBotContext())
+	if (!_getCurrentWizardContext())
 	{
 		throw new Error('Game state hooks can only be used inside a bot function');
 	}
-	return _getCurrentBotContext()!;
+	return _getCurrentWizardContext()!;
+}
+
+/**
+ * Run a function with missile context set, preserving the current entity ID.
+ * Used by the simulation to set up MissileContext before calling hooks-style missile AIs.
+ */
+export function withMissileContext<T>(context: MissileContext, fn: () => T): T
+{
+	const previousContext = _getCurrentMissileContext();
+	_setCurrentMissileContext(context);
+
+	try
+	{
+		return fn();
+	}
+	finally
+	{
+		_setCurrentMissileContext(previousContext);
+	}
+}
+
+/**
+ * Get the current missile context. Throws if called outside missile AI execution.
+ */
+export function getMissileContext(): MissileContext
+{
+	if (!_getCurrentMissileContext())
+	{
+		throw new Error('getMissileContext() can only be used inside a missile AI function');
+	}
+	return _getCurrentMissileContext()!;
 }
 
 /**

package/src/engine/manual-match.ts

@@ -9,25 +9,26 @@
  * Extra capabilities over `simulate()`:
  * - step(N) advances N ticks at a time (default 1) — caller controls pacing
  * - replaceMissileAI(id, ai) hot-swaps a missile's AI mid-flight (used by
- *   the missile-hijack feature in manual play)
+ *   the missile-guide feature in manual play)
  * - setInvincible(wizardIndex, on) toggles damage immunity per wizard
  */
 
 import {
-	ARENA_HEIGHT,
-	ARENA_WIDTH,
+	RULES,
+	ARENA_SIZE,
+	ARENA_MIN,
+	ARENA_MAX,
 	MATCH_DURATION,
 	SPAWN_DISTANCE,
 	TICKS_PER_SECOND,
-	WIZARD_HEALTH,
 } from '../rules.js';
 import type {
 	GameConfig,
 	GameState,
-	MissileAIFunction,
 	ProjectileState,
-	WizardFunction,
 } from '../types.js';
+import type {MissileFunction} from '../hooks/types.js';
+import type {WizardFunction} from '../hooks/types.js';
 import {clearHooks} from './hooks-runtime.js';
 import {
 	type BotError,
@@ -61,10 +62,10 @@ function createInitialWizards(spawnDistance: number): InternalWizardState[]
 	return [
 		{
 			id: 'wizard-1',
-			position: {x: ARENA_WIDTH / 2 - spawnDistance / 2, y: ARENA_HEIGHT / 2},
+			position: {x: ARENA_SIZE / 2 - spawnDistance / 2, y: ARENA_SIZE / 2},
 			rotation: 0,
-			health: WIZARD_HEALTH,
-			maxHealth: WIZARD_HEALTH,
+			health: RULES.WIZARD_HEALTH,
+			maxHealth: RULES.WIZARD_HEALTH,
 			state: 'idle',
 			blinkCooldown: 0,
 			velocity: {x: 0, y: 0},
@@ -74,10 +75,10 @@ function createInitialWizards(spawnDistance: number): InternalWizardState[]
 		},
 		{
 			id: 'wizard-2',
-			position: {x: ARENA_WIDTH / 2 + spawnDistance / 2, y: ARENA_HEIGHT / 2},
+			position: {x: ARENA_SIZE / 2 + spawnDistance / 2, y: ARENA_SIZE / 2},
 			rotation: 180,
-			health: WIZARD_HEALTH,
-			maxHealth: WIZARD_HEALTH,
+			health: RULES.WIZARD_HEALTH,
+			maxHealth: RULES.WIZARD_HEALTH,
 			state: 'idle',
 			blinkCooldown: 0,
 			velocity: {x: 0, y: 0},
@@ -98,13 +99,15 @@ export class ManualMatch
 
 	private wizards: InternalWizardState[];
 	private projectiles: ProjectileState[] = [];
-	private missileAIs: Map<string, MissileAIFunction> = new Map();
-	/** First-replacement originals for hijacked missiles. Used by restoreMissileAI. */
-	private originalMissileAIs: Map<string, MissileAIFunction> = new Map();
+	private missileAIs: Map<string, MissileFunction> = new Map();
+	/** First-replacement originals for guided missiles. Used by restoreMissileAI. */
+	private originalMissileAIs: Map<string, MissileFunction> = new Map();
 	private currentTick = 0;
 	private done = false;
+	private deathTick: number | null = null;
 	private allErrors: BotError[] = [];
 	private history: GameState[];
+	private lastTickEvents: import('../types.js').SimEvent[] = [];
 
 	constructor(wizard1AI: WizardFunction, wizard2AI: WizardFunction, options: ManualMatchOptions = {})
 	{
@@ -131,11 +134,11 @@ export class ManualMatch
 			? Math.min(Math.floor(rawMaxTicks), 100000)
 			: MATCH_DURATION;
 		const spawnDistance = Number.isFinite(rawSpawn) && rawSpawn! > 0
-			? Math.min(rawSpawn!, Math.min(ARENA_WIDTH, ARENA_HEIGHT) - 100)
+			? Math.min(rawSpawn!, (ARENA_MAX - ARENA_MIN) - 100)
 			: SPAWN_DISTANCE;
 
 		this.config = Object.freeze({
-			arenaSize: Object.freeze({width: ARENA_WIDTH, height: ARENA_HEIGHT}),
+			arenaSize: Object.freeze({width: ARENA_SIZE, height: ARENA_SIZE}),
 			tickRate: TICKS_PER_SECOND,
 			maxTicks: this.maxTicks,
 		});
@@ -172,17 +175,22 @@ export class ManualMatch
 			this.currentTick = result.nextTick;
 			this.wizards = result.wizards;
 			this.projectiles = result.projectiles;
+			this.lastTickEvents = result.events;
 			if (result.errors.length > 0)
 			{
 				this.allErrors.push(...result.errors);
 				errorsThisCall.push(...result.errors);
 			}
 
-			this.history.push(getPlayerState(0, this.wizards, this.projectiles, this.currentTick));
+			this.history.push(getPlayerState(0, this.wizards, this.projectiles, this.currentTick, result.events));
 
+			// Track death and add grace period (0.5s = 50 ticks at 100 tps)
+			if (!this.deathTick && (this.wizards[0]!.health <= 0 || this.wizards[1]!.health <= 0))
+			{
+				this.deathTick = this.currentTick;
+			}
 			if (
-				this.wizards[0]!.health <= 0
-				|| this.wizards[1]!.health <= 0
+				(this.deathTick && this.currentTick - this.deathTick >= 200)
 				|| this.currentTick >= this.maxTicks
 			)
 			{
@@ -198,14 +206,14 @@ export class ManualMatch
 	}
 
 	/**
-	 * Hot-swap a missile's AI function. Used by the missile-hijack feature
+	 * Hot-swap a missile's AI function. Used by the missile-guide feature
 	 * in manual play. The first replacement remembers the original AI so
 	 * `restoreMissileAI` can put it back. Subsequent replacements update
 	 * the active AI but leave the remembered original alone.
 	 *
 	 * No-op if the projectile id doesn't exist.
 	 */
-	replaceMissileAI(projectileId: string, ai: MissileAIFunction): void
+	replaceMissileAI(projectileId: string, ai: MissileFunction): void
 	{
 		const existing = this.missileAIs.get(projectileId);
 		if (!existing) return;
@@ -217,8 +225,8 @@ export class ManualMatch
 	}
 
 	/**
-	 * Restore a previously hijacked missile's original AI function.
-	 * No-op if the projectile id doesn't exist or was never hijacked.
+	 * Restore a previously guided missile's original AI function.
+	 * No-op if the projectile id doesn't exist or was never guided.
 	 */
 	restoreMissileAI(projectileId: string): void
 	{
@@ -246,7 +254,7 @@ export class ManualMatch
 	 */
 	getGameState(): GameState
 	{
-		return getPlayerState(0, this.wizards, this.projectiles, this.currentTick);
+		return getPlayerState(0, this.wizards, this.projectiles, this.currentTick, this.lastTickEvents);
 	}
 
 	getCurrentTick(): number

package/src/engine/missile-templates.ts

@@ -11,7 +11,10 @@ import {
 	MISSILE_MIN_SPEED,
 	MISSILE_MIN_DURATION,
 } from '../rules.js';
-import type {MissileAIFunction, MissileConfig} from '../types.js';
+import type {MissileConfig} from '../types.js';
+import type {MissileFunction} from '../hooks/types.js';
+import {getMissileContext} from './hooks-runtime.js';
+import {turnToward, flyStraight} from '../hooks/action-builders.js';
 
 interface BaseParams
 {
@@ -29,8 +32,6 @@ export type StraightParams = BaseParams;
 
 export type HomingParams = TurningParams;
 
-export type AntiHomingParams = TurningParams;
-
 export interface SpiralParams extends BaseParams
 {
 	spiralRadius: number;
@@ -45,7 +46,7 @@ export interface SeekerParams extends TurningParams
 export interface MissileTemplate
 {
 	config: MissileConfig;
-	ai: MissileAIFunction;
+	ai: MissileFunction;
 }
 
 function clampBase(p: BaseParams): {damage: number; speed: number; duration: number}
@@ -64,7 +65,7 @@ export function straightMissile(p: StraightParams): MissileTemplate
 {
 	const base = clampBase(p);
 	const config: MissileConfig = {...base, turnRate: 0};
-	const ai: MissileAIFunction = () => ({});
+	const ai: MissileFunction = () => flyStraight();
 	return {config, ai};
 }
 
@@ -75,33 +76,12 @@ export function homingMissile(p: HomingParams): MissileTemplate
 {
 	const base = clampBase(p);
 	const config: MissileConfig = {...base, turnRate: p.turnRate};
-	const ai: MissileAIFunction = ({worldState}) =>
+	const ai: MissileFunction = () =>
 	{
-		const enemy = worldState.enemies[0];
-		if (!enemy) return {};
-		return {turnToward: enemy.position};
-	};
-	return {config, ai};
-}
-
-/**
- * Anti-homing missile. Steers AWAY from the enemy — useful as a feint or
- * area-denial pattern.
- */
-export function antiHomingMissile(p: AntiHomingParams): MissileTemplate
-{
-	const base = clampBase(p);
-	const config: MissileConfig = {...base, turnRate: p.turnRate};
-	const ai: MissileAIFunction = ({missileState, worldState}) =>
-	{
-		const enemy = worldState.enemies[0];
-		if (!enemy) return {};
-		// Reflect the enemy position through the missile to get an "away" target.
-		const target = {
-			x: missileState.position.x * 2 - enemy.position.x,
-			y: missileState.position.y * 2 - enemy.position.y,
-		};
-		return {turnToward: target};
+		const ctx = getMissileContext();
+		const enemy = ctx.worldState.enemies[0];
+		if (!enemy) return flyStraight();
+		return turnToward(enemy.position.x, enemy.position.y);
 	};
 	return {config, ai};
 }
@@ -118,14 +98,15 @@ export function spiralMissile(p: SpiralParams): MissileTemplate
 	const config: MissileConfig = {...base, turnRate: 12};
 	const radius = Math.max(1, p.spiralRadius);
 	const freq = p.spiralFreq;
-	const ai: MissileAIFunction = ({missileState}) =>
+	const ai: MissileFunction = () =>
 	{
-		const phase = -missileState.remainingTicks * freq;
+		const ctx = getMissileContext();
+		const phase = -ctx.remainingTicks * freq;
 		const target = {
-			x: missileState.position.x + Math.cos(phase) * radius,
-			y: missileState.position.y + Math.sin(phase) * radius,
+			x: ctx.position.x + Math.cos(phase) * radius,
+			y: ctx.position.y + Math.sin(phase) * radius,
 		};
-		return {turnToward: target};
+		return turnToward(target.x, target.y);
 	};
 	return {config, ai};
 }
@@ -141,15 +122,16 @@ export function seekerMissile(p: SeekerParams): MissileTemplate
 	const config: MissileConfig = {...base, turnRate: p.turnRate};
 	const minDist = Math.max(0, p.minLockDistance);
 	const minDistSq = minDist * minDist;
-	const ai: MissileAIFunction = ({missileState, worldState}) =>
+	const ai: MissileFunction = () =>
 	{
-		const enemy = worldState.enemies[0];
-		if (!enemy) return {};
-		const dx = enemy.position.x - missileState.position.x;
-		const dy = enemy.position.y - missileState.position.y;
+		const ctx = getMissileContext();
+		const enemy = ctx.worldState.enemies[0];
+		if (!enemy) return flyStraight();
+		const dx = enemy.position.x - ctx.position.x;
+		const dy = enemy.position.y - ctx.position.y;
 		const distSq = dx * dx + dy * dy;
-		if (distSq < minDistSq) return {};
-		return {turnToward: enemy.position};
+		if (distSq < minDistSq) return flyStraight();
+		return turnToward(enemy.position.x, enemy.position.y);
 	};
 	return {config, ai};
 }