@vibemancer/core 1.0.7 → 1.0.9

package/src/bots/sniper/01_Spellshot.ts

@@ -151,11 +151,17 @@ function combatMove(
 /**
  * Bot: Spellshot
  *
- * BEHAVIOR: Uses interceptAngle to calculate where the enemy will be and fires
- * fast, non-homing missiles (speed 8, turnRate 0) along the predicted path.
- * Strafes at medium range (300-400), shields undodgeable threats, emergency
- * blinks when shield isn't available. The key mechanic is PREDICTION — these
- * missiles don't track, they go exactly where you calculated the enemy would be.
+ * BEHAVIOR: fires lightly-homing missiles (turnRate defaults to 0.3) aimed at the enemy's
+ * CURRENT position, strafes at medium range (300-400), shields undodgeable threats, and
+ * blinks when a shield isn't available.
+ *
+ * This description used to claim it "uses interceptAngle to calculate where the enemy will
+ * be" and fires "non-homing missiles (speed 8, turnRate 0)" whose "key mechanic is
+ * PREDICTION". None of that was true — it calls angleTo(position, enemy.position) and lets
+ * the missile home. That mattered because this is the exemplar other snipers are read from,
+ * and until 2026-09-10 aiming ahead was impossible anyway: the engine auto-aimed at the
+ * enemy every tick and discarded whatever angle a bot passed. Leading is now possible with
+ * per-tick aim(), but this bot does not do it.
  *
  * NAMING RATIONALE: "Spellshot" — a spell that is a single, precisely aimed shot.
  * Like a sniper's "called shot" but magical. The defining feature is the intercept

package/src/engine/manual-match.ts

@@ -185,7 +185,9 @@ export class ManualMatch
 
 			this.history.push(getPlayerState(0, this.wizards, this.projectiles, this.currentTick, result.events));
 
-			// Track death and add grace period (0.5s = 50 ticks at 100 tps)
+			// Track death and add grace period (2s = 200 ticks at 100 tps), matching
+			// simulation.ts. The window is what makes a Draw reachable: a second death inside
+			// it is still recorded. Pinned by tests/death-grace-period.test.ts.
 			if (!this.deathTick && (this.wizards[0]!.health <= 0 || this.wizards[1]!.health <= 0))
 			{
 				this.deathTick = this.currentTick;

package/src/engine/physics.ts

@@ -9,8 +9,18 @@ import {RULES, ARENA_SIZE, WIZARD_RADIUS, ARENA_MIN, ARENA_MAX} from '../rules.j
  */
 export function moveWizard(wizard: WizardState, move: {x: number; y: number}, deltaTicks: number): Position
 {
-	let dx = move.x || 0;
-	let dy = move.y || 0;
+	// A bot's move vector is untrusted input, and it must not be able to poison the
+	// simulation. This was `move.x || 0`, which neutralises NaN (NaN is falsy) and does
+	// nothing about Infinity — and `Infinity / magnitude` is NaN, so the position became NaN,
+	// `isInLava(NaN)` was false so the wizard never died, and `resolveWizardCollision` then
+	// divided by a NaN distance and wrote NaN into the OPPONENT's position too. Both wizards
+	// froze, nothing could hit anything, and every match was a silent draw.
+	//
+	// On a rated ladder that made `move(1/0, 0)` a one-line way to deny every opponent a win
+	// and never lose — and it is reachable by accident from any divide-by-zero scale factor.
+	// A non-finite component is treated as no input on that axis, exactly like move(0, 0).
+	let dx = Number.isFinite(move?.x) ? move.x : 0;
+	let dy = Number.isFinite(move?.y) ? move.y : 0;
 
 	const magnitude = Math.sqrt(dx * dx + dy * dy);
 	// Stryker disable next-line EqualityOperator: > vs >= equivalent (dividing by exactly 1 is identity)

package/src/engine/simulation.ts

@@ -47,6 +47,15 @@ export interface InternalWizardState extends WizardState
 	knockbackVy?: number;
 	// Delayed knockback (waits for explosion to expand)
 	knockbackDelay?: number;
+	/**
+	 * A heading this wizard LOCKED for the duration of a missile cast, via `lockAim()`.
+	 *
+	 * Auto-aim rewrites `rotation` every tick and a missile launches with the rotation at cast
+	 * completion, so an angle applied only at cast start never survived. Holding it here is
+	 * what lets a bot lead a moving target. Absent for every bot that does not opt in, which
+	 * is why adding it changed no existing behaviour.
+	 */
+	castAimDirection?: number;
 	knockbackPendingVx?: number;
 	knockbackPendingVy?: number;
 }
@@ -292,12 +301,19 @@ export function tick(
 			}
 		}
 
-		// Auto-aim: face the enemy by default, bot can override with aimDirection
+		// Auto-aim: face the enemy by default; a bot overrides with aimDirection (`aim()`), and
+		// a missile cast that opted in with `lockAim()` holds its heading until it launches.
+		// Without that hold the override ran every tick and the requested angle never reached
+		// cast completion, which is the rotation the missile is actually fired with.
 		const enemy = wizards[1 - i]!;
 		if (action.aimDirection !== undefined && Number.isFinite(action.aimDirection))
 		{
 			wizard.rotation = action.aimDirection;
 		}
