@vibemancer/core 0.1.4 → 0.1.5

package/src/types.ts

@@ -104,6 +104,9 @@ export interface GameState
 	damageDealt: number;   // total damage dealt this match
 	damageTaken: number;   // total damage taken this match
 	lastHitTick: number;   // tick when last took damage (0 if never)
+
+	/** Events emitted during the most recent tick (empty for the initial state). */
+	events: SimEvent[];
 }
 
 /**
@@ -133,7 +136,7 @@ export interface WizardActions
 	startCast?: {
 		spell: 'missile';
 		config: MissileConfig;
-		missileAI: MissileAIFunction;
+		missileAI: MissileFunction;
 		direction?: number; // initial rotation override (auto-aims at enemy by default)
 	} | {
 		spell: 'shield';
@@ -153,6 +156,20 @@ export interface WizardActions
 	 * Only applies while state === 'casting' and castingSpell === 'missile'.
 	 */
 	aimDirection?: number;
+
+	/**
+	 * Missile guide — manual play mode only. Takes direct control of a
+	 * specific missile using WASD/joystick input. While active, the wizard
+	 * is invulnerable and frozen (move ignored), and the missile steers
+	 * using its turnRate toward the given direction.
+	 *
+	 * direction: {x, y} → converted to target angle via atan2(y, x)
+	 * direction: null   → missile flies straight (no steering input)
+	 */
+	missileGuide?: {
+		missileId: string;
+		direction: {x: number; y: number} | null;
+	} | null;
 }
 
 /**
@@ -167,27 +184,123 @@ export interface MissileConfig
 }
 
 /**
- * Missile AI function type.
+ * Missile AI function type — re-exported from hooks/types.ts.
  */
-export type MissileAIFunction = (props: {
-	missileState: ProjectileState;
-	worldState: GameState;
-	random: () => number; // Seeded PRNG, isolated per entity, 0-1 range
-}) => MissileActions;
+type MissileFunction = import('./hooks/types.js').MissileFunction;
 
 /**
  * Actions returned by missile each tick.
  */
 export interface MissileActions
 {
-	turnToward?: Position; // engine handles turn rate limit
+	turnToward?: Position;
+	turnToAngle?: number;
+}
+
+// ============================================================
+// GAME EVENTS
+// ============================================================
+
+export interface MissileHitEvent
+{
+	type: 'missile-hit';
+	position: Position;
+	damage: number;
+	actualDamage: number;
+	speed: number;
+	ownerId: string;
+	targetId: string;
+}
+
+export interface MissileExpiredEvent
+{
+	type: 'missile-expired';
+	position: Position;
+}
+
+export interface MissileOobEvent
+{
+	type: 'missile-oob';
+	position: Position;
+}
+
+export interface BlinkEvent
+{
+	type: 'blink';
+	wizardId: string;
+	from: Position;
+	to: Position;
+}
+
+export interface ShieldStartEvent
+{
+	type: 'shield-start';
+	wizardId: string;
+	position: Position;
+}
+
+export interface CastStartEvent
+{
+	type: 'cast-start';
+	wizardId: string;
+	position: Position;
+	spell: 'missile' | 'shield' | 'blink';
+}
+
+export interface WizardDeathEvent
+{
+	type: 'wizard-death';
+	wizardId: string;
+	position: Position;
+}
+
+export interface WizardLavaDeathEvent
+{
+	type: 'wizard-lava-death';
+	wizardId: string;
+	position: Position;
 }
 
+export interface CastCancelEvent
+{
+	type: 'cast-cancel';
+	wizardId: string;
+	position: Position;
+	spell: 'missile' | 'shield' | 'blink';
+}
+
+export interface MissileLaunchEvent
+{
+	type: 'missile-launch';
+	position: Position;
+	damage: number;
+	speed: number;
+	ownerId: string;
+	rotation: number;
+}
+
+export interface ShieldBlockEvent
+{
+	type: 'shield-block';
+	wizardId: string;
+	position: Position;
+	damageBlocked: number;
+	damageThrough: number;
+}
+
+export type SimEvent =
+	| MissileHitEvent
+	| MissileExpiredEvent
+	| MissileOobEvent
+	| MissileLaunchEvent
+	| BlinkEvent
+	| ShieldStartEvent
+	| ShieldBlockEvent
+	| CastStartEvent
+	| CastCancelEvent
+	| WizardDeathEvent
+	| WizardLavaDeathEvent;
+
 /**
- * Main wizard function type.
+ * @deprecated Use WizardFunction from hooks/types.ts instead.
  */
