@vibemancer/core 1.0.9 → 1.0.11

package/dist/{chunk-OLGKLCCB.js → chunk-EO7JO2RZ.js}

@@ -213,7 +213,7 @@ function currentRuleset() {
 }
 
 // src/engine-version.ts
-var ENGINE_VERSION = 293192982913104;
+var ENGINE_VERSION = 2983169471988242;
 var EQUIVALENT_ENGINE_VERSIONS = [1688330189011034];
 
 // src/replay-compat.ts
@@ -520,7 +520,51 @@ function extractMissileAction(action) {
   return action._toMissileAction();
 }
 function extractAction(finalAction) {
-  return finalAction._toAction();
+  if (finalAction === null || finalAction === void 0 || typeof finalAction._toAction !== "function") {
+    const describeReturned = (value) => {
+      if (value === null) return "null";
+      if (value === void 0) return "undefined";
+      if (Array.isArray(value)) return "an array";
+      if (typeof value === "object") {
+        if ("then" in value && typeof value.then === "function") {
+          return "a Promise \u2014 your bot function is `async`, and it must not be: remove the async keyword";
+        }
+        return "a plain object";
+      }
+      return `a ${typeof value}`;
+    };
+    const got = describeReturned(finalAction);
+    throw new Error(
+      `Your bot returned ${got}. Return one of: idle(), move(x, y), missile(config, ai, angle), shield(), blink(x, y), cancel() or aim(degrees). A bot must return an action every tick \u2014 returning nothing throws, it does not skip the tick.`
+    );
+  }
+  const action = finalAction._toAction();
+  if (action === null || typeof action !== "object" || typeof action.move !== "object" || action.move === null) {
+    throw new Error(
+      "Your bot returned something that is not a valid action. Build actions with the provided functions \u2014 idle(), move(x, y), missile(config, ai, angle), shield(), blink(x, y), cancel() or aim(degrees) \u2014 rather than constructing the object yourself."
+    );
+  }
+  return normaliseActionNumbers(action);
+}
+function normaliseActionNumbers(action) {
+  const num = (value) => Number(value);
+  const normalised = {
+    ...action,
+    move: { x: num(action.move?.x), y: num(action.move?.y) }
+  };
+  if (action.aimDirection !== void 0) normalised.aimDirection = num(action.aimDirection);
+  if (action.startCast?.spell === "missile") {
+    normalised.startCast = {
+      ...action.startCast,
+      ...action.startCast.direction !== void 0 ? { direction: num(action.startCast.direction) } : {}
+    };
+  } else if (action.startCast?.spell === "blink") {
+    normalised.startCast = {
+      ...action.startCast,
+      target: { x: num(action.startCast.target?.x), y: num(action.startCast.target?.y) }
+    };
+  }
+  return normalised;
 }
 
 // src/engine/physics.ts
@@ -551,6 +595,27 @@ function moveProjectile(projectile, deltaTicks) {
     y: projectile.position.y + Math.sin(radians) * projectile.speed * deltaTicks
   };
 }
