@orakl/shared 0.2.0 → 0.3.1

package/dist/badges.d.ts

@@ -37,12 +37,14 @@ export type BadgeContext = {
     /** Rounds this player alone was right with the field answering (Lone torch). */
     soleCorrectRounds?: number;
     /**
-     * This player's rank after each closed round, with the field size then;
-     * null for rounds before they held a hero slot (Ascendant, Undisputed).
+     * This player's rank after each closed round, with the field size then
+     * and whether their score was strictly above everyone else's; null for
+     * rounds before they held a hero slot (Ascendant, Undisputed).
      */
     rankHistory?: Array<{
         rank: number;
         field: number;
+        lead: boolean;
     } | null>;
 };
 export interface BadgeInput {
@@ -110,7 +112,8 @@ export interface FieldLogEntry {
 /**
  * Field-relative round counts for `playerId` from every tenured player's log.
  * The field for a round is the other players' submitted answers; a miss-filled
- * row (a leaver, or a timeout) is not a wrong answer and is left out.
+ * row (a leaver, or a timeout) is not a wrong answer and is left out. Round
+ * tallies are cached per `logs` map, so `logs` must not change between calls.
  */
 export declare function fieldRoundStats(playerId: string, logs: ReadonlyMap<string, readonly FieldLogEntry[]>): {
     fieldRoundsDefied: number;

package/dist/badges.js

@@ -167,7 +167,7 @@ export const BADGES = {
     "master-of-none": {
         id: "master-of-none",
         label: "Many-sided",
-        description: "Earned four other badges in one run spanning four or more categories.",
+        description: "Earned five other badges in one run spanning four or more categories.",
         icon: "dice",
         modes: CROSS_MODE,
     },
@@ -302,7 +302,7 @@ const SURVIVOR_QUESTIONS = 20;
 /** Distinct categories a run must span for the Many-sided meta-badge. */
 const MASTER_OF_NONE_MIN_CATEGORIES = 3;
 /** Other badges that must be earned alongside the breadth for Many-sided. */
-const MASTER_OF_NONE_MIN_BADGES = 3;
+const MASTER_OF_NONE_MIN_BADGES = 4;
 /** Accuracy (0–1) on a hard run that earns giant-slayer. */
 const GIANT_SLAYER_ACCURACY = 0.9;
 /** Minimum answers before giant-slayer is meaningful. */
@@ -371,32 +371,64 @@ const LONE_TORCH_MIN_HEROES = 5;
 const LONE_TORCH_MIN_SUBMITTERS = 4;
 /** Places Ascendant must climb from the midpoint snapshot. */
 const ASCENDANT_MIN_CLIMB = 2;
+/** Per-round submitted/correct totals across every log (first row per round). */
+function tallyRounds(logs) {
+    const tallies = new Map();
+    for (const log of logs.values()) {
+        const seen = new Set();
+        for (const e of log) {
+            if (seen.has(e.questionIndex))
+                continue;
+            seen.add(e.questionIndex);
+            if (!e.submitted)
+                continue;
+            let t = tallies.get(e.questionIndex);
+            if (!t) {
+                t = { submitted: 0, correct: 0 };
+                tallies.set(e.questionIndex, t);
+            }
+            t.submitted++;
+            if (e.isCorrect)
+                t.correct++;
+        }
+    }
+    return tallies;
+}
+// Keyed by the logs map so a final-scores pass tallies once for all players.
+const tallyCache = new WeakMap();
 /**
  * Field-relative round counts for `playerId` from every tenured player's log.
  * The field for a round is the other players' submitted answers; a miss-filled
- * row (a leaver, or a timeout) is not a wrong answer and is left out.
+ * row (a leaver, or a timeout) is not a wrong answer and is left out. Round
+ * tallies are cached per `logs` map, so `logs` must not change between calls.
  */
 export function fieldRoundStats(playerId, logs) {
+    let tallies = tallyCache.get(logs);
+    if (!tallies) {
+        tallies = tallyRounds(logs);
+        tallyCache.set(logs, tallies);
+    }
     let fieldRoundsDefied = 0;
     let soleCorrectRounds = 0;
-    for (const entry of logs.get(playerId) ?? []) {
+    const own = logs.get(playerId) ?? [];
+    const firstOwn = new Map();
+    for (const e of own) {
+        if (!firstOwn.has(e.questionIndex))
+            firstOwn.set(e.questionIndex, e);
+    }
+    for (const entry of own) {
         if (!entry.isCorrect)
             continue;
-        let others = 0;
-        let wrong = 0;
-        let othersCorrect = 0;
-        for (const [id, log] of logs) {
-            if (id === playerId)
-                continue;
-            const other = log.find((e) => e.questionIndex === entry.questionIndex);
-            if (!other?.submitted)
-                continue;
-            others++;
-            if (other.isCorrect)
-                othersCorrect++;
-            else
-                wrong++;
+        const t = tallies.get(entry.questionIndex);
+        let others = t?.submitted ?? 0;
+        let othersCorrect = t?.correct ?? 0;
+        const mine = firstOwn.get(entry.questionIndex);
+        if (mine?.submitted) {
+            others--;
+            if (mine.isCorrect)
+                othersCorrect--;
         }
+        const wrong = others - othersCorrect;
         if (others >= CASSANDRA_MIN_OTHERS &&
             wrong / others >= CASSANDRA_WRONG_SHARE) {
             fieldRoundsDefied++;
@@ -746,7 +778,7 @@ export function computeBadges(input) {
         if (victorGates &&
             context.rank === 1 &&
             history.length >= 2 &&
-            history.slice(1).every((h) => h?.rank === 1)) {
+            history.slice(1).every((h) => h?.rank === 1 && h.lead)) {
             eligible.push({ id: "undisputed", detail: "first from round two" });
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orakl/shared",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "Orakl runtime helpers shared by the web client and the engine.",
   "license": "AGPL-3.0-only",
   "repository": {