@vibemancer/core 0.1.0 → 0.1.2

package/src/engine/missile-templates.ts

@@ -1,155 +1,155 @@
-/**
- * VIBEMANCER - MISSILE TEMPLATES
- *
- * Reusable missile config + AI factories for manual play and bot examples.
- * Each factory clamps its inputs to rules.ts minimums and returns a pure
- * AI function that's safe to register with the engine.
- */
-
-import {
-	MISSILE_MIN_DAMAGE,
-	MISSILE_MIN_SPEED,
-	MISSILE_MIN_DURATION,
-} from '../rules.js';
-import type {MissileAIFunction, MissileConfig} from '../types.js';
-
-interface BaseParams
-{
-	damage: number;
-	speed: number;
-	duration: number;
-}
-
-interface TurningParams extends BaseParams
-{
-	turnRate: number;
-}
-
-export type StraightParams = BaseParams;
-
-export type HomingParams = TurningParams;
-
-export type AntiHomingParams = TurningParams;
-
-export interface SpiralParams extends BaseParams
-{
-	spiralRadius: number;
-	spiralFreq: number;
-}
-
-export interface SeekerParams extends TurningParams
-{
-	minLockDistance: number;
-}
-
-export interface MissileTemplate
-{
-	config: MissileConfig;
-	ai: MissileAIFunction;
-}
-
-function clampBase(p: BaseParams): {damage: number; speed: number; duration: number}
-{
-	return {
-		damage: Math.max(MISSILE_MIN_DAMAGE, p.damage),
-		speed: Math.max(MISSILE_MIN_SPEED, p.speed),
-		duration: Math.max(MISSILE_MIN_DURATION, Math.floor(p.duration)),
-	};
-}
-
-/**
- * Fire-and-forget missile. No steering — flies in a straight line.
- */
-export function straightMissile(p: StraightParams): MissileTemplate
-{
-	const base = clampBase(p);
-	const config: MissileConfig = {...base, turnRate: 0};
-	const ai: MissileAIFunction = () => ({});
-	return {config, ai};
-}
-
-/**
- * Homing missile. Steers toward the enemy each tick.
- */
-export function homingMissile(p: HomingParams): MissileTemplate
-{
-	const base = clampBase(p);
-	const config: MissileConfig = {...base, turnRate: p.turnRate};
-	const ai: MissileAIFunction = ({worldState}) =>
-	{
-		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};
-	};
-	return {config, ai};
-}
-
-/**
- * Spiral missile. Continuously orbits its current heading while advancing.
- * Uses missileState.remainingTicks as a deterministic phase counter so the
- * AI is fully pure (no closure state).
- */
-export function spiralMissile(p: SpiralParams): MissileTemplate
-{
-	const base = clampBase(p);
-	// turnRate must be high enough for the spiral to manifest visibly
-	const config: MissileConfig = {...base, turnRate: 12};
-	const radius = Math.max(1, p.spiralRadius);
-	const freq = p.spiralFreq;
-	const ai: MissileAIFunction = ({missileState}) =>
-	{
-		const phase = -missileState.remainingTicks * freq;
-		const target = {
-			x: missileState.position.x + Math.cos(phase) * radius,
-			y: missileState.position.y + Math.sin(phase) * radius,
-		};
-		return {turnToward: target};
-	};
-	return {config, ai};
-}
-
-/**
- * Seeker missile. Homes toward the enemy, but only when farther away than
- * minLockDistance — closer than that, the missile coasts straight (so it
- * doesn't whirl around a target it's about to hit).
- */
-export function seekerMissile(p: SeekerParams): MissileTemplate
-{
-	const base = clampBase(p);
-	const config: MissileConfig = {...base, turnRate: p.turnRate};
-	const minDist = Math.max(0, p.minLockDistance);
-	const minDistSq = minDist * minDist;
-	const ai: MissileAIFunction = ({missileState, worldState}) =>
-	{
-		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 distSq = dx * dx + dy * dy;
-		if (distSq < minDistSq) return {};
-		return {turnToward: enemy.position};
-	};
-	return {config, ai};
-}
+/**
+ * VIBEMANCER - MISSILE TEMPLATES
+ *
+ * Reusable missile config + AI factories for manual play and bot examples.
+ * Each factory clamps its inputs to rules.ts minimums and returns a pure
+ * AI function that's safe to register with the engine.
+ */
+
+import {
+	MISSILE_MIN_DAMAGE,
+	MISSILE_MIN_SPEED,
+	MISSILE_MIN_DURATION,
+} from '../rules.js';
+import type {MissileAIFunction, MissileConfig} from '../types.js';
+
+interface BaseParams
+{
+	damage: number;
+	speed: number;
+	duration: number;
+}
+
+interface TurningParams extends BaseParams
+{
+	turnRate: number;
+}
+
+export type StraightParams = BaseParams;
+
+export type HomingParams = TurningParams;
+
+export type AntiHomingParams = TurningParams;
+
+export interface SpiralParams extends BaseParams
+{
+	spiralRadius: number;
+	spiralFreq: number;
+}
+
+export interface SeekerParams extends TurningParams
+{
+	minLockDistance: number;
+}
+
+export interface MissileTemplate
+{
+	config: MissileConfig;
+	ai: MissileAIFunction;
+}
+
+function clampBase(p: BaseParams): {damage: number; speed: number; duration: number}
+{
+	return {
+		damage: Math.max(MISSILE_MIN_DAMAGE, p.damage),
+		speed: Math.max(MISSILE_MIN_SPEED, p.speed),
+		duration: Math.max(MISSILE_MIN_DURATION, Math.floor(p.duration)),
+	};
+}
+
+/**
+ * Fire-and-forget missile. No steering — flies in a straight line.
+ */
+export function straightMissile(p: StraightParams): MissileTemplate
+{
+	const base = clampBase(p);
+	const config: MissileConfig = {...base, turnRate: 0};
+	const ai: MissileAIFunction = () => ({});
+	return {config, ai};
+}
+
+/**
+ * Homing missile. Steers toward the enemy each tick.
+ */
+export function homingMissile(p: HomingParams): MissileTemplate
+{
+	const base = clampBase(p);
+	const config: MissileConfig = {...base, turnRate: p.turnRate};
+	const ai: MissileAIFunction = ({worldState}) =>
+	{
+		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};
+	};
+	return {config, ai};
+}
+
+/**
+ * Spiral missile. Continuously orbits its current heading while advancing.
+ * Uses missileState.remainingTicks as a deterministic phase counter so the
+ * AI is fully pure (no closure state).
+ */
+export function spiralMissile(p: SpiralParams): MissileTemplate
+{
+	const base = clampBase(p);
+	// turnRate must be high enough for the spiral to manifest visibly
+	const config: MissileConfig = {...base, turnRate: 12};
+	const radius = Math.max(1, p.spiralRadius);
+	const freq = p.spiralFreq;
+	const ai: MissileAIFunction = ({missileState}) =>
+	{
+		const phase = -missileState.remainingTicks * freq;
+		const target = {
+			x: missileState.position.x + Math.cos(phase) * radius,
+			y: missileState.position.y + Math.sin(phase) * radius,
+		};
+		return {turnToward: target};
+	};
+	return {config, ai};
+}
+
+/**
+ * Seeker missile. Homes toward the enemy, but only when farther away than
+ * minLockDistance — closer than that, the missile coasts straight (so it
+ * doesn't whirl around a target it's about to hit).
+ */
+export function seekerMissile(p: SeekerParams): MissileTemplate
+{
+	const base = clampBase(p);
+	const config: MissileConfig = {...base, turnRate: p.turnRate};
+	const minDist = Math.max(0, p.minLockDistance);
+	const minDistSq = minDist * minDist;
+	const ai: MissileAIFunction = ({missileState, worldState}) =>
+	{
+		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 distSq = dx * dx + dy * dy;
+		if (distSq < minDistSq) return {};
+		return {turnToward: enemy.position};
+	};
+	return {config, ai};
+}