+function clampToSafeZone(position, radius) {
+  const min = ARENA_MIN + radius;
+  const max = ARENA_MAX - radius;
+  const centre = ARENA_SIZE / 2;
+  const axis = (value) => {
+    if (!Number.isFinite(value)) return centre;
+    return Math.max(min, Math.min(max, value));
+  };
+  return { x: axis(position?.x), y: axis(position?.y) };
+}
+function moveTowardSafely(from, target) {
+  const dx = target?.x - from?.x;
+  const dy = target?.y - from?.y;
+  if (!Number.isFinite(dx) || !Number.isFinite(dy)) return { x: 0, y: 0 };
+  const distance = Math.sqrt(dx * dx + dy * dy);
+  if (distance === 0) return { x: 0, y: 0 };
+  if (distance >= RULES.MOVEMENT_SPEED) return { x: dx / distance, y: dy / distance };
+  const travel = Math.max(0, distance - 1e-6);
+  const fraction = travel / RULES.MOVEMENT_SPEED;
+  return { x: dx / distance * fraction, y: dy / distance * fraction };
+}
 function clampToArena(position, radius) {
   return {
     x: Math.max(radius, Math.min(ARENA_SIZE - radius, position.x)),
@@ -729,6 +794,69 @@ function createEntitySeed(matchSeed, entityId, tick2) {
   return combined;
 }
 
+// src/engine/bot-error-capture.ts
+var MAX_MESSAGE_LENGTH = 1e3;
+var MAX_ERRORS_PER_MATCH = 500;
+function describeThrown(thrown) {
+  return truncate(rawDescription(thrown));
+}
+function rawDescription(thrown) {
+  if (thrown instanceof Error) {
+    const message = typeof thrown.message === "string" ? thrown.message : "";
+    if (message.length > MAX_MESSAGE_LENGTH) {
+      return truncate(message) + " [stack omitted: message too large]";
+    }
+    const stack = typeof thrown.stack === "string" ? stripBundleCoordinates(thrown.stack.trim()) : "";
+    if (stack) return stack;
+    return message || `${thrown.name || "Error"} (thrown with no message)`;
+  }
+  if (typeof thrown === "string") return thrown || "(empty string thrown)";
+  if (thrown === null) return "null was thrown";
+  if (thrown === void 0) return "undefined was thrown";
+  try {
+    const json = JSON.stringify(thrown);
+    if (typeof json === "string" && json !== "{}") return json;
+  } catch {
+  }
+  try {
+    const text = String(thrown);
+    if (text === "[object Object]") return describeOpaqueObject(thrown);
+    return text;
+  } catch {
+    return "(a value was thrown that could not be described)";
+  }
+}
+function describeOpaqueObject(thrown) {
+  let name = "object";
+  try {
+    const ctor = thrown.constructor;
+    if (ctor && typeof ctor.name === "string" && ctor.name) name = ctor.name;
+  } catch {
+  }
+  let keys = [];
+  try {
+    keys = Object.keys(thrown).slice(0, 12);
+  } catch {
+  }
+  const shape = keys.length > 0 ? ` with keys: ${keys.join(", ")}` : " with no enumerable keys";
+  return `a non-serialisable ${name} was thrown${shape} (it could not be converted to text \u2014 usually a circular reference, or a getter that throws)`;
+}
+function stripBundleCoordinates(stack) {
+  return stack.replace(/\s*\((?:[^()\s]*match-bundle\.js|<isolated-vm>)[^()]*\)/g, "");
+}
+function truncate(message) {
+  if (message.length <= MAX_MESSAGE_LENGTH) return message;
+  const dropped = message.length - MAX_MESSAGE_LENGTH;
+  return `${message.slice(0, MAX_MESSAGE_LENGTH)}\u2026 [truncated, ${dropped} more characters]`;
+}
+function cappedNotice(entityId, tick2) {
+  return {
+    tick: tick2,
+    entityId,
+    message: `\u2026 stopped recording errors after ${MAX_ERRORS_PER_MATCH} in this match. The bot is still being called and still failing; only the recording stopped.`
+  };
+}
+
 // src/engine/simulation.ts
 function createInitialState(_seed, spawnDist = SPAWN_DISTANCE) {
   const center = { x: ARENA_SIZE / 2, y: ARENA_SIZE / 2 };
@@ -815,6 +943,7 @@ function buildWizardContext(state, config, random) {
 function tick(currentTick, wizard1AI, wizard2AI, config, wizards, projectiles, missileAIs, matchSeed, budgets) {
   const nextTick = currentTick + 1;
   const errors = [];
+  const budgetExhausted = [];
   const events = [];
   const random1 = createRandom(createEntitySeed(matchSeed, wizards[0].id, nextTick));
   const random2 = createRandom(createEntitySeed(matchSeed, wizards[1].id, nextTick));
@@ -822,13 +951,25 @@ function tick(currentTick, wizard1AI, wizard2AI, config, wizards, projectiles, m
   const nextBudgets = budgets ? [budgets.states[0], budgets.states[1]] : void 0;
   const runBot = (index, entityId, invoke) => {
     const state = nextBudgets?.[index];
-    if (state && !mayAct(state)) return IDLE_ACTION();
+    if (state && !mayAct(state)) {
+      if (!state.reported) {
+        state.reported = true;
+        budgetExhausted.push({ tick: nextTick, entityId, spentMs: state.spentMs });
+      }
+      return IDLE_ACTION();
+    }
     const startedAt = state ? Date.now() : 0;
     let action;
     try {
       action = invoke();
     } catch (e) {
-      errors.push({ tick: nextTick, entityId, message: e instanceof Error ? e.message : String(e) });
+      const alreadyDead = (wizards[index]?.health ?? 1) <= 0;
+      errors.push({
+        tick: nextTick,
+        entityId,
+        message: describeThrown(e),
+        ...alreadyDead ? { afterDeath: true } : {}
+      });
       action = IDLE_ACTION();
     }
     if (state && budgets) {
@@ -911,10 +1052,12 @@ function tick(currentTick, wizard1AI, wizard2AI, config, wizards, projectiles, m
           delete wizard.missileConfig;
           delete wizard.missileAI;
         } else if (spell === "blink" && wizard.blinkTarget) {
-          const dx = wizard.blinkTarget.x - wizard.position.x;
-          const dy = wizard.blinkTarget.y - wizard.position.y;
+          const targetX = Number.isFinite(wizard.blinkTarget.x) ? wizard.blinkTarget.x : wizard.position.x;
+          const targetY = Number.isFinite(wizard.blinkTarget.y) ? wizard.blinkTarget.y : wizard.position.y;
+          const dx = targetX - wizard.position.x;
+          const dy = targetY - wizard.position.y;
           const distance = Math.sqrt(dx * dx + dy * dy);
-          let targetPos = wizard.blinkTarget;
+          let targetPos = { x: targetX, y: targetY };
           if (distance > RULES.BLINK_RANGE) {
             const scale = RULES.BLINK_RANGE / distance;
             targetPos = {
@@ -1043,12 +1186,12 @@ function tick(currentTick, wizard1AI, wizard2AI, config, wizards, projectiles, m
             () => extractMissileAction(withMissileContext(missileCtx, ai))
           ) ?? {};
         } catch (e) {
-          errors.push({ tick: nextTick, entityId: projectile.id, message: e instanceof Error ? e.message : String(e) });
+          errors.push({ tick: nextTick, entityId: projectile.id, message: describeThrown(e) });
         }
         targetAngle = missileActions.turnToward ? angleTo(projectile.position, missileActions.turnToward) : missileActions.turnToAngle !== void 0 ? missileActions.turnToAngle : null;
       }
     }
-    if (targetAngle !== null) {
+    if (targetAngle !== null && Number.isFinite(targetAngle)) {
       const diff = angleDiff(projectile.rotation, targetAngle);
       const turn = Math.max(-projectile.turnRate, Math.min(projectile.turnRate, diff));
       projectile.rotation = normalizeAngle(projectile.rotation + turn);
@@ -1109,6 +1252,7 @@ function tick(currentTick, wizard1AI, wizard2AI, config, wizards, projectiles, m
     projectiles: remainingProjectiles,
     events,
     errors,
+    budgetExhausted,
     budgets: nextBudgets
   };
 }
@@ -1248,6 +1392,7 @@ var FIGHT_SPAWN_DISTANCES = [500, 550, 600, 650, 700];
 function fight(wizard1AI, wizard2AI, options = {}) {
   const matches = [];
   const allErrors = [];
+  const allBudgetExhausted = [];
   let matchNumber = 1;
   let wizard1Wins = 0;
   let wizard2Wins = 0;
@@ -1262,6 +1407,7 @@ function fight(wizard1AI, wizard2AI, options = {}) {
     });
     matches.push(result);
     allErrors.push(...result.errors.map((e) => ({ ...e, match: matchNumber })));
+    allBudgetExhausted.push(...result.budgetExhausted.map((b) => ({ ...b, match: matchNumber })));
     matchNumber++;
     if (result.winner === "wizard-1") {
       wizard1Wins++;
@@ -1282,6 +1428,7 @@ function fight(wizard1AI, wizard2AI, options = {}) {
       budget.states = [swappedBudget.states[1], swappedBudget.states[0]];
     }
     allErrors.push(...swapped.errors.map((e) => ({ ...e, entityId: swapSide(e.entityId), match: matchNumber })));
+    allBudgetExhausted.push(...swapped.budgetExhausted.map((b) => ({ ...b, entityId: swapSide(b.entityId), match: matchNumber })));
     matchNumber++;
     if (swapped.winner === "wizard-1") {
       wizard2Wins++;
@@ -1292,7 +1439,7 @@ function fight(wizard1AI, wizard2AI, options = {}) {
     }
   }
   const winner = wizard1Wins > wizard2Wins ? "wizard-1" : wizard2Wins > wizard1Wins ? "wizard-2" : "draw";
-  return { wizard1Wins, wizard2Wins, draws, winner, matches, allErrors };
+  return { wizard1Wins, wizard2Wins, draws, winner, matches, allErrors, budgetExhausted: allBudgetExhausted };
 }
 function simulate(wizard1AI, wizard2AI, options = {}) {
   if (typeof wizard1AI !== "function") {
@@ -1345,6 +1492,7 @@ function simulate(wizard1AI, wizard2AI, options = {}) {
   let projectiles = [];
   const missileAIs = /* @__PURE__ */ new Map();
   const allErrors = [];
+  const allBudgetExhausted = [];
   let deathTick = null;
   const sharedBudget = options.budget;
   const budgetLimits = sharedBudget?.limits ?? options.budgetLimits;
@@ -1368,7 +1516,15 @@ function simulate(wizard1AI, wizard2AI, options = {}) {
     currentTick = result.nextTick;
     wizards = result.wizards;
     projectiles = result.projectiles;
-    if (result.errors.length > 0) allErrors.push(...result.errors);
+    for (const error of result.errors) {
+      if (allErrors.length > MAX_ERRORS_PER_MATCH) break;
+      if (allErrors.length === MAX_ERRORS_PER_MATCH) {
+        allErrors.push(cappedNotice(error.entityId, error.tick));
+        break;
+      }
+      allErrors.push(error);
+    }
+    if (result.budgetExhausted.length > 0) allBudgetExhausted.push(...result.budgetExhausted);
     if (!skipHistory) {
       history.push(getPlayerState(0, wizards, projectiles, currentTick, result.events));
     }
@@ -1393,7 +1549,8 @@ function simulate(wizard1AI, wizard2AI, options = {}) {
     ticks: currentTick,
     finalState,
     history: skipHistory ? [] : history,
-    errors: allErrors
+    errors: allErrors,
+    budgetExhausted: allBudgetExhausted
   };
 }
 
@@ -1567,7 +1724,9 @@ var ManualMatch = class {
       ticks: this.currentTick,
       finalState: this.getGameState(),
       history: this.history,
-      errors: this.allErrors
+      errors: this.allErrors,
+      // Manual play is unbudgeted — the clock is never read, so nobody can be cut off.
+      budgetExhausted: []
     };
   }
   dispose() {
@@ -1975,7 +2134,8 @@ function analyzeOneThreat(targetPos, projectile, ticksUntilReady) {
       targetPos,
       canDodgeLeft,
       canDodgeRight,
-      canOutrun
+      canOutrun,
+      ticksToImpact
     );
   }
   const canBlockInTime = ticksToImpact > ticksUntilReady + RULES.SHIELD_CAST_TIME + 1;
@@ -2090,15 +2250,28 @@ function getDodgeDirection(projectile, targetPos, direction) {
       return { x: 0, y: 0 };
   }
 }
-function calculateBestDodgeDirection(projectile, targetPos, canDodgeLeft, canDodgeRight, canOutrun) {
-  if (canDodgeLeft && canDodgeRight) {
-    return getDodgeDirection(projectile, targetPos, "left");
-  } else if (canDodgeLeft) {
-    return getDodgeDirection(projectile, targetPos, "left");
-  } else if (canDodgeRight) {
-    return getDodgeDirection(projectile, targetPos, "right");
-  } else if (canOutrun) {
-    return getDodgeDirection(projectile, targetPos, "away");
+function roomBeforeLava(from, dir) {
+  const min = ARENA_MIN + COLLISION_RADIUS;
+  const max = ARENA_MAX - COLLISION_RADIUS;
+  const along = (pos, d, lo, hi) => {
+    if (Math.abs(d) < 1e-9) return Number.POSITIVE_INFINITY;
+    return d > 0 ? (hi - pos) / d : (lo - pos) / d;
+  };
+  return Math.max(0, Math.min(along(from.x, dir.x, min, max), along(from.y, dir.y, min, max)));
+}
+function calculateBestDodgeDirection(projectile, targetPos, canDodgeLeft, canDodgeRight, canOutrun, ticksToImpact) {
+  const travel = RULES.MOVEMENT_SPEED * Math.max(1, Math.min(ticksToImpact, 600));
+  const survives = (dir) => roomBeforeLava(targetPos, dir) >= travel;
+  const sides = [];
+  if (canDodgeLeft) sides.push(getDodgeDirection(projectile, targetPos, "left"));
+  if (canDodgeRight) sides.push(getDodgeDirection(projectile, targetPos, "right"));
+  const safeSides = sides.filter(survives);
+  if (safeSides.length > 0) {
+    return safeSides.reduce((best, dir) => roomBeforeLava(targetPos, dir) > roomBeforeLava(targetPos, best) ? dir : best);
+  }
+  if (canOutrun) {
+    const away = getDodgeDirection(projectile, targetPos, "away");
+    if (survives(away)) return away;
   }
   return null;
 }
@@ -10585,6 +10758,8 @@ export {
   extractAction,
   moveWizard,
   moveProjectile,
+  clampToSafeZone,
+  moveTowardSafely,
   clampToArena,
   isInLava,
   resolveWizardCollision,
@@ -10723,4 +10898,4 @@ export {
   diagnoseTrace,
   formatDiagnosis
 };
-//# sourceMappingURL=chunk-OLGKLCCB.js.map
+//# sourceMappingURL=chunk-EO7JO2RZ.js.map