+		else if (wizard.state === 'casting' && wizard.castingSpell === 'missile' && wizard.castAimDirection !== undefined)
+		{
+			wizard.rotation = wizard.castAimDirection;
+		}
 		else
 		{
 			wizard.rotation = angleTo(wizard.position, enemy.position);
@@ -328,6 +344,9 @@ export function tick(
 						remainingTicks: validConfig.duration,
 					};
 					projectiles.push(projectile);
+					// The lock belonged to this cast; the next action auto-aims again unless it
+					// asks for something else.
+					wizard.castAimDirection = undefined;
 					missileAIs.set(id, wizard.missileAI);
 					events.push({type: 'missile-launch', position: {...wizard.position}, damage: validConfig.damage, speed: validConfig.speed, ownerId: wizard.id, rotation: wizard.rotation});
 					// Track last missile for warmup system
@@ -455,6 +474,11 @@ export function tick(
 					{
 						wizard.rotation = action.startCast.direction;
 					}
+					// Only a bot that called lockAim() sends aimDirection, so auto-aim stays
+					// the default for everything that came before this existed.
+					wizard.castAimDirection = (action.aimDirection !== undefined && Number.isFinite(action.aimDirection))
+						? action.aimDirection
+						: undefined;
 				}
 				else if (castingSpell === 'blink')
 				{
@@ -832,6 +856,15 @@ export interface BotError
 	tick: number;
 	entityId: string;
 	message: string;
+	/**
+	 * 1-based index within the fight's TEN matches, present only on `FightResult.allErrors`.
+	 *
+	 * A single `simulate()` knows nothing about a series, so it does not set this. `fight()`
+	 * stamps it, numbering 1..10 in the order matches are played. Every tool description
+	 * promises "a 10-match series (5 spawn distances, each played twice with sides swapped)",
+	 * so a match index that only ever reached 5 was uninterpretable to the player reading it.
+	 */
+	match?: number;
 }
 
 export interface SimulateResult
@@ -860,6 +893,37 @@ export interface FightResult
 	 * Used for visual playback in the web viewer. Scoring includes both sides.
 	 */
 	matches: SimulateResult[];
+	/**
+	 * Every bot error from ALL TEN matches, including the swapped half that `matches` drops.
+	 *
+	 * `matches` exists for visual playback, so it holds only the five non-swapped results.
+	 * Anything asking "did this bot crash?" needs the whole series: a bot that throws only
+	 * when it spawns on one side was previously invisible, reporting a clean `success: true`
+	 * while losing every match.
+	 *
+	 * Entity ids are in the CALLER's frame of reference. In a swapped match the engine calls
+	 * bot 2 "wizard-1", so those records are remapped on the way out — passing them through
+	 * raw would blame each side's faults on the other.
+	 */
+	allErrors: BotError[];
+}
+
+/**
+ * Flip an entity id between the two sides.
+ *
+ * A swapped match runs bot 2 in the wizard-1 slot, so every id it produces is the mirror of
+ * what the caller means by it. Projectile ids carry their owner (`missile-<wizard>-<tick>`),
+ * so they are mirrored too — otherwise a missile-AI fault from the swapped half would be
+ * attributed to the wrong bot, which is exactly the defect that made a passive bot look like
+ * it had thrown 3,695 times.
+ */
+function swapSide(entityId: string): string
+{
+	if (entityId === 'wizard-1') return 'wizard-2';
+	if (entityId === 'wizard-2') return 'wizard-1';
+	if (entityId.startsWith('missile-wizard-1-')) return 'missile-wizard-2-' + entityId.slice('missile-wizard-1-'.length);
+	if (entityId.startsWith('missile-wizard-2-')) return 'missile-wizard-1-' + entityId.slice('missile-wizard-2-'.length);
+	return entityId;
 }
 
 /** Spawn distances for the 5 matches in a fight (creates butterfly effect variation) */
@@ -891,6 +955,10 @@ export function fight(
 ): FightResult
 {
 	const matches: SimulateResult[] = [];
+	const allErrors: BotError[] = [];
+	// 1..10 in the order matches are played, so the number a player is shown is the number
+	// every tool description promises.
+	let matchNumber = 1;
 	let wizard1Wins = 0;
 	let wizard2Wins = 0;
 	let draws = 0;
@@ -909,6 +977,8 @@ export function fight(
 		});
 
 		matches.push(result);
+		allErrors.push(...result.errors.map((e) => ({...e, match: matchNumber})));
+		matchNumber++;
 
 		if (result.winner === 'wizard-1')
 		{
@@ -946,6 +1016,13 @@ export function fight(
 			budget.states = [swappedBudget.states[1], swappedBudget.states[0]];
 		}
 
+		// The swapped match is dropped from `matches` (playback only), but its errors are not
+		// dropped — half a fight's worth of crashes used to vanish here. Ids are flipped back
+		// into the caller's frame first: this match ran bot 2 as "wizard-1", so passing the
+		// records through raw would report each bot's faults against the other.
+		allErrors.push(...swapped.errors.map((e) => ({...e, entityId: swapSide(e.entityId), match: matchNumber})));
+		matchNumber++;
+
 		// Don't push swapped match to matches array (it's only for scoring)
 		if (swapped.winner === 'wizard-1')
 		{
@@ -966,7 +1043,7 @@ export function fight(
 		: wizard2Wins > wizard1Wins ? 'wizard-2'
 			: 'draw';
 
-	return {wizard1Wins, wizard2Wins, draws, winner, matches};
+	return {wizard1Wins, wizard2Wins, draws, winner, matches, allErrors};
 }
 
 /**

package/src/engine-version.ts

@@ -9,7 +9,7 @@
  * 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 = 4204441759696527;
+export const ENGINE_VERSION = 293192982913104;
 
 /**
  * Historical versions that denote the SAME engine as `ENGINE_VERSION`.