@vibemancer/core 0.1.4 → 0.1.6

package/src/engine/spells.ts

@@ -1,12 +1,7 @@
 import {WizardState, MissileConfig, ProjectileState} from '../types.js';
 import {
-	SHIELD_MAX_BLOCK,
-	SHIELD_DECAY_PER_SECOND,
-	SHIELD_MIN_BLOCK,
+	RULES,
 	TICKS_PER_SECOND,
-	GCD_DURATION,
-	SHIELD_CAST_TIME,
-	BLINK_CAST_TIME,
 	calculateMissileCastTime,
 	calculateWarmupMultiplier,
 } from '../rules.js';
@@ -21,6 +16,7 @@ export function startCast(wizard: WizardState, spell: 'missile' | 'shield' | 'bl
 	wizard.castingSpell = spell;
 	wizard.castProgress = 0;
 
+	// Stryker disable next-line ConditionalExpression: `true && config` equivalent for valid calls (spell is always correct type)
 	if (spell === 'missile' && config)
 	{
 		// calculateMissileCastTime includes warmup when lastMissileConfig is passed
@@ -31,11 +27,12 @@ export function startCast(wizard: WizardState, spell: 'missile' | 'shield' | 'bl
 	}
 	else if (spell === 'shield')
 	{
-		wizard.castDuration = SHIELD_CAST_TIME;
+		wizard.castDuration = RULES.SHIELD_CAST_TIME;
 	}
-	else if (spell === 'blink')
+	else
 	{
-		wizard.castDuration = BLINK_CAST_TIME;
+		// Blink is the only remaining case after missile and shield
+		wizard.castDuration = RULES.BLINK_CAST_TIME;
 	}
 }
 
@@ -66,7 +63,7 @@ export function completeCast(wizard: WizardState): void
 	else if (spell === 'missile')
 	{
 		wizard.state = 'gcd_locked';
-		wizard.gcdRemaining = GCD_DURATION;
+		wizard.gcdRemaining = RULES.GCD_DURATION;
 	}
 	else
 	{
@@ -96,8 +93,8 @@ export function updateShield(wizard: WizardState, deltaTicks: number): void
 export function calculateShieldBlock(channelDurationTicks: number): number
 {
 	const channelSeconds = channelDurationTicks / TICKS_PER_SECOND;
-	const decay = channelSeconds * SHIELD_DECAY_PER_SECOND;
-	return Math.max(SHIELD_MIN_BLOCK, SHIELD_MAX_BLOCK - decay);
+	const decay = channelSeconds * RULES.SHIELD_DECAY_PER_SECOND;
+	return Math.max(RULES.SHIELD_MIN_BLOCK, RULES.SHIELD_MAX_BLOCK - decay);
 }
 
 /**

package/src/engine-version.ts

@@ -8,4 +8,4 @@
  * Used to gate spectator replays: a recorded match can only be re-simulated when
  * the runtime engine version matches the version that produced the match.
  */
-export const ENGINE_VERSION = 1777687052301;
+export const ENGINE_VERSION = 1782047842068;

package/src/hooks/action-builders.ts

@@ -5,7 +5,7 @@
  *
  * UNITS REFERENCE (100 ticks = 1 second):
  *   Position:   absolute world coordinates, 0-800 on each axis (800×800 arena)
- *   Movement:   direction vector, magnitude auto-normalized to max 100
+ *   Movement:   direction vector, magnitude clamped to max 1 (speed in [0, 1])
  *   Speed:      units per tick (player moves at 1 unit/tick = 100 units/sec)
  *   Duration:   ticks (divide by 100 for seconds)
  *   Angles:     degrees (0°=right, 90°=down, 180°=left, 270°=up)
@@ -13,8 +13,8 @@
  *   Turn rate:  degrees per tick the missile can rotate
  */
 
-import {WizardActions, MissileConfig, MissileAIFunction} from '../types.js';
-import type {FinalAction, ActionBuilder} from './types.js';
+import {WizardActions, MissileConfig, MissileActions} from '../types.js';
+import type {FinalAction, ActionBuilder, MissileAction, MissileFunction} from './types.js';
 
 /**
  * Create a FinalAction (no further chaining possible).
@@ -63,7 +63,7 @@ function createActionBuilder(baseAction: Omit<WizardActions, 'move'>): ActionBui
  *
  * @example
  *   return shield();                    // shield and stay still
- *   return shield().move(100, 0);       // move right while cast starts
+ *   return shield().move(1, 0);         // move right while cast starts
  */
 export function shield(): ActionBuilder
 {
@@ -90,27 +90,30 @@ export function shield(): ActionBuilder
  *   - duration: ticks the missile lives (min 10). Range ≈ speed × duration.
  *   - turnRate: degrees/tick of homing (0 = straight line, 3 = moderate homing, 5+ = strong).
  *              Negative = no homing + minor speed cost reduction.
- * @param ai - Called every tick to control missile steering. Receives:
- *   - missileState: the missile's position, rotation (degrees), speed, remainingTicks
- *   - worldState:   full game state (all wizards, projectiles)
- *   - random():     seeded PRNG [0, 1)
- *   Return { turnToward: {x, y} } to home toward a position, or {} to fly straight.
+ * @param ai - Called every tick to control missile steering. Use getMissileContext()
+ *   to read the missile's state (position, rotation, speed, etc.), the full game
+ *   state (worldState), and a seeded PRNG (random). Return turnToward(x, y) to home
+ *   toward a position, or flyStraight() to fly straight.
  * @param direction - Launch angle in degrees (0°=right, 90°=down, 180°=left, 270°=up).
  *   Tip: use Math.atan2(dy, dx) * (180 / Math.PI) to aim at a target.
  *
  * @example
  *   // Straight missile aimed at enemy
  *   const angle = Math.atan2(dy, dx) * (180 / Math.PI);
- *   return missile({damage: 15, speed: 6, duration: 200, turnRate: 0}, () => ({}), angle);
+ *   return missile({damage: 15, speed: 6, duration: 200, turnRate: 0}, () => flyStraight(), angle);
  *
  *   // Homing missile that tracks enemy
  *   return missile(
  *     {damage: 10, speed: 5, duration: 300, turnRate: 3},
- *     ({worldState}) => ({turnToward: worldState.enemies[0]?.position}),
+ *     () => {
+ *       const ctx = getMissileContext();
+ *       const enemy = ctx.worldState.enemies[0];
+ *       return enemy ? turnToward(enemy.position.x, enemy.position.y) : flyStraight();
+ *     },
  *     angle,
  *   );
  */
-export function missile(config: MissileConfig, ai: MissileAIFunction, direction: number): ActionBuilder
+export function missile(config: MissileConfig, ai: MissileFunction, direction: number): ActionBuilder
 {
 	return createActionBuilder({
 		startCast: {
@@ -157,7 +160,7 @@ export function blink(x: number, y: number): FinalAction
  * Can chain .move() for simultaneous movement.
  *
  * @example
- *   return cancel().move(-100, 0);  // cancel and dodge left
+ *   return cancel().move(-1, 0);    // cancel and dodge left
  */
 export function cancel(): ActionBuilder
 {
@@ -169,19 +172,17 @@ export function cancel(): ActionBuilder
 /**
  * Move in a direction without casting any spell.
  *
- * This is a **direction vector**, not a target position. The engine normalizes
- * the magnitude to max 100, then moves at 1 unit/tick (100 units/sec).
- * Positive X = right, positive Y = down.
- *
- * To move toward a target position, subtract your position:
- *   move(target.x - myPos.x, target.y - myPos.y)
+ * This is a **direction vector**, not a target position. Values are in the
+ * range [-1, 1] where 1 = full speed. Larger values (like raw position
+ * deltas) are clamped to full speed automatically.
  *
  * @param x - Horizontal direction (positive = right, negative = left)
  * @param y - Vertical direction (positive = down, negative = up)
  *
  * @example
- *   return move(100, 0);                                       // move right
- *   return move(enemy.position.x - myPos.x, enemy.position.y - myPos.y);  // move toward enemy
+ *   return move(1, 0);                                         // move right at full speed
+ *   return move(dx / dist, dy / dist);                         // normalized unit vector = full speed
+ *   return move(enemy.position.x - myPos.x, enemy.position.y - myPos.y);  // raw delta = clamped to full speed
  */
 export function move(x: number, y: number): FinalAction
 {
@@ -200,6 +201,60 @@ export function idle(): FinalAction
 	});
 }
 
+// ============================================================
+// MISSILE ACTION BUILDERS
+// ============================================================
+
+/**
+ * Steer the missile toward a world position.
+ * The engine clamps the actual turn to the missile's turnRate.
+ *
+ * @param x - Target X position (world coordinates)
+ * @param y - Target Y position (world coordinates)
+ */
+export function turnToward(x: number, y: number): MissileAction
+{
+	return {
+		_toMissileAction: () => ({turnToward: {x, y}}),
+	};
+}
+
+/**
+ * Steer the missile toward a specific angle (degrees).
+ * The engine clamps the actual turn to the missile's turnRate.
+ *
+ * @param degrees - Target rotation in degrees (0=right, 90=down, 180=left, 270=up)
+ */
+export function turnToAngle(degrees: number): MissileAction
+{
+	return {
+		_toMissileAction: () => ({turnToAngle: degrees}),
+	};
+}
+
+/**
+ * Fly straight — no steering this tick.
+ */
+export function flyStraight(): MissileAction
+{
+	return {
+		_toMissileAction: () => ({}),
+	};
+}
+
+/**
+ * Extract MissileActions from a MissileAction.
+ * Used by the engine to get the actual missile action.
+ */
+export function extractMissileAction(action: MissileAction): MissileActions
+{
+	return action._toMissileAction();
+}
+
+// ============================================================
+// WIZARD ACTION EXTRACTION
+// ============================================================
+
 /**
  * Extract WizardActions from a FinalAction.
  * Used by the engine to get the actual action.

package/src/hooks/index.ts

@@ -10,14 +10,17 @@ export type {
 	AnalyzedThreat,
 	FinalAction,
 	ActionBuilder,
-	BotFunction,
-	BotContext,
+	WizardFunction,
+	WizardContext,
 	MissileConfig,
-	MissileAIFunction,
+	MissileContext,
+	MissileAction,
+	MissileFunction,
 } from './types.js';
 
 // State hooks
 export {
+	useRandom,
 	useHealth,
 	usePosition,
 	useVelocity,
@@ -28,7 +31,9 @@ export {
 	useCastingSpell,
 	useCastProgress,
 	useEnemy,
+	useProjectiles,
 	useMyProjectiles,
+	useLastMissileConfig,
 	useDamageDealt,
 	useDamageTaken,
 	useLastHitTick,
@@ -51,6 +56,10 @@ export {
 	move,
 	idle,
 	extractAction,
+	turnToward,
+	turnToAngle,
+	flyStraight,
+	extractMissileAction,
 } from './action-builders.js';
 
 // Re-export persistence hooks from runtime
@@ -59,17 +68,16 @@ export {
 	useEffect,
 	useMemo,
 	useRef,
-	runBotWithContext,
-	withBotContext,
-	getBotContext,
+	runWizardWithContext,
+	withWizardContext,
+	withMissileContext,
+	getWizardContext,
+	getMissileContext,
 } from '../engine/hooks-runtime.js';
 
 // Re-export RefObject type
 export type {RefObject} from '../engine/hooks-runtime.js';
 
-// Bot wrapper for integration
-export {wrapNewBot, isNewStyleBot} from './bot-wrapper.js';
-
 // Parameter tuning hook
 export {useParam} from '../engine/params-runtime.js';
 export type {ParamDeclaration} from '../engine/params-runtime.js';

package/src/hooks/state-hooks.ts

@@ -13,8 +13,8 @@
  */
 
 import {Position, Velocity, ProjectileState} from '../types.js';
-import {getBotContext, useMemo} from '../engine/hooks-runtime.js';
-import {SHIELD_MAX_BLOCK, SHIELD_DECAY_PER_SECOND, SHIELD_MIN_BLOCK, TICKS_PER_SECOND} from '../rules.js';
+import {getWizardContext, useMemo} from '../engine/hooks-runtime.js';
+import {RULES, TICKS_PER_SECOND} from '../rules.js';
 import type {EnemyState, AnalyzedThreat} from './types.js';
 import {analyzeThreats} from './threat-analysis.js';
 
@@ -22,12 +22,22 @@ import {analyzeThreats} from './threat-analysis.js';
 // SELF STATE HOOKS
 // ============================================================
 
+/**
+ * Get a seeded random number generator. Returns a function that produces
+ * deterministic values in [0, 1) — same seed + same tick = same sequence.
+ * Use this instead of Math.random() so replays are deterministic.
+ */
+export function useRandom(): () => number
+{
+	return getWizardContext().random;
+}
+
 /**
  * Get your current health (0-60). Wizard dies at 0.
  */
 export function useHealth(): number
 {
-	return getBotContext().health;
+	return getWizardContext().health;
 }
 
 /**
@@ -36,7 +46,7 @@ export function useHealth(): number
  */
 export function usePosition(): Position
 {
-	const ctx = getBotContext();
+	const ctx = getWizardContext();
 	return {x: ctx.position.x, y: ctx.position.y};
 }
 
@@ -46,7 +56,7 @@ export function usePosition(): Position
  */
 export function useVelocity(): Velocity
 {
-	const ctx = getBotContext();
+	const ctx = getWizardContext();
 	return {x: ctx.velocity.x, y: ctx.velocity.y};
 }
 
@@ -59,7 +69,7 @@ export function useVelocity(): Velocity
  */
 export function useStatus(): 'idle' | 'casting' | 'channeling' | 'gcd_locked'
 {
-	return getBotContext().state;
+	return getWizardContext().state;
 }
 
 /**
@@ -72,7 +82,7 @@ export function useStatus(): 'idle' | 'casting' | 'channeling' | 'gcd_locked'
  */
 export function useTicksUntilReady(): number
 {
-	const ctx = getBotContext();
+	const ctx = getWizardContext();
 
 	switch (ctx.state)
 	{
@@ -105,7 +115,7 @@ export function useTicksUntilReady(): number
  */
 export function useShieldStrength(): number
 {
-	const ctx = getBotContext();
+	const ctx = getWizardContext();
 
 	if (ctx.state !== 'channeling' || ctx.channelingSpell !== 'shield')
 	{
@@ -114,9 +124,27 @@ export function useShieldStrength(): number
 
 	// Calculate shield strength based on channel duration
 	const channelDuration = ctx.channelDuration ?? 0;
-	const decayPerTick = SHIELD_DECAY_PER_SECOND / TICKS_PER_SECOND;
-	const strength = SHIELD_MAX_BLOCK - (channelDuration * decayPerTick);
-	return Math.max(SHIELD_MIN_BLOCK, strength);
+	const decayPerTick = RULES.SHIELD_DECAY_PER_SECOND / TICKS_PER_SECOND;
+	const strength = RULES.SHIELD_MAX_BLOCK - (channelDuration * decayPerTick);
+	return Math.max(RULES.SHIELD_MIN_BLOCK, strength);
+}
+
+/**
+ * Get all projectiles currently in flight (yours and enemy's).
+ * Used for blink safety calculations and threat analysis.
+ */
+export function useProjectiles(): ProjectileState[]
+{
+	return getWizardContext().projectiles;
+}
+
+/**
+ * Get the config of the last missile you fired, or undefined if none fired yet.
+ * Used for the warmup system: consecutive similar missiles cast faster.
+ */
+export function useLastMissileConfig(): import('../types.js').MissileConfig | undefined
+{
+	return getWizardContext().lastMissileConfig;
 }
 
 /**
@@ -130,7 +158,7 @@ export function useShieldStrength(): number
  */
 export function useBlinkCooldown(): number
 {
-	return getBotContext().blinkCooldown;
+	return getWizardContext().blinkCooldown;
 }
 
 /**
@@ -139,7 +167,7 @@ export function useBlinkCooldown(): number
  */
 export function useCastingSpell(): 'missile' | 'shield' | 'blink' | null
 {
-	const ctx = getBotContext();
+	const ctx = getWizardContext();
 	if (ctx.state !== 'casting')
 	{
 		return null;
@@ -155,7 +183,7 @@ export function useCastingSpell(): 'missile' | 'shield' | 'blink' | null
  */
 export function useCastProgress(): {current: number; total: number} | null
 {
-	const ctx = getBotContext();
+	const ctx = getWizardContext();
 	if (ctx.state !== 'casting')
 	{
 		return null;
@@ -180,7 +208,7 @@ export function useCastProgress(): {current: number; total: number} | null
  */
 export function useEnemy(): EnemyState
 {
-	const ctx = getBotContext();
+	const ctx = getWizardContext();
 	const enemy = ctx.enemies[0];
 
 	if (!enemy)
@@ -192,6 +220,10 @@ export function useEnemy(): EnemyState
 			health: 0,
 			status: 'idle',
 			castingSpell: null,
+			castProgress: 0,
+			castDuration: 0,
+			gcdRemaining: 0,
+			channelDuration: 0,
 			shieldStrength: 0,
 		};
 	}
@@ -201,8 +233,8 @@ export function useEnemy(): EnemyState
 	if (enemy.state === 'channeling' && enemy.channelingSpell === 'shield')
 	{
 		const channelDuration = enemy.channelDuration ?? 0;
-		const decayPerTick = SHIELD_DECAY_PER_SECOND / TICKS_PER_SECOND;
-		shieldStrength = Math.max(SHIELD_MIN_BLOCK, SHIELD_MAX_BLOCK - (channelDuration * decayPerTick));
+		const decayPerTick = RULES.SHIELD_DECAY_PER_SECOND / TICKS_PER_SECOND;
+		shieldStrength = Math.max(RULES.SHIELD_MIN_BLOCK, RULES.SHIELD_MAX_BLOCK - (channelDuration * decayPerTick));
 	}
 
 	return {
@@ -211,6 +243,10 @@ export function useEnemy(): EnemyState
 		health: enemy.health,
 		status: enemy.state,
 		castingSpell: enemy.state === 'casting' ? (enemy.castingSpell ?? null) : null,
+		castProgress: enemy.castProgress ?? 0,
+		castDuration: enemy.castDuration ?? 0,
+		gcdRemaining: enemy.gcdRemaining ?? 0,
+		channelDuration: enemy.channelDuration ?? 0,
 		shieldStrength,
 	};
 }
@@ -225,7 +261,7 @@ export function useEnemy(): EnemyState
  */
 export function useMyProjectiles(): ProjectileState[]
 {
-	return getBotContext().myProjectiles;
+	return getWizardContext().myProjectiles;
 }
 
 // ============================================================
@@ -237,7 +273,7 @@ export function useMyProjectiles(): ProjectileState[]
  */
 export function useDamageDealt(): number
 {
-	return getBotContext().damageDealt;
+	return getWizardContext().damageDealt;
 }
 
 /**
@@ -245,7 +281,7 @@ export function useDamageDealt(): number
  */
 export function useDamageTaken(): number
 {
-	return getBotContext().damageTaken;
+	return getWizardContext().damageTaken;
 }
 
 /**
@@ -254,7 +290,7 @@ export function useDamageTaken(): number
  */
 export function useLastHitTick(): number
 {
-	return getBotContext().lastHitTick;
+	return getWizardContext().lastHitTick;
 }
 
 // ============================================================
@@ -267,7 +303,7 @@ export function useLastHitTick(): number
  */
 export function useArenaSize(): {width: number; height: number}
 {
-	const ctx = getBotContext();
+	const ctx = getWizardContext();
 	return {width: ctx.arenaWidth, height: ctx.arenaHeight};
 }
 
@@ -277,7 +313,7 @@ export function useArenaSize(): {width: number; height: number}
  */
 export function useTick(): number
 {
-	return getBotContext().tick;
+	return getWizardContext().tick;
 }
 
 // ============================================================
@@ -300,7 +336,7 @@ export function useTick(): number
  */
 export function useThreats(): AnalyzedThreat[]
 {
-	const ctx = getBotContext();
+	const ctx = getWizardContext();
 	const ticksUntilReady = useTicksUntilReady();
 
 	// Memoize to avoid recalculating every call
@@ -331,7 +367,7 @@ export function useClosestThreat(): AnalyzedThreat | null
  */
 export function useMyThreatsToEnemy(): AnalyzedThreat[]
 {
-	const ctx = getBotContext();
+	const ctx = getWizardContext();
 	const enemy = ctx.enemies[0];
 
 	if (!enemy)