-export type WizardFunction = (props: {
-	state: GameState;
-	config: GameConfig;
-	random: () => number; // Seeded PRNG, isolated per entity, 0-1 range
-}) => WizardActions;

package/src/utils/angles.ts

@@ -30,6 +30,7 @@ export function normalizeAngle(angle: number): number
  */
 export function angleDiff(angleA: number, angleB: number): number
 {
+	// Stryker disable next-line ArithmeticOperator: +180 vs -180 in modular arithmetic produces identical results for all inputs
 	let diff = (angleB - angleA + 180) % 360 - 180;
 	if (diff < -180)
 	{

package/src/utils/combat.ts

@@ -10,6 +10,8 @@ import {
 	calculateWarmupMultiplier,
 	validateMissileConfig,
 	TICKS_PER_SECOND,
+	MOVEMENT_SPEED,
+	CASTING_MOVEMENT_MULT,
 	WIZARD_HEALTH,
 	MISSILE_BASE_CAST,
 	MISSILE_DAMAGE_SCALE,
@@ -21,6 +23,7 @@ import {
 	MISSILE_MIN_CAST_TIME,
 	MISSILE_MIN_DURATION,
 	MISSILE_MIN_DAMAGE,
+	WIZARD_RADIUS,
 	effectiveTurnRateCost,
 } from '../rules.js';
 
@@ -172,12 +175,61 @@ export function getAdaptiveMissileConfig(
  * If `lastMissileConfig` is provided, accounts for warmup bonus: similar
  * missiles cast faster, so more damage can fit in the same budget.
  */
+/**
+ * Simulate a missile trajectory to find the minimum duration (ticks) needed
+ * to reach a target at the given distance. Works for all turnRate values:
+ * positive (homing) and zero (straight).
+ *
+ * The simulation starts the missile aimed directly at the target and steps
+ * through the trajectory tick by tick. For homing, the missile tracks the
+ * target each tick matching the engine's steering physics.
+ */
+/**
+ * Simulate a missile trajectory to find the minimum duration (ticks) needed
+ * to reach a target at the given distance. Works for straight (turnRate=0)
+ * and homing (turnRate>0) missiles.
+ *
+ * The missile starts aimed directly at the target at (dist, 0) and steps
+ * through the trajectory tick by tick. For homing, the missile tracks the
+ * target each tick matching the engine's steering physics.
+ *
+ * Returns 500 if the missile cannot reach the target within 500 ticks.
+ */
+export function simulateMinDuration(speed: number, turnRateDeg: number, dist: number, collisionRadius?: number): number
+{
+	if (dist <= 0) return 1;
+	const hitR = collisionRadius ?? (WIZARD_RADIUS + 8);
+	if (turnRateDeg === 0)
+	{
+		return Math.max(1, Math.ceil((dist - hitR) / speed));
+	}
+	const maxTurn = Math.abs(turnRateDeg) * Math.PI / 180;
+	let angle = 0;
+	let x = 0;
+	let y = 0;
+	for (let t = 1; t <= 500; t++)
+	{
+		const targetAngle = Math.atan2(-y, dist - x);
+		let diff = targetAngle - angle;
+		while (diff > Math.PI) diff -= 2 * Math.PI;
+		while (diff < -Math.PI) diff += 2 * Math.PI;
+		const turn = Math.max(-maxTurn, Math.min(maxTurn, diff));
+		angle += turn;
+		x += Math.cos(angle) * speed;
+		y += Math.sin(angle) * speed;
+		const d = Math.sqrt((x - dist) * (x - dist) + y * y);
+		if (d <= hitR) return t;
+	}
+	return 500;
+}
+
 export function fitMissileToBudget(
 	budgetTicks: number,
 	distance: number,
 	options?: {minTurnRate?: number; maxDamage?: number; lastMissileConfig?: MissileConfig},
 ): MissileConfig | null
 {
+
 	const budgetSec = budgetTicks / TICKS_PER_SECOND;
 	const minTurnRate = options?.minTurnRate ?? 0;
 	const maxDamage = options?.maxDamage ?? WIZARD_HEALTH;
@@ -195,10 +247,7 @@ export function fitMissileToBudget(
 
 	// Templates: [speed, turnRate] combos to try, ordered by preference.
 	// Lower turnRate = cheaper cast. Higher speed = shorter duration needed.
-	// Negative turnRate = anti-homing (turns away from target) but cheaper cast time.
 	const templates: [number, number][] = [
-		[7, -1],  // Fast anti-homing: cheapest cast, curves away from target
-		[7, -0.5],// Fast light anti-homing
 		[7, 0],   // Fast straight: cheapest cast, only hits stationary
 		[5, 0],   // Medium straight
 		[6, 0.5], // Fast with light tracking
@@ -214,11 +263,9 @@ export function fitMissileToBudget(
 	for (const [speed, turnRate] of templates)
 	{
 		if (turnRate < minTurnRate) continue;
-		// Minimum duration to reach target (with 20% margin for homing curve)
-		const margin = turnRate > 0 ? 1.2 : 1.05;
 		const minDurationTicks = Math.max(
 			MISSILE_MIN_DURATION,
-			Math.ceil(distance * margin / speed),
+			simulateMinDuration(speed, turnRate, distance),
 		);
 		const durationSec = minDurationTicks / TICKS_PER_SECOND;
 
@@ -277,3 +324,48 @@ export function fitMissileToBudget(
 
 	return best;
 }
+
+/**
+ * Fit a missile config that accounts for the enemy escaping during cast time.
+ *
+ * During casting, the caster moves at CASTING_MOVEMENT_MULT speed while
+ * the enemy moves at full MOVEMENT_SPEED. This means the effective distance
+ * at launch is larger than the current distance. This function iteratively
+ * converges on a missile config whose range covers the escape distance.
+ *
+ * @param currentDistance - Current distance to enemy
+ * @param budgetTicks - Maximum cast time budget in ticks
+ * @param options - Same options as fitMissileToBudget, plus:
+ *   - enemyApproaching: if true, enemy is moving toward caster (reduces escape)
+ *   - distanceBuffer: flat units added to target distance for safety margin (default 20)
+ *   - maxIterations: convergence iterations (default 5)
+ */
+export function fitMissileForEscapingTarget(
+	currentDistance: number,
+	budgetTicks: number,
+	options?: {minTurnRate?: number; maxDamage?: number; lastMissileConfig?: MissileConfig; enemyApproaching?: boolean; distanceBuffer?: number; maxIterations?: number},
+): MissileConfig | null
+{
+	const maxIter = options?.maxIterations ?? 5;
+	const buffer = options?.distanceBuffer ?? 20;
+	const escapeRate = options?.enemyApproaching
+		? 0
+		: MOVEMENT_SPEED - MOVEMENT_SPEED * CASTING_MOVEMENT_MULT;
+
+	let targetDistance = currentDistance + buffer;
+	let lastCastTicks = 0;
+
+	for (let i = 0; i < maxIter; i++)
+	{
+		const config = fitMissileToBudget(budgetTicks, targetDistance, options);
+		if (!config) return null;
+
+		const castTicks = getMissileCastTime(config, options?.lastMissileConfig);
+		if (castTicks === lastCastTicks) return config;
+		lastCastTicks = castTicks;
+
+		targetDistance = currentDistance + castTicks * escapeRate + buffer;
+	}
+
+	return fitMissileToBudget(budgetTicks, targetDistance, options);
+}

package/src/utils/spatial.ts

@@ -5,7 +5,7 @@
  */
 
 import {Position} from '../types.js';
-import {ARENA_WIDTH, ARENA_HEIGHT} from '../rules.js';
+import {ARENA_SIZE} from '../rules.js';
 
 /**
  * Normalize a vector to unit length.
@@ -49,8 +49,8 @@ export function directionAway(from: Position, to: Position): Position
 export function clampPositionToArena(position: Position): Position
 {
 	return {
-		x: Math.max(0, Math.min(ARENA_WIDTH, position.x)),
-		y: Math.max(0, Math.min(ARENA_HEIGHT, position.y)),
+		x: Math.max(0, Math.min(ARENA_SIZE, position.x)),
+		y: Math.max(0, Math.min(ARENA_SIZE, position.y)),
 	};
 }