package/src/engine/physics.ts

@@ -1,143 +1,143 @@
-import {Position, WizardState, ProjectileState} from '../types.js';
-import {ARENA_WIDTH, ARENA_HEIGHT, MOVEMENT_SPEED, CASTING_MOVEMENT_MULT, WIZARD_RADIUS} 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
- */
-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));
-
-	// Normalize diagonal movement (cap magnitude at 100)
-	const magnitude = Math.sqrt(dx * dx + dy * dy);
-	if (magnitude > 100)
-	{
-		dx = dx * 100 / magnitude;
-		dy = dy * 100 / magnitude;
-	}
-
-	// Convert from [-100, 100] to [-1, 1] direction
-	dx = dx / 100;
-	dy = dy / 100;
-
-	let speed = MOVEMENT_SPEED;
-	if (wizard.state === 'casting')
-	{
-		speed *= CASTING_MOVEMENT_MULT;
-	}
-	else if (wizard.state === 'channeling')
-	{
-		// Movement keys ignored during channeling (design doc line 197, 1120)
-		speed = 0;
-	}
-
-	const newPos = {
-		x: wizard.position.x + dx * speed * deltaTicks,
-		y: wizard.position.y + dy * speed * deltaTicks,
-	};
-
-	return clampToArena(newPos, WIZARD_RADIUS);
-}
-
-/**
- * Move a projectile in its current rotation direction.
- */
-export function moveProjectile(projectile: ProjectileState, deltaTicks: number): Position
-{
-	const radians = projectile.rotation * (Math.PI / 180);
-	return {
-		x: projectile.position.x + Math.cos(radians) * projectile.speed * deltaTicks,
-		y: projectile.position.y + Math.sin(radians) * projectile.speed * deltaTicks,
-	};
-}
-
-/**
- * Clamp a position to the arena boundaries.
- */
-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)),
-	};
-}
-
-/**
- * Resolve body collision between two wizards.
- * Pushes both apart equally so they don't overlap. Neither is blocked — they just can't stack.
- * Iterates until stable: wizard push → wall clamp → re-check overlap → repeat.
- */
-export function resolveWizardCollision(wizard1: WizardState, wizard2: WizardState): void
-{
-	const minDist = WIZARD_RADIUS * 2;
-	const maxIterations = 5; // Prevents infinite loops in edge cases
-
-	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);
-
-		if (dist >= minDist) return; // No overlap — done
-
-		if (dist === 0)
-		{
-			// Exactly overlapping — push apart along arbitrary axis
-			wizard1.position = {x: wizard1.position.x - WIZARD_RADIUS, y: wizard1.position.y};
-			wizard2.position = {x: wizard2.position.x + WIZARD_RADIUS, y: wizard2.position.y};
-		}
-		else
-		{
-			const overlap = minDist - dist;
-			const pushX = (dx / dist) * (overlap / 2);
-			const pushY = (dy / dist) * (overlap / 2);
-
-			wizard1.position = {x: wizard1.position.x - pushX, y: wizard1.position.y - pushY};
-			wizard2.position = {x: wizard2.position.x + pushX, y: wizard2.position.y + pushY};
-		}
-
-		// Clamp both to arena — this may re-introduce overlap if one is pushed into a wall
-		wizard1.position = clampToArena(wizard1.position, WIZARD_RADIUS);
-		wizard2.position = clampToArena(wizard2.position, WIZARD_RADIUS);
-	}
-}
-
-/**
- * Perform swept circle collision detection between a moving point (projectile) and a stationary circle (wizard).
- * Returns true if a collision occurred during the movement from oldPos to newPos.
- */
-export function sweptCircleCollision(oldPos: Position, newPos: Position, radius: number, targetPos: Position, targetRadius: number): boolean
-{
-	// Distance from point to line segment
-	const totalRadius = radius + targetRadius;
-
-	// Vector from oldPos to newPos
-	const dx = newPos.x - oldPos.x;
-	const dy = newPos.y - oldPos.y;
-	const d2 = dx * dx + dy * dy;
-
-	if (d2 === 0)
-	{
-		const dist2 = (oldPos.x - targetPos.x) ** 2 + (oldPos.y - targetPos.y) ** 2;
-		return dist2 <= totalRadius * totalRadius;
-	}
-
-	// Projection of targetPos onto the line segment (oldPos, newPos)
-	let t = ((targetPos.x - oldPos.x) * dx + (targetPos.y - oldPos.y) * dy) / d2;
-	t = Math.max(0, Math.min(1, t));
-
-	const closestX = oldPos.x + t * dx;
-	const closestY = oldPos.y + t * dy;
-
-	const dist2 = (targetPos.x - closestX) ** 2 + (targetPos.y - closestY) ** 2;
-	return dist2 <= totalRadius * totalRadius;
-}
+import {Position, WizardState, ProjectileState} from '../types.js';
+import {ARENA_WIDTH, ARENA_HEIGHT, MOVEMENT_SPEED, CASTING_MOVEMENT_MULT, WIZARD_RADIUS} 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
+ */
+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));
+
+	// Normalize diagonal movement (cap magnitude at 100)
+	const magnitude = Math.sqrt(dx * dx + dy * dy);
+	if (magnitude > 100)
+	{
+		dx = dx * 100 / magnitude;
+		dy = dy * 100 / magnitude;
+	}
+
+	// Convert from [-100, 100] to [-1, 1] direction
+	dx = dx / 100;
+	dy = dy / 100;
+
+	let speed = MOVEMENT_SPEED;
+	if (wizard.state === 'casting')
+	{
+		speed *= CASTING_MOVEMENT_MULT;
+	}
+	else if (wizard.state === 'channeling')
+	{
+		// Movement keys ignored during channeling (design doc line 197, 1120)
+		speed = 0;
+	}
+
+	const newPos = {
+		x: wizard.position.x + dx * speed * deltaTicks,
+		y: wizard.position.y + dy * speed * deltaTicks,
+	};
+
+	return clampToArena(newPos, WIZARD_RADIUS);
+}
+
+/**
+ * Move a projectile in its current rotation direction.
+ */
+export function moveProjectile(projectile: ProjectileState, deltaTicks: number): Position
+{
+	const radians = projectile.rotation * (Math.PI / 180);
+	return {
+		x: projectile.position.x + Math.cos(radians) * projectile.speed * deltaTicks,
+		y: projectile.position.y + Math.sin(radians) * projectile.speed * deltaTicks,
+	};
+}
+
+/**
+ * Clamp a position to the arena boundaries.
+ */
+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)),
+	};
+}
+
+/**
+ * Resolve body collision between two wizards.
+ * Pushes both apart equally so they don't overlap. Neither is blocked — they just can't stack.
+ * Iterates until stable: wizard push → wall clamp → re-check overlap → repeat.
+ */
+export function resolveWizardCollision(wizard1: WizardState, wizard2: WizardState): void
+{
+	const minDist = WIZARD_RADIUS * 2;
+	const maxIterations = 5; // Prevents infinite loops in edge cases
+
+	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);
+
+		if (dist >= minDist) return; // No overlap — done
+
+		if (dist === 0)
+		{
+			// Exactly overlapping — push apart along arbitrary axis
+			wizard1.position = {x: wizard1.position.x - WIZARD_RADIUS, y: wizard1.position.y};
+			wizard2.position = {x: wizard2.position.x + WIZARD_RADIUS, y: wizard2.position.y};
+		}
+		else
+		{
+			const overlap = minDist - dist;
+			const pushX = (dx / dist) * (overlap / 2);
+			const pushY = (dy / dist) * (overlap / 2);
+
+			wizard1.position = {x: wizard1.position.x - pushX, y: wizard1.position.y - pushY};
+			wizard2.position = {x: wizard2.position.x + pushX, y: wizard2.position.y + pushY};
+		}
+
+		// Clamp both to arena — this may re-introduce overlap if one is pushed into a wall
+		wizard1.position = clampToArena(wizard1.position, WIZARD_RADIUS);
+		wizard2.position = clampToArena(wizard2.position, WIZARD_RADIUS);
+	}
+}
+
+/**
+ * Perform swept circle collision detection between a moving point (projectile) and a stationary circle (wizard).
+ * Returns true if a collision occurred during the movement from oldPos to newPos.
+ */
+export function sweptCircleCollision(oldPos: Position, newPos: Position, radius: number, targetPos: Position, targetRadius: number): boolean
+{
+	// Distance from point to line segment
+	const totalRadius = radius + targetRadius;
+
+	// Vector from oldPos to newPos
+	const dx = newPos.x - oldPos.x;
+	const dy = newPos.y - oldPos.y;
+	const d2 = dx * dx + dy * dy;
+
+	if (d2 === 0)
+	{
+		const dist2 = (oldPos.x - targetPos.x) ** 2 + (oldPos.y - targetPos.y) ** 2;
+		return dist2 <= totalRadius * totalRadius;
+	}
+
+	// Projection of targetPos onto the line segment (oldPos, newPos)
+	let t = ((targetPos.x - oldPos.x) * dx + (targetPos.y - oldPos.y) * dy) / d2;
+	t = Math.max(0, Math.min(1, t));
+
+	const closestX = oldPos.x + t * dx;
+	const closestY = oldPos.y + t * dy;
+
+	const dist2 = (targetPos.x - closestX) ** 2 + (targetPos.y - closestY) ** 2;
+	return dist2 <= totalRadius * totalRadius;
+}