@vibemancer/core 0.1.3 → 0.1.5

package/src/engine/optimizer.ts

@@ -17,7 +17,7 @@
 
 import type {ParamDeclaration} from './params-runtime.js';
 import type {FightResult} from './simulation.js';
-import {WIZARD_HEALTH} from '../rules.js';
+import {RULES} from '../rules.js';
 
 /**
  * Compute the effective min/max search window for a parameter.
@@ -169,7 +169,7 @@ export function scoreFight(result: FightResult): number
 		if (match.winner === 'wizard-1')
 		{
 			// Won: 3.0 base + HP bonus
-			score += 3.0 + (match.finalState.health / WIZARD_HEALTH) * 0.5;
+			score += 3.0 + (match.finalState.health / RULES.WIZARD_HEALTH) * 0.5;
 		}
 		else if (match.winner === 'draw' || match.winner === null)
 		{
@@ -178,8 +178,8 @@ export function scoreFight(result: FightResult): number
 		else
 		{
 			// Lost: small bonus for low enemy HP
-			const enemyHP = match.finalState.enemies[0]?.health ?? WIZARD_HEALTH;
-			score += (1 - enemyHP / WIZARD_HEALTH) * 0.5;
+			const enemyHP = match.finalState.enemies[0]?.health ?? RULES.WIZARD_HEALTH;
+			score += (1 - enemyHP / RULES.WIZARD_HEALTH) * 0.5;
 		}
 	}
 
@@ -201,8 +201,8 @@ export function scoreFightAsWizard2(result: FightResult): number
 		if (match.winner === 'wizard-2')
 		{
 			// Won: 3.0 base + HP bonus (wizard-2's remaining HP)
-			const hp = match.finalState.enemies[0]?.health ?? WIZARD_HEALTH;
-			score += 3.0 + (hp / WIZARD_HEALTH) * 0.5;
+			const hp = match.finalState.enemies[0]?.health ?? RULES.WIZARD_HEALTH;
+			score += 3.0 + (hp / RULES.WIZARD_HEALTH) * 0.5;
 		}
 		else if (match.winner === 'draw' || match.winner === null)
 		{
@@ -212,7 +212,7 @@ export function scoreFightAsWizard2(result: FightResult): number
 		{
 			// Lost: small bonus for low wizard-1 HP
 			const enemyHP = match.finalState.health;
-			score += (1 - enemyHP / WIZARD_HEALTH) * 0.5;
+			score += (1 - enemyHP / RULES.WIZARD_HEALTH) * 0.5;
 		}
 	}
 

package/src/engine/params-runtime.ts

@@ -50,7 +50,7 @@
  * - Violations are detected and throw errors
  */
 
