@vibemancer/core 0.1.0 → 0.1.2

package/src/engine/manual-match.ts

@@ -1,289 +1,289 @@
-/**
- * VIBEMANCER - MANUAL MATCH
- *
- * Tick-by-tick match runner used by manual play mode. Wraps the same
- * `tick()` primitive that `simulate()` uses, so stepping forward
- * produces the same trajectory as a batched `simulate()` with the
- * same seed.
- *
- * 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)
- * - setInvincible(wizardIndex, on) toggles damage immunity per wizard
- */
-
-import {
-	ARENA_HEIGHT,
-	ARENA_WIDTH,
-	MATCH_DURATION,
-	SPAWN_DISTANCE,
-	TICKS_PER_SECOND,
-	WIZARD_HEALTH,
-} from '../rules.js';
-import type {
-	GameConfig,
-	GameState,
-	MissileAIFunction,
-	ProjectileState,
-	WizardFunction,
-} from '../types.js';
-import {clearHooks} from './hooks-runtime.js';
-import {
-	type BotError,
-	type InternalWizardState,
-	type MatchWinner,
-	type SimulateResult,
-	getPlayerState,
-	tick,
-} from './simulation.js';
-
-export interface ManualMatchOptions
-{
-	seed?: number;
-	spawnDistance?: number;
-	maxTicks?: number;
-}
-
-export interface StepResult
-{
-	gameState: GameState;
-	errors: BotError[];
-	done: boolean;
-}
-
-/**
- * Build the initial pair of internal wizards for a match. Mirrors the
- * inline setup in simulate() so both code paths produce identical state.
- */
-function createInitialWizards(spawnDistance: number): InternalWizardState[]
-{
-	return [
-		{
-			id: 'wizard-1',
-			position: {x: ARENA_WIDTH / 2 - spawnDistance / 2, y: ARENA_HEIGHT / 2},
-			rotation: 0,
-			health: WIZARD_HEALTH,
-			maxHealth: WIZARD_HEALTH,
-			state: 'idle',
-			blinkCooldown: 0,
-			velocity: {x: 0, y: 0},
-			damageDealt: 0,
-			damageTaken: 0,
-			lastHitTick: 0,
-		},
-		{
-			id: 'wizard-2',
-			position: {x: ARENA_WIDTH / 2 + spawnDistance / 2, y: ARENA_HEIGHT / 2},
-			rotation: 180,
-			health: WIZARD_HEALTH,
-			maxHealth: WIZARD_HEALTH,
-			state: 'idle',
-			blinkCooldown: 0,
-			velocity: {x: 0, y: 0},
-			damageDealt: 0,
-			damageTaken: 0,
-			lastHitTick: 0,
-		},
-	];
-}
-
-export class ManualMatch
-{
-	private readonly wizard1AI: WizardFunction;
-	private readonly wizard2AI: WizardFunction;
-	private readonly seed: number;
-	private readonly maxTicks: number;
-	private readonly config: GameConfig;
-
-	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 currentTick = 0;
-	private done = false;
-	private allErrors: BotError[] = [];
-	private history: GameState[];
-
-	constructor(wizard1AI: WizardFunction, wizard2AI: WizardFunction, options: ManualMatchOptions = {})
-	{
-		if (typeof wizard1AI !== 'function')
-		{
-			throw new Error('wizard1AI must be a function');
-		}
-		if (typeof wizard2AI !== 'function')
-		{
-			throw new Error('wizard2AI must be a function');
-		}
-
-		this.wizard1AI = wizard1AI;
-		this.wizard2AI = wizard2AI;
-
-		const {
-			seed: rawSeed = Date.now(),
-			spawnDistance: rawSpawn,
-			maxTicks: rawMaxTicks = MATCH_DURATION,
-		} = options;
-
-		this.seed = Number.isFinite(rawSeed) ? Math.floor(rawSeed) & 0x7FFFFFFF : Date.now() & 0x7FFFFFFF;
-		this.maxTicks = Number.isFinite(rawMaxTicks) && rawMaxTicks > 0
-			? 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)
-			: SPAWN_DISTANCE;
-
-		this.config = Object.freeze({
-			arenaSize: Object.freeze({width: ARENA_WIDTH, height: ARENA_HEIGHT}),
-			tickRate: TICKS_PER_SECOND,
-			maxTicks: this.maxTicks,
-		});
-
-		// Hook state must start clean — bot useState/useRef from a previous
-		// match would otherwise leak in.
-		clearHooks('wizard-1');
-		clearHooks('wizard-2');
-
-		this.wizards = createInitialWizards(spawnDistance);
-		this.history = [getPlayerState(0, this.wizards, this.projectiles, 0)];
-	}
-
-	/**
-	 * Advance the match by `count` ticks (default 1). Stops early if the
-	 * match completes mid-batch.
-	 */
-	step(count = 1): StepResult
-	{
-		const errorsThisCall: BotError[] = [];
-		for (let i = 0; i < count; i++)
-		{
-			if (this.done) break;
-			const result = tick(
-				this.currentTick,
-				this.wizard1AI,
-				this.wizard2AI,
-				this.config,
-				this.wizards,
-				this.projectiles,
-				this.missileAIs,
-				this.seed,
-			);
-			this.currentTick = result.nextTick;
-			this.wizards = result.wizards;
-			this.projectiles = result.projectiles;
-			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));
-
-			if (
-				this.wizards[0]!.health <= 0
-				|| this.wizards[1]!.health <= 0
-				|| this.currentTick >= this.maxTicks
-			)
-			{
-				this.done = true;
-			}
-		}
-
-		return {
-			gameState: this.getGameState(),
-			errors: errorsThisCall,
-			done: this.done,
-		};
-	}
-
-	/**
-	 * Hot-swap a missile's AI function. Used by the missile-hijack 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
-	{
-		const existing = this.missileAIs.get(projectileId);
-		if (!existing) return;
-		if (!this.originalMissileAIs.has(projectileId))
-		{
-			this.originalMissileAIs.set(projectileId, existing);
-		}
-		this.missileAIs.set(projectileId, ai);
-	}
-
-	/**
-	 * Restore a previously hijacked missile's original AI function.
-	 * No-op if the projectile id doesn't exist or was never hijacked.
-	 */
-	restoreMissileAI(projectileId: string): void
-	{
-		const original = this.originalMissileAIs.get(projectileId);
-		if (!original) return;
-		if (!this.missileAIs.has(projectileId)) return;
-		this.missileAIs.set(projectileId, original);
-		this.originalMissileAIs.delete(projectileId);
-	}
-
-	/**
-	 * Set the invincibility flag for a wizard. Invincible wizards take 0
-	 * damage from all sources.
-	 */
-	setInvincible(wizardIndex: 0 | 1, on: boolean): void
-	{
-		const wizard = this.wizards[wizardIndex];
-		if (!wizard) return;
-		wizard.invincible = on;
-	}
-
-	/**
-	 * Get the current game state from wizard-1's perspective.
-	 * Returned object is a deep clone — safe to mutate.
-	 */
-	getGameState(): GameState
-	{
-		return getPlayerState(0, this.wizards, this.projectiles, this.currentTick);
-	}
-
-	getCurrentTick(): number
-	{
-		return this.currentTick;
-	}
-
-	isComplete(): {done: boolean; winner: MatchWinner}
-	{
-		return {done: this.done, winner: this.done ? this.computeWinner() : null};
-	}
-
-	getResult(): SimulateResult
-	{
-		return {
-			winner: this.computeWinner(),
-			ticks: this.currentTick,
-			finalState: this.getGameState(),
-			history: this.history,
-			errors: this.allErrors,
-		};
-	}
-
-	dispose(): void
-	{
-		clearHooks('wizard-1');
-		clearHooks('wizard-2');
-		this.history = [];
-	}
-
-	private computeWinner(): MatchWinner
-	{
-		const w1 = this.wizards[0]!;
-		const w2 = this.wizards[1]!;
-		if (w1.health <= 0 && w2.health <= 0) return 'draw';
-		if (w2.health <= 0) return 'wizard-1';
-		if (w1.health <= 0) return 'wizard-2';
-		return null;
-	}
-}
+/**
+ * VIBEMANCER - MANUAL MATCH
+ *
+ * Tick-by-tick match runner used by manual play mode. Wraps the same
+ * `tick()` primitive that `simulate()` uses, so stepping forward
+ * produces the same trajectory as a batched `simulate()` with the
+ * same seed.
+ *
+ * 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)
+ * - setInvincible(wizardIndex, on) toggles damage immunity per wizard
+ */
+
+import {
+	ARENA_HEIGHT,
+	ARENA_WIDTH,
+	MATCH_DURATION,
+	SPAWN_DISTANCE,
+	TICKS_PER_SECOND,
+	WIZARD_HEALTH,
+} from '../rules.js';
+import type {
+	GameConfig,
+	GameState,
+	MissileAIFunction,
+	ProjectileState,
+	WizardFunction,
+} from '../types.js';
+import {clearHooks} from './hooks-runtime.js';
+import {
+	type BotError,
+	type InternalWizardState,
+	type MatchWinner,
+	type SimulateResult,
+	getPlayerState,
+	tick,
+} from './simulation.js';
+
+export interface ManualMatchOptions
+{
+	seed?: number;
+	spawnDistance?: number;
+	maxTicks?: number;
+}
+
+export interface StepResult
+{
+	gameState: GameState;
+	errors: BotError[];
+	done: boolean;
+}
+
+/**
+ * Build the initial pair of internal wizards for a match. Mirrors the
+ * inline setup in simulate() so both code paths produce identical state.
+ */
+function createInitialWizards(spawnDistance: number): InternalWizardState[]
+{
+	return [
+		{
+			id: 'wizard-1',
+			position: {x: ARENA_WIDTH / 2 - spawnDistance / 2, y: ARENA_HEIGHT / 2},
+			rotation: 0,
+			health: WIZARD_HEALTH,
+			maxHealth: WIZARD_HEALTH,
+			state: 'idle',
+			blinkCooldown: 0,
+			velocity: {x: 0, y: 0},
+			damageDealt: 0,
+			damageTaken: 0,
+			lastHitTick: 0,
+		},
+		{
+			id: 'wizard-2',
+			position: {x: ARENA_WIDTH / 2 + spawnDistance / 2, y: ARENA_HEIGHT / 2},
+			rotation: 180,
+			health: WIZARD_HEALTH,
+			maxHealth: WIZARD_HEALTH,
+			state: 'idle',
+			blinkCooldown: 0,
+			velocity: {x: 0, y: 0},
+			damageDealt: 0,
+			damageTaken: 0,
+			lastHitTick: 0,
+		},
+	];
+}
+
+export class ManualMatch
+{
+	private readonly wizard1AI: WizardFunction;
+	private readonly wizard2AI: WizardFunction;
+	private readonly seed: number;
+	private readonly maxTicks: number;
+	private readonly config: GameConfig;
+
+	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 currentTick = 0;
+	private done = false;
+	private allErrors: BotError[] = [];
+	private history: GameState[];
+
+	constructor(wizard1AI: WizardFunction, wizard2AI: WizardFunction, options: ManualMatchOptions = {})
+	{
+		if (typeof wizard1AI !== 'function')
+		{
+			throw new Error('wizard1AI must be a function');
+		}
+		if (typeof wizard2AI !== 'function')
+		{
+			throw new Error('wizard2AI must be a function');
+		}
+
+		this.wizard1AI = wizard1AI;
+		this.wizard2AI = wizard2AI;
+
+		const {
+			seed: rawSeed = Date.now(),
+			spawnDistance: rawSpawn,
+			maxTicks: rawMaxTicks = MATCH_DURATION,
+		} = options;
+
+		this.seed = Number.isFinite(rawSeed) ? Math.floor(rawSeed) & 0x7FFFFFFF : Date.now() & 0x7FFFFFFF;
+		this.maxTicks = Number.isFinite(rawMaxTicks) && rawMaxTicks > 0
+			? 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)
+			: SPAWN_DISTANCE;
+
+		this.config = Object.freeze({
+			arenaSize: Object.freeze({width: ARENA_WIDTH, height: ARENA_HEIGHT}),
+			tickRate: TICKS_PER_SECOND,
+			maxTicks: this.maxTicks,
+		});
+
+		// Hook state must start clean — bot useState/useRef from a previous
+		// match would otherwise leak in.
+		clearHooks('wizard-1');
+		clearHooks('wizard-2');
+
+		this.wizards = createInitialWizards(spawnDistance);
+		this.history = [getPlayerState(0, this.wizards, this.projectiles, 0)];
+	}
+
+	/**
+	 * Advance the match by `count` ticks (default 1). Stops early if the
+	 * match completes mid-batch.
+	 */
+	step(count = 1): StepResult
+	{
+		const errorsThisCall: BotError[] = [];
+		for (let i = 0; i < count; i++)
+		{
+			if (this.done) break;
+			const result = tick(
+				this.currentTick,
+				this.wizard1AI,
+				this.wizard2AI,
+				this.config,
+				this.wizards,
+				this.projectiles,
+				this.missileAIs,
+				this.seed,
+			);
+			this.currentTick = result.nextTick;
+			this.wizards = result.wizards;
+			this.projectiles = result.projectiles;
+			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));
+
+			if (
+				this.wizards[0]!.health <= 0
+				|| this.wizards[1]!.health <= 0
+				|| this.currentTick >= this.maxTicks
+			)
+			{
+				this.done = true;
+			}
+		}
+
+		return {
+			gameState: this.getGameState(),
+			errors: errorsThisCall,
+			done: this.done,
+		};
+	}
+
+	/**
+	 * Hot-swap a missile's AI function. Used by the missile-hijack 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
+	{
+		const existing = this.missileAIs.get(projectileId);
+		if (!existing) return;
+		if (!this.originalMissileAIs.has(projectileId))
+		{
+			this.originalMissileAIs.set(projectileId, existing);
+		}
+		this.missileAIs.set(projectileId, ai);
+	}
+
+	/**
+	 * Restore a previously hijacked missile's original AI function.
+	 * No-op if the projectile id doesn't exist or was never hijacked.
+	 */
+	restoreMissileAI(projectileId: string): void
+	{
+		const original = this.originalMissileAIs.get(projectileId);
+		if (!original) return;
+		if (!this.missileAIs.has(projectileId)) return;
+		this.missileAIs.set(projectileId, original);
+		this.originalMissileAIs.delete(projectileId);
+	}
+
+	/**
+	 * Set the invincibility flag for a wizard. Invincible wizards take 0
+	 * damage from all sources.
+	 */
+	setInvincible(wizardIndex: 0 | 1, on: boolean): void
+	{
+		const wizard = this.wizards[wizardIndex];
+		if (!wizard) return;
+		wizard.invincible = on;
+	}
+
+	/**
+	 * Get the current game state from wizard-1's perspective.
+	 * Returned object is a deep clone — safe to mutate.
+	 */
+	getGameState(): GameState
+	{
+		return getPlayerState(0, this.wizards, this.projectiles, this.currentTick);
+	}
+
+	getCurrentTick(): number
+	{
+		return this.currentTick;
+	}
+
+	isComplete(): {done: boolean; winner: MatchWinner}
+	{
+		return {done: this.done, winner: this.done ? this.computeWinner() : null};
+	}
+
+	getResult(): SimulateResult
+	{
+		return {
+			winner: this.computeWinner(),
+			ticks: this.currentTick,
+			finalState: this.getGameState(),
+			history: this.history,
+			errors: this.allErrors,
+		};
+	}
+
+	dispose(): void
+	{
+		clearHooks('wizard-1');
+		clearHooks('wizard-2');
+		this.history = [];
+	}
+
+	private computeWinner(): MatchWinner
+	{
+		const w1 = this.wizards[0]!;
+		const w2 = this.wizards[1]!;
+		if (w1.health <= 0 && w2.health <= 0) return 'draw';
+		if (w2.health <= 0) return 'wizard-1';
+		if (w1.health <= 0) return 'wizard-2';
+		return null;
+	}
+}