@vibemancer/core 1.0.11 → 1.0.13

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

@@ -213,7 +213,7 @@ function currentRuleset() {
 }
 
 // src/engine-version.ts
-var ENGINE_VERSION = 2983169471988242;
+var ENGINE_VERSION = 4256327861353618;
 var EQUIVALENT_ENGINE_VERSIONS = [1688330189011034];
 
 // src/replay-compat.ts
@@ -516,23 +516,28 @@ function flyStraight() {
     _toMissileAction: () => ({})
   };
 }
+function 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 function is `async`, and it must not be: remove the async keyword";
+    }
+    return "a plain object";
+  }
+  return `a ${typeof value}`;
+}
 function extractMissileAction(action) {
+  if (action === null || action === void 0 || typeof action._toMissileAction !== "function") {
+    throw new Error(
+      `Your missile AI returned ${describeReturned(action)}. Return turnToward(x, y), turnToAngle(degrees) or flyStraight(). The missile AI runs once per tick for every missile you have in flight, and it must return one of those every time.`
+    );
+  }
   return action._toMissileAction();
 }
 function extractAction(finalAction) {
   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.`
@@ -670,7 +675,8 @@ function startCast(wizard, spell, config) {
   wizard.castingSpell = spell;
   wizard.castProgress = 0;
   if (spell === "missile" && config) {
-    const castTimeSec = calculateMissileCastTime(config, wizard.lastMissileConfig);
+    const validated = validateMissileConfig(config);
+    const castTimeSec = calculateMissileCastTime(validated, wizard.lastMissileConfig);
     wizard.castDuration = Math.max(1, Math.round(castTimeSec * TICKS_PER_SECOND));
     wizard.warmupMultiplier = calculateWarmupMultiplier(wizard.lastMissileConfig, config);
   } else if (spell === "shield") {
@@ -798,32 +804,33 @@ function createEntitySeed(matchSeed, entityId, tick2) {
 var MAX_MESSAGE_LENGTH = 1e3;
 var MAX_ERRORS_PER_MATCH = 500;
 function describeThrown(thrown) {
-  return truncate(rawDescription(thrown));
+  const { text, alreadyBounded } = rawDescription(thrown);
+  return alreadyBounded ? text : truncate(text);
 }
 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]";
+      return { text: truncate(message) + " [stack omitted: message too large]", alreadyBounded: true };
     }
     const stack = typeof thrown.stack === "string" ? stripBundleCoordinates(thrown.stack.trim()) : "";
-    if (stack) return stack;
-    return message || `${thrown.name || "Error"} (thrown with no message)`;
+    if (stack) return { text: stack, alreadyBounded: false };
+    return { text: message || `${thrown.name || "Error"} (thrown with no message)`, alreadyBounded: false };
   }
-  if (typeof thrown === "string") return thrown || "(empty string thrown)";
-  if (thrown === null) return "null was thrown";
-  if (thrown === void 0) return "undefined was thrown";
+  if (typeof thrown === "string") return { text: thrown || "(empty string thrown)", alreadyBounded: false };
+  if (thrown === null) return { text: "null was thrown", alreadyBounded: false };
+  if (thrown === void 0) return { text: "undefined was thrown", alreadyBounded: false };
   try {
     const json = JSON.stringify(thrown);
-    if (typeof json === "string" && json !== "{}") return json;
+    if (typeof json === "string" && json !== "{}") return { text: json, alreadyBounded: false };
   } catch {
   }
   try {
     const text = String(thrown);
-    if (text === "[object Object]") return describeOpaqueObject(thrown);
-    return text;
+    if (text === "[object Object]") return { text: describeOpaqueObject(thrown), alreadyBounded: false };
+    return { text, alreadyBounded: false };
   } catch {
-    return "(a value was thrown that could not be described)";
+    return { text: "(a value was thrown that could not be described)", alreadyBounded: false };
   }
 }
 function describeOpaqueObject(thrown) {
@@ -842,7 +849,7 @@ function describeOpaqueObject(thrown) {
   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, "");
+  return stack.replace(/\s*\((?:[^()\s]*match-bundle\.js|<isolated-vm>)[^()]*\)/g, "").replace(/(\s*at )(?:[^()\s]*match-bundle\.js|<isolated-vm>)[^\s)]*/g, "$1<your bot>");
 }
 function truncate(message) {
   if (message.length <= MAX_MESSAGE_LENGTH) return message;
@@ -940,6 +947,18 @@ function buildWizardContext(state, config, random) {
     lastHitTick: state.lastHitTick
   };
 }
+function nonFiniteField(move2, action, wizard) {
+  const bad = (v) => typeof v === "number" && !Number.isFinite(v);
+  if (bad(move2?.x)) return { what: "move(x, y): x", value: String(move2.x) };
+  if (bad(move2?.y)) return { what: "move(x, y): y", value: String(move2.y) };
+  const target = action.startCast?.spell === "blink" ? action.startCast.target : void 0;
+  if (bad(target?.x)) return { what: "blink(x, y): x", value: String(target.x) };
+  if (bad(target?.y)) return { what: "blink(x, y): y", value: String(target.y) };
+  if (bad(wizard.blinkTarget?.x)) return { what: "blink(x, y): x", value: String(wizard.blinkTarget.x) };
+  if (bad(wizard.blinkTarget?.y)) return { what: "blink(x, y): y", value: String(wizard.blinkTarget.y) };
+  if (bad(action.aimDirection)) return { what: "aim(degrees)", value: String(action.aimDirection) };
+  return null;
+}
 function tick(currentTick, wizard1AI, wizard2AI, config, wizards, projectiles, missileAIs, matchSeed, budgets) {
   const nextTick = currentTick + 1;
   const errors = [];
@@ -1083,6 +1102,17 @@ function tick(currentTick, wizard1AI, wizard2AI, config, wizards, projectiles, m
     }
     const oldPos = wizard.position;
     const move2 = action.move ?? { x: 0, y: 0 };
+    if (!wizard.advised?.nonFinite) {
+      const bad = nonFiniteField(move2, action, wizard);
+      if (bad) {
+        wizard.advised = { ...wizard.advised, nonFinite: true };
+        errors.push({
+          tick: nextTick,
+          entityId: wizard.id,
+          message: `${bad.what} is not a finite number (it was ${bad.value}). The engine ignored it to keep the match running \u2014 the value is treated as zero, so your wizard simply does not do what you asked. This is almost always a divide-by-zero or a subtraction of two equal positions somewhere in your maths. Reported once per match.`
+        });
+      }
+    }
     wizard.position = moveWizard(wizard, move2, 1);
     if (wizard.knockbackDelay !== void 0 && wizard.knockbackDelay > 0) {
       wizard.knockbackDelay--;
@@ -1129,6 +1159,15 @@ function tick(currentTick, wizard1AI, wizard2AI, config, wizards, projectiles, m
         const castingSpell = action.startCast.spell;
         startCast(wizard, castingSpell, castingSpell === "missile" ? action.startCast.config : void 0);
         if (castingSpell === "missile") {
+          if ((wizard.castDuration ?? 0) > MATCH_DURATION && !wizard.advised?.unfinishableCast) {
+            wizard.advised = { ...wizard.advised, unfinishableCast: true };
+            const config2 = action.startCast.config;
+            errors.push({
+              tick: nextTick,
+              entityId: wizard.id,
+              message: `This missile takes ${wizard.castDuration} ticks to cast, but a match is only ${MATCH_DURATION} ticks long, so the cast can never finish and this wizard will stand still for the rest of the match. The cost is dominated by turnRate (${config2?.turnRate ?? "?"}) \u2014 it is the most expensive field by far, and unlike the others it is not clamped to a sane maximum. Try a turnRate in the single digits, then use missile-calc or getMissileCastTime() to check the cast time before committing to a config.`
+            });
+          }
           wizard.missileConfig = action.startCast.config;
           wizard.missileAI = action.startCast.missileAI;
           if (action.startCast.direction !== void 0) {
@@ -2095,13 +2134,14 @@ function fitMissileForEscapingTarget(currentDistance, budgetTicks, options) {
 }
 
 // src/hooks/threat-analysis.ts
+var CANCEL_COST_TICKS = 1;
 var THREAT_RELEVANCE_DISTANCE = 500;
-function analyzeThreats(myPos, projectiles, myProjectiles, ticksUntilReady) {
+function analyzeThreats(myPos, projectiles, myProjectiles, ticksUntilReady, options) {
   const myProjectileIds = new Set(myProjectiles.map((p) => p.id));
   const enemyProjectiles = projectiles.filter((p) => !myProjectileIds.has(p.id));
   const threats = [];
   for (const projectile of enemyProjectiles) {
-    const analysis = analyzeOneThreat(myPos, projectile, ticksUntilReady);
+    const analysis = analyzeOneThreat(myPos, projectile, ticksUntilReady, options?.canCancelCurrentCast ?? false);
     const missileDistance = Math.sqrt(
       (projectile.position.x - myPos.x) ** 2 + (projectile.position.y - myPos.y) ** 2
     );
@@ -2112,7 +2152,7 @@ function analyzeThreats(myPos, projectiles, myProjectiles, ticksUntilReady) {
   threats.sort((a, b) => a.ticksToImpact - b.ticksToImpact);
   return threats;
 }
-function analyzeOneThreat(targetPos, projectile, ticksUntilReady) {
+function analyzeOneThreat(targetPos, projectile, ticksUntilReady, canCancelCurrentCast) {
   const missileRadius = calculateMissileRadius(projectile.damage);
   const collisionDist = COLLISION_RADIUS + missileRadius;
   const dodgeCollisionDist = collisionDist + projectile.speed * 0.5;
@@ -2138,8 +2178,10 @@ function analyzeOneThreat(targetPos, projectile, ticksUntilReady) {
       ticksToImpact
     );
   }
-  const canBlockInTime = ticksToImpact > ticksUntilReady + RULES.SHIELD_CAST_TIME + 1;
-  const ticksToStartShield = Math.max(0, ticksToImpact - RULES.SHIELD_CAST_TIME - 1);
+  const delayBeforeShield = canCancelCurrentCast ? CANCEL_COST_TICKS : ticksUntilReady;
+  const ticksNeededToBlock = delayBeforeShield + RULES.SHIELD_CAST_TIME + 1;
+  const canBlockInTime = ticksToImpact >= ticksNeededToBlock;
+  const ticksToStartShield = Math.max(0, ticksToImpact - ticksNeededToBlock);
   return {
     id: projectile.id,
     projectile,
@@ -2414,9 +2456,13 @@ function useThreats() {
       ctx.position,
       ctx.projectiles,
       ctx.myProjectiles,
-      ticksUntilReady
+      ticksUntilReady,
+      // Mid-CAST you are one cancel() away from being able to shield, so the analysis
+      // must not charge you the whole remainder of the cast. A GCD cannot be cancelled,
+      // so it keeps the pessimistic reading.
+      { canCancelCurrentCast: ctx.state === "casting" }
     );
-  }, [ctx.projectiles, ctx.myProjectiles, ctx.position.x, ctx.position.y, ticksUntilReady]);
+  }, [ctx.projectiles, ctx.myProjectiles, ctx.position.x, ctx.position.y, ticksUntilReady, ctx.state]);
 }
 function useClosestThreat() {
   const threats = useThreats();
@@ -10898,4 +10944,4 @@ export {
   diagnoseTrace,
   formatDiagnosis
 };
-//# sourceMappingURL=chunk-EO7JO2RZ.js.map
+//# sourceMappingURL=chunk-KGRG7TZS.js.map