-import type {WizardFunction} from '../types.js';
+import type {WizardFunction} from '../hooks/types.js';
 import {validateHookCall} from './hooks-runtime.js';
 
 /**
@@ -174,12 +174,12 @@ export function stopDiscovery(): ParamDeclaration[]
  */
 export function wrapWithParams(bot: WizardFunction, params: Record<string, number>): WizardFunction
 {
-	return (props) =>
+	return () =>
 	{
 		setParamValues(params);
 		try
 		{
-			return bot(props);
+			return bot();
 		}
 		finally
 		{

package/src/engine/physics.ts

@@ -1,38 +1,29 @@
 import {Position, WizardState, ProjectileState} from '../types.js';
-import {ARENA_WIDTH, ARENA_HEIGHT, MOVEMENT_SPEED, CASTING_MOVEMENT_MULT, WIZARD_RADIUS} from '../rules.js';
+import {RULES, ARENA_SIZE, WIZARD_RADIUS, ARENA_MIN, ARENA_MAX} from '../rules.js';
 
 /**
  * Move a wizard based on world-space input direction.
  *
- * Movement model (from design doc):
- * - x: +100 = right, -100 = left
- * - y: +100 = down, -100 = up
- * - Values are clamped to [-100, 100]
- * - Diagonal movement is normalized (magnitude capped at 100)
- * - No rotation tracking - just output (x, y) direction
+ * Any vector works: direction is preserved, speed is clamped to [0, 1].
+ * (0.5, 0) = half speed right. (300, 200) = full speed at 33.7°.
  */
 export function moveWizard(wizard: WizardState, move: {x: number; y: number}, deltaTicks: number): Position
 {
-	// Clamp input values to [-100, 100]
-	let dx = Math.max(-100, Math.min(100, move.x || 0));
-	let dy = Math.max(-100, Math.min(100, move.y || 0));
+	let dx = move.x || 0;
+	let dy = move.y || 0;
 
-	// Normalize diagonal movement (cap magnitude at 100)
 	const magnitude = Math.sqrt(dx * dx + dy * dy);
-	if (magnitude > 100)
+	// Stryker disable next-line EqualityOperator: > vs >= equivalent (dividing by exactly 1 is identity)
+	if (magnitude > 1)
 	{
-		dx = dx * 100 / magnitude;
-		dy = dy * 100 / magnitude;
+		dx = dx / magnitude;
+		dy = dy / magnitude;
 	}
 
-	// Convert from [-100, 100] to [-1, 1] direction
-	dx = dx / 100;
-	dy = dy / 100;
-
-	let speed = MOVEMENT_SPEED;
+	let speed = RULES.MOVEMENT_SPEED;
 	if (wizard.state === 'casting')
 	{
-		speed *= CASTING_MOVEMENT_MULT;
+		speed *= RULES.CASTING_MOVEMENT_MULT;
 	}
 	else if (wizard.state === 'channeling')
 	{
@@ -61,16 +52,31 @@ export function moveProjectile(projectile: ProjectileState, deltaTicks: number):
 }
 
 /**
- * Clamp a position to the arena boundaries.
+ * Clamp a position to the full arena bounds (0-860).
+ * No playfield clamping — wizards CAN walk/blink into lava.
  */
 export function clampToArena(position: Position, radius: number): Position
 {
 	return {
-		x: Math.max(radius, Math.min(ARENA_WIDTH - radius, position.x)),
-		y: Math.max(radius, Math.min(ARENA_HEIGHT - radius, position.y)),
+		x: Math.max(radius, Math.min(ARENA_SIZE - radius, position.x)),
+		y: Math.max(radius, Math.min(ARENA_SIZE - radius, position.y)),
 	};
 }
 
+/**
+ * Check if a position is in the lava zone (outside the playfield).
+ * Lava zones: [0, ARENA_MIN] and [ARENA_MAX, ARENA_SIZE] on each axis.
+ */
+export function isInLava(position: Position, radius: number): boolean
+{
+	return (
+		position.x - radius < ARENA_MIN ||
+		position.x + radius > ARENA_MAX ||
+		position.y - radius < ARENA_MIN ||
+		position.y + radius > ARENA_MAX
+	);
+}
+
 /**
  * Resolve body collision between two wizards.
  * Pushes both apart equally so they don't overlap. Neither is blocked — they just can't stack.
@@ -81,12 +87,14 @@ export function resolveWizardCollision(wizard1: WizardState, wizard2: WizardStat
 	const minDist = WIZARD_RADIUS * 2;
 	const maxIterations = 5; // Prevents infinite loops in edge cases
 
+	// Stryker disable next-line EqualityOperator: < vs <= equivalent (one extra iteration produces same result)
 	for (let i = 0; i < maxIterations; i++)
 	{
 		const dx = wizard2.position.x - wizard1.position.x;
 		const dy = wizard2.position.y - wizard1.position.y;
 		const dist = Math.sqrt(dx * dx + dy * dy);
 
+		// Stryker disable next-line EqualityOperator: >= vs > equivalent (at exactly minDist, no push needed either way)
 		if (dist >= minDist) return; // No overlap — done
 
 		if (dist === 0)
@@ -128,6 +136,7 @@ export function sweptCircleCollision(oldPos: Position, newPos: Position, radius:
 	if (d2 === 0)
 	{
 		const dist2 = (oldPos.x - targetPos.x) ** 2 + (oldPos.y - targetPos.y) ** 2;
+		// Stryker disable next-line EqualityOperator: <= vs < equivalent (exact equality of float dist² and integer radius² is vanishingly rare)
 		return dist2 <= totalRadius * totalRadius;
 	}
 
@@ -139,5 +148,6 @@ export function sweptCircleCollision(oldPos: Position, newPos: Position, radius:
 	const closestY = oldPos.y + t * dy;
 
 	const dist2 = (targetPos.x - closestX) ** 2 + (targetPos.y - closestY) ** 2;
+	// Stryker disable next-line EqualityOperator: <= vs < equivalent (float dist² rarely equals exact integer radius²)
 	return dist2 <= totalRadius * totalRadius;
 }

package/src/engine/sandbox-browser.ts

@@ -19,7 +19,8 @@
  * NOTE: This file has ZERO Node.js dependencies. It works in any JS environment.
  */
 
-import type {GameState, MissileAIFunction, ProjectileState, WizardActions} from '../types.js';
+import type {GameState, ProjectileState, WizardActions} from '../types.js';
+import type {MissileFunction} from '../hooks/types.js';
 import type {BotError, FightResult, MatchWinner, SimulateResult} from './simulation.js';
 import type {StepResult} from './manual-match.js';
 
@@ -580,7 +581,7 @@ export class BrowserManualMatchSandbox
 
 	/**
 	 * Advance the match by `request.count` ticks (default 1), updating
-	 * the player's human actions and any hijacked missile targets first.
+	 * the player's human actions and any guided missile targets first.
 	 */
 	async step(request: ManualMatchStepRequest = {}): Promise<StepResult>
 	{
@@ -589,18 +590,18 @@ export class BrowserManualMatchSandbox
 	}
 
 	/**
-	 * Replace a missile's AI with a worker-local hijack stub that reads
+	 * Replace a missile's AI with a worker-local guide stub that reads
 	 * from `latestHumanMissileTargets[projectileId]`. Subsequent step()
 	 * calls with `humanMissileTargets` populated for this id steer the
 	 * missile.
 	 */
-	async hijackMissile(projectileId: string): Promise<void>
+	async guideMissile(projectileId: string): Promise<void>
 	{
-		await this.inner.callRaw('manualMatchHijack', {projectileId});
+		await this.inner.callRaw('manualMatchGuide', {projectileId});
 	}
 
 	/**
-	 * Restore a hijacked missile's original AI.
+	 * Restore a guided missile's original AI.
 	 */
 	async releaseMissile(projectileId: string): Promise<void>
 	{
@@ -664,7 +665,7 @@ export type {
 	BotError,
 	GameState,
 	MatchWinner,
-	MissileAIFunction,
+	MissileFunction,
 	ProjectileState,
 	StepResult,
 	WizardActions,

package/src/engine/sandbox-compile.ts

@@ -148,7 +148,7 @@ export async function compileMatchBundle(
  * the host).
  *
  * Returns a plain JS string that, when loaded into a Web Worker, exposes the
- * `__manualMatchInit`, `__manualMatchStep`, `__manualMatchHijack`,
+ * `__manualMatchInit`, `__manualMatchStep`, `__manualMatchGuide`,
  * `__manualMatchRelease`, `__manualMatchSetInvincible`,
  * `__manualMatchGetState`, `__manualMatchGetResult`, and `__manualMatchDispose`
  * globals on the worker's globalThis.