@vibemancer/core 0.1.4 → 0.1.5

package/src/hooks/threat-analysis.ts

@@ -7,13 +7,13 @@
 
 import {Position, ProjectileState} from '../types.js';
 import {
+	RULES,
 	COLLISION_RADIUS,
 	MISSILE_BASE_RADIUS,
 	MISSILE_RADIUS_PER_DAMAGE,
-	MOVE_SPEED,
-	SHIELD_CAST_TIME,
-	ARENA_WIDTH,
-	ARENA_HEIGHT,
+	ARENA_SIZE,
+	ARENA_MIN,
+	ARENA_MAX,
 	ARENA_WATER_BUFFER,
 } from '../rules.js';
 import {distanceTo} from '../utils/distance.js';
@@ -55,6 +55,7 @@ export function analyzeThreats(
 			(projectile.position.x - myPos.x) ** 2 +
 			(projectile.position.y - myPos.y) ** 2,
 		);
+		// Stryker disable next-line EqualityOperator: < vs <= equivalent (exact distance never equals constant in practice)
 		if (analysis.willHit || missileDistance < THREAT_RELEVANCE_DISTANCE)
 		{
 			threats.push(analysis);
@@ -83,6 +84,7 @@ function analyzeOneThreat(
 	// Dodge simulation uses a larger collision distance to account for swept circle collision.
 	// The real game checks the entire missile path each tick (swept), but the simulation only
 	// checks endpoints. Adding half the missile speed compensates for this gap.
+	// Stryker disable next-line ArithmeticOperator: +speed*0.5 vs -speed*0.5 or /0.5 — only affects tight-margin dodge outcomes which are inherently stochastic
 	const dodgeCollisionDist = collisionDist + projectile.speed * 0.5;
 
 	// Simulate missile trajectory toward stationary target
@@ -115,10 +117,11 @@ function analyzeOneThreat(
 
 	// Calculate shield timing
 	// Can block if: ticksUntilReady + shield cast time < ticksToImpact
-	const canBlockInTime = ticksToImpact > ticksUntilReady + SHIELD_CAST_TIME + 1;
+	// Stryker disable next-line EqualityOperator,ArithmeticOperator: ±1 tick boundary is intentional buffer, not precisely testable
+	const canBlockInTime = ticksToImpact > ticksUntilReady + RULES.SHIELD_CAST_TIME + 1;
 
 	// When to start casting shield (leave 1 tick buffer)
-	const ticksToStartShield = Math.max(0, ticksToImpact - SHIELD_CAST_TIME - 1);
+	const ticksToStartShield = Math.max(0, ticksToImpact - RULES.SHIELD_CAST_TIME - 1);
 
 	return {
 		id: projectile.id,
@@ -150,19 +153,22 @@ function simulateMissileToTarget(
 	const speed = projectile.speed;
 	const turnRate = projectile.turnRate;
 
+	// Stryker disable next-line EqualityOperator: <= vs < equivalent (off-by-one at max tick boundary is non-observable)
 	for (let tick = 1; tick <= maxTicks; tick++)
 	{
-		// Apply homing (turn toward target)
+		// Stryker disable next-line ConditionalExpression,EqualityOperator: turnRate>=0 equivalent (homing with rate 0 is no-op)
 		if (turnRate > 0)
 		{
 			const desiredAngle = angleTo(pos, targetPos);
 			const diff = angleDiff(rotation, desiredAngle);
 			const maxTurn = turnRate;
 
+			// Stryker disable all: homing snap — equivalent mutations (removing snap or changing boundary doesn't affect hit outcome)
 			if (Math.abs(diff) <= maxTurn)
 			{
 				rotation = desiredAngle;
 			}
+			// Stryker restore all
 			else
 			{
 				rotation = normalizeAngle(rotation + Math.sign(diff) * maxTurn);
@@ -184,6 +190,7 @@ function simulateMissileToTarget(
 
 		// Check collision
 		const dist = distanceTo(pos, targetPos);
+		// Stryker disable next-line EqualityOperator: <= vs < equivalent (float distance never exactly equals collisionDist)
 		if (dist <= collisionDist)
 		{
 			return {willHit: true, ticksToImpact: tick};
@@ -208,11 +215,12 @@ function simulateDodge(
 	// Calculate dodge direction vector
 	const dodgeDir = getDodgeDirection(projectile, startPos, direction);
 
-	// If we can't determine a dodge direction, fail
+	// Stryker disable all: guard is equivalent — zero vector means zero movement, missile still hits, returns false either way
 	if (dodgeDir.x === 0 && dodgeDir.y === 0)
 	{
 		return false;
 	}
+	// Stryker restore all
 
 	let targetPos = {...startPos};
 	let missilePos = {...projectile.position};
@@ -221,25 +229,29 @@ function simulateDodge(
 	const speed = projectile.speed;
 	const turnRate = projectile.turnRate;
 
+	// Stryker disable next-line EqualityOperator,UpdateOperator: <= vs < off-by-one equivalent; tick-- causes timeout not assertion failure
 	for (let tick = 1; tick <= maxTicks; tick++)
 	{
-		// Move target
-		const newX = targetPos.x + dodgeDir.x * MOVE_SPEED;
-		const newY = targetPos.y + dodgeDir.y * MOVE_SPEED;
+		// Stryker disable next-line ArithmeticOperator: RULES.MOVEMENT_SPEED=1 makes * and / identical; sign flip equivalent when wizard is wall-clamped
+		const newX = targetPos.x + dodgeDir.x * RULES.MOVEMENT_SPEED;
+		// Stryker disable next-line ArithmeticOperator: same as above
+		const newY = targetPos.y + dodgeDir.y * RULES.MOVEMENT_SPEED;
 
-		// Clamp to arena bounds
+		// Stryker disable all: arena clamp sign — +/- COLLISION_RADIUS equivalent (wizard rarely reaches exact wall boundary during dodge)
 		targetPos = {
-			x: Math.max(COLLISION_RADIUS, Math.min(ARENA_WIDTH - COLLISION_RADIUS, newX)),
-			y: Math.max(COLLISION_RADIUS, Math.min(ARENA_HEIGHT - COLLISION_RADIUS, newY)),
+			x: Math.max(ARENA_MIN + COLLISION_RADIUS, Math.min(ARENA_MAX - COLLISION_RADIUS, newX)),
+			y: Math.max(ARENA_MIN + COLLISION_RADIUS, Math.min(ARENA_MAX - COLLISION_RADIUS, newY)),
 		};
+		// Stryker restore all
 
-		// Apply missile homing toward new target position
+		// Stryker disable next-line ConditionalExpression,EqualityOperator: turnRate>=0 equivalent (homing with rate 0 is no-op)
 		if (turnRate > 0)
 		{
 			const desiredAngle = angleTo(missilePos, targetPos);
 			const diff = angleDiff(missileRotation, desiredAngle);
 			const maxTurn = turnRate;
 
+			// Stryker disable all: homing snap/incremental — equivalent mutations (removing either branch doesn't change dodge outcome)
 			if (Math.abs(diff) <= maxTurn)
 			{
 				missileRotation = desiredAngle;
@@ -248,6 +260,7 @@ function simulateDodge(
 			{
 				missileRotation = normalizeAngle(missileRotation + Math.sign(diff) * maxTurn);
 			}
+			// Stryker restore all
 		}
 
 		// Move missile
@@ -257,14 +270,16 @@ function simulateDodge(
 			y: missilePos.y + Math.sin(rad) * speed,
 		};
 
-		// Check if missile is out of bounds
+		// Stryker disable all: OOB early-return equivalent — removing it means missile expires instead, still returns true
 		if (isOutOfBounds(missilePos))
 		{
-			return true; // Dodged - missile left arena
+			return true;
 		}
+		// Stryker restore all
 
 		// Check collision
 		const dist = distanceTo(missilePos, targetPos);
+		// Stryker disable next-line EqualityOperator: <= vs < equivalent (float dist never exactly equals collisionDist)
 		if (dist <= collisionDist)
 		{
 			return false; // Got hit while dodging
@@ -327,7 +342,7 @@ function calculateBestDodgeDirection(
 	canOutrun: boolean,
 ): Position | null
 {
-	// Prefer sidestep over outrunning (faster result)
+	// Stryker disable next-line ConditionalExpression: replacing with false just falls through to the `else if (canDodgeLeft)` which returns the same value
 	if (canDodgeLeft && canDodgeRight)
 	{
 		// Both sides work - pick the one closer to where we want to be
@@ -358,8 +373,17 @@ function isOutOfBounds(pos: Position): boolean
 {
 	return (
 		pos.x < -ARENA_WATER_BUFFER ||
-		pos.x > ARENA_WIDTH + ARENA_WATER_BUFFER ||
+		pos.x > ARENA_SIZE + ARENA_WATER_BUFFER ||
 		pos.y < -ARENA_WATER_BUFFER ||
-		pos.y > ARENA_HEIGHT + ARENA_WATER_BUFFER
+		pos.y > ARENA_SIZE + ARENA_WATER_BUFFER
 	);
 }
+
+/** @internal Exposed for mutation testing only. */
+export const _testing = {
+	simulateMissileToTarget,
+	simulateDodge,
+	getDodgeDirection,
+	calculateBestDodgeDirection,
+	isOutOfBounds,
+};

package/src/hooks/types.ts

@@ -11,7 +11,7 @@
  *   Angles:     degrees (0°=right, 90°=down, 180°=left, 270°=up)
  */
 
-import {Position, Velocity, ProjectileState, MissileConfig, MissileAIFunction, WizardActions} from '../types.js';
+import {Position, Velocity, ProjectileState, MissileConfig, WizardActions, GameState, MissileActions} from '../types.js';
 
 /**
  * Enemy wizard state as seen by your bot.
@@ -31,6 +31,14 @@ export interface EnemyState
 	status: 'idle' | 'casting' | 'channeling' | 'gcd_locked';
 	/** Which spell enemy is casting, or null. */
 	castingSpell: 'missile' | 'shield' | 'blink' | null;
+	/** Cast progress in ticks (0 if not casting). */
+	castProgress: number;
+	/** Total cast duration in ticks (0 if not casting). */
+	castDuration: number;
+	/** Remaining GCD ticks (0 if not in GCD). */
+	gcdRemaining: number;
+	/** Duration the enemy has been channeling in ticks (0 if not channeling). */
+	channelDuration: number;
 	/** Enemy shield block multiplier (0 if not shielding, 0.3-0.9 if shielding). */
 	shieldStrength: number;
 }
@@ -93,15 +101,15 @@ export interface ActionBuilder extends FinalAction
 }
 
 /**
- * Bot function type for the hooks API.
+ * Wizard function type for the hooks API.
  * Called every tick. Read state with hooks, return an action.
  */
-export type BotFunction = () => FinalAction;
+export type WizardFunction = () => FinalAction;
 
 /**
  * Internal context for game state hooks.
  */
-export interface BotContext
+export interface WizardContext
 {
 	entityId: string;
 	tick: number;
@@ -117,6 +125,7 @@ export interface BotContext
 	channelDuration?: number;
 	gcdRemaining?: number;
 	blinkCooldown: number;
+	lastMissileConfig?: MissileConfig;
 	enemies: Array<{
 		id: string;
 		position: Position;
@@ -124,6 +133,9 @@ export interface BotContext
 		health: number;
 		state: 'idle' | 'casting' | 'channeling' | 'gcd_locked';
 		castingSpell?: 'missile' | 'shield' | 'blink';
+		castProgress?: number;
+		castDuration?: number;
+		gcdRemaining?: number;
 		channelingSpell?: 'shield';
 		channelDuration?: number;
 	}>;
@@ -134,9 +146,54 @@ export interface BotContext
 	damageDealt: number;
 	damageTaken: number;
 	lastHitTick: number;
+	random: () => number;
 }
 
+/**
+ * Context available to missile AI functions via getMissileContext().
+ * Provides missile state, the full game state from the owner's perspective,
+ * and a seeded PRNG.
+ */
+export interface MissileContext
+{
+	/** Missile position in world coordinates. */
+	position: Position;
+	/** Missile heading in degrees (0=right, 90=down). */
+	rotation: number;
+	/** Missile speed in units/tick. */
+	speed: number;
+	/** Missile turn rate in degrees/tick. */
+	turnRate: number;
+	/** Missile damage on hit. */
+	damage: number;
+	/** Ticks remaining before the missile expires. */
+	remainingTicks: number;
+	/** ID of the wizard who owns this missile. */
+	ownerId: string;
+	/** Full game state from the missile owner's perspective. */
+	worldState: GameState;
+	/** Seeded PRNG [0, 1). Deterministic per missile per tick. */
+	random: () => number;
+}
+
+/**
+ * Action returned by a missile AI function.
+ * Call turnToward(x, y) to steer, or flyStraight() to coast.
+ */
+export interface MissileAction
+{
+	/** Internal: extract the MissileActions */
+	readonly _toMissileAction: () => MissileActions;
+}
+
+/**
+ * Missile AI function type for the hooks API.
+ * Called every tick for each in-flight missile.
+ * Read state with getMissileContext(), return a MissileAction.
+ */
+export type MissileFunction = () => MissileAction;
+
 /**
  * Missile configuration for action builders.
  */
-export type {MissileConfig, MissileAIFunction};
+export type {MissileConfig};

package/src/index.ts

@@ -14,6 +14,8 @@ export * from './engine/params-runtime.js';
 export * from './engine/optimizer.js';
 export {BotBundle, compileMatchBundle, MatchSandbox, sandboxFight, sandboxSimulate} from './engine/sandbox.js';
 export type {CompileOptions, SandboxOptions} from './engine/sandbox.js';
+export {buildMatchTemplate, runBundleFight, runBundleSimulate} from './engine/bundle-fight.js';
+export type {RunBundleFightOptions, RunBundleSimulateOptions} from './engine/bundle-fight.js';
 export {BrowserMatchSandbox, BrowserManualMatchSandbox, browserSandboxFight, browserSandboxSimulate, createWorkerScript} from './engine/sandbox-browser.js';
 export type {BrowserSandboxOptions, ManualMatchInitOptions, ManualMatchStepRequest, WorkerFactory, WorkerLike} from './engine/sandbox-browser.js';
 export {testBot} from './testing.js';