Revert "hotfix: unwinding the peak logic."

miaklwalker · miaklwalker · commit 48c588b49caf · 2026-01-25T14:54:10.000-06:00
This reverts commit e3c39d3.
diff --git a/___tests___/spoiler_peek.spec.ts b/___tests___/spoiler_peek.spec.ts
@@ -0,0 +1,48 @@
+import { expect, test } from "vitest";
+import { analyzeSeed } from "../src/modules/ImmolateWrapper";
+import { options } from "../src/modules/const";
+
+function getAnte2BossArcanaSpoilerJokers(cardsPerAnte: number): string[] {
+  const results = analyzeSeed(
+    {
+      seed: "TYTWAA1P",
+      deck: "Plasma Deck",
+      stake: "White Stake",
+      gameVersion: "10106",
+      antes: 2,
+      cardsPerAnte,
+    },
+    {
+      buys: {},
+      sells: {},
+      showCardSpoilers: true,
+      unlocks: options,
+      events: [],
+      lockedCards: {},
+    }
+  ) as any;
+
+  const packs = results?.antes?.[2]?.blinds?.bossBlind?.packs ?? [];
+  const arcanaPacks = packs.filter((p: any) => p?.name === "Arcana");
+  const jokerNames = arcanaPacks.flatMap((p: any) =>
+    (p?.cards ?? [])
+      .filter((c: any) => c?.type === "Joker")
+      .map((c: any) => c?.name)
+  );
+
+  return jokerNames;
+}
+
+test("TYTWAA1P: Judgement spoiler does not change when Cards per Ante changes", () => {
+  const at50 = getAnte2BossArcanaSpoilerJokers(50);
+  const at100 = getAnte2BossArcanaSpoilerJokers(100);
+  const at150 = getAnte2BossArcanaSpoilerJokers(150);
+
+  expect(at50.length).toBeGreaterThan(0);
+  expect(at50).toEqual(at100);
+  expect(at50).toEqual(at150);
+
+  expect(at50).toContain("Ice Cream");
+  expect(at50).not.toContain("Sixth Sense");
+});
+
diff --git a/src/modules/ImmolateWrapper/index.ts b/src/modules/ImmolateWrapper/index.ts
@@ -544,7 +544,7 @@ export function analyzeSeed(settings: AnalyzeSettings, analyzeOptions: AnalyzeOp
             const shopItem = engine.nextShopItem(ante);
             const spoilerSource = engine.hasSpoilersMap[shopItem.item.name];
             if (engine.hasSpoilers && spoilerSource) {
-                const joker: JokerData = engine.nextJoker(spoilerSource, ante, true);
+                const joker: JokerData = engine.peekJoker(spoilerSource, ante, true);
                 result.queue.push(
                     engineWrapper.makeGameCard(joker)
                 )
@@ -560,7 +560,7 @@ export function analyzeSeed(settings: AnalyzeSettings, analyzeOptions: AnalyzeOp
             if (analyzeOptions && analyzeOptions?.showCardSpoilers) {
                 if (itemsWithSpoilers.includes(result.queue[i].name as SpoilableItems)) {
                     // @ts-expect-error reports types dont match.
-                    result.queue[i] = Pack.PackCardToCard(engine.nextJoker(spoilerSources[itemsWithSpoilers.indexOf(result.queue[i].name)], ante, false), 'Joker')
+                    result.queue[i] = Pack.PackCardToCard(engine.peekJoker(spoilerSources[itemsWithSpoilers.indexOf(result.queue[i].name)], ante, false), 'Joker')
                 }
             }
             if (analyzeOptions && analyzeOptions.buys[key]) {
@@ -671,7 +671,7 @@ export function analyzeSeed(settings: AnalyzeSettings, analyzeOptions: AnalyzeOp
                 const spoilerSource = engine.hasSpoilersMap[card.name];
                 // @ts-ignore
                 if (engine.hasSpoilers && spoilerSource) {
-                    card = engine.nextJoker(spoilerSource, ante, true)
+                    card = engine.peekJoker(spoilerSource, ante, true)
                 }
                 const generatedCard = engineWrapper.makeGameCard(card);
                 // @ts-ignore
diff --git a/src/modules/balatrots/BalatroAnalyzer.ts b/src/modules/balatrots/BalatroAnalyzer.ts
@@ -238,7 +238,7 @@ export class BalatroAnalyzer {
 
                 if (this.hasSpoilers && isSpoilable) {
                     const spoilerSource = this.hasSpoilersMap[card.name as SpoilableItems];
-                    const joker = game.nextJoker(spoilerSource, this.result.ante, true);
+                    const joker = game.peekJoker(spoilerSource, this.result.ante, true);
                     BalatroAnalyzer.getSticker(joker);
                     card = joker
                     run.addJoker(card.joker.name);
@@ -257,7 +257,7 @@ export class BalatroAnalyzer {
         const spoilerSource = Object.keys(this.hasSpoilersMap)
             .includes(shopItem.item.name);
         if (this.hasSpoilers && spoilerSource) {
-            const joker: JokerData = game.nextJoker(this.hasSpoilersMap[shopItem.item.name as SpoilableItems], ante, true);
+            const joker: JokerData = game.peekJoker(this.hasSpoilersMap[shopItem.item.name as SpoilableItems], ante, true);
             run.addJoker(joker.joker.getName());
             BalatroAnalyzer.getSticker(joker);
             this.result.addItemToShopQueue(joker);
@@ -323,7 +323,7 @@ export class BalatroAnalyzer {
                 if (item === "The Soul") {
                     run.hasTheSoul = true;
                 }
-                const joker = game.nextJoker(spoilerSource, this.result.ante, true);
+                const joker = game.peekJoker(spoilerSource, this.result.ante, true);
                 run.addJoker(joker.joker.getName());
                 const sticker = BalatroAnalyzer.getSticker(joker);
                 options.add(new Option(joker.joker, new ItemImpl(sticker)));
diff --git a/src/modules/balatrots/Cache.ts b/src/modules/balatrots/Cache.ts
@@ -74,4 +74,4 @@ export class Cache {
         }
         this.nodes.set(key, value);
     }
-}
+}
diff --git a/src/modules/balatrots/Game.ts b/src/modules/balatrots/Game.ts
@@ -346,6 +346,11 @@ export class Game extends Lock {
         this.hasSpoilers = false;
     }
 
+    private withCacheState<T>(fn: () => T): T {
+        // Roll back only the keys mutated during `fn` (cheap), instead of copying the whole cache.
+        return this.cache.withRollback(fn);
+    }
+
     private getNode(id: string) {
         let c = this.cache.getNode(id);
 
@@ -653,6 +658,14 @@ export class Game extends Lock {
         return new JokerData(joker, rarity, edition, stickers);
     }
 
+    /**
+     * Returns what `nextJoker(...)` would return, but does NOT advance RNG/cache state.
+     * Intended for spoiler/peek UI.
+     */
+    peekJoker(source: QueueNames, ante: number, hasStickers: boolean): JokerData {
+        return this.withCacheState(() => this.nextJoker(source, ante, hasStickers));
+    }
+
     getShopInstance(): ShopInstance {
         let tarotRate = 4;
         let planetRate = 4;
@@ -1031,7 +1044,7 @@ export class Game extends Lock {
             const item = (card as ItemImpl).getName();
             const spoilerSource = this.hasSpoilersMap[item];
             if (this.hasSpoilers) {
-                return this.nextJoker(spoilerSource, ante, false)
+                return this.peekJoker(spoilerSource, ante, false)
             }
             return card as Card;
         }
@@ -1132,18 +1145,18 @@ item wheel_of_fortune_edition(instance* inst) {
         }
         return (value + this.hashedSeed) / 2;
     }
-    static get CARDS_ABANDONED(): Array<Card> {
+    static get CARDS_ABANDONED(): Card[] {
         // Abandoned Deck: 40 cards, no face cards (J, Q, K).
         return this.CARDS.filter(c => {
             const name = c.getName();
             return !name.includes("_J") && !name.includes("_Q") && !name.includes("_K");
         }).map(c => new Card(c.getName() as PlayingCard));
     }
 
-    static get CARDS_CHECKERED(): Array<Card> {
+    static get CARDS_CHECKERED(): Card[] {
         // Checkered Deck: 52 cards (Hearts/Spades only).
         return this.CARDS.map(c => {
-            const name = c.getName();
+            const name = c.getName() as string;
             const rank = name.split("_")[1];
             const suit = name.split("_")[0];
             let newSuit = suit;
@@ -1156,9 +1169,9 @@ item wheel_of_fortune_edition(instance* inst) {
     /**
      * Returns a fully shuffled deck for the given ante and round index (1, 2, or 3).
      */
-    private getShuffledDeck(ante: number, round: number = 1): Array<Card> {
+    private getShuffledDeck(ante: number, round: number = 1): Card[] {
         const deckType = this.params.getDeck().name;
-        let cards: Array<Card>;
+        let cards: Card[];
 
         switch (deckType) {
             case deckNames[DeckType.ABANDONED_DECK]:
@@ -1168,7 +1181,7 @@ item wheel_of_fortune_edition(instance* inst) {
                 cards = Game.CARDS_CHECKERED;
                 break;
             case deckNames[DeckType.ERRATIC_DECK]: {
-                const randomizedCards: Array<Card> = [];
+                const randomizedCards: Card[] = [];
                 for(let i = 0; i < 52; i++){
                     const card = this.randchoice_simple(RandomQueueNames.R_Erratic, Game.CARDS);
                     randomizedCards.push(new Card(card.getName() as PlayingCard));
@@ -1185,7 +1198,7 @@ item wheel_of_fortune_edition(instance* inst) {
 
         for (let i = cards.length - 1; i >= 1; i--) {
             const j = rng.randint(1, i + 1) -1;
-            const temp = cards[i];
+            let temp = cards[i];
             cards[i] = cards[j];
             cards[j] = temp;
 
@@ -1202,29 +1215,13 @@ item wheel_of_fortune_edition(instance* inst) {
      * @param round The round index within the ante (1, 2, or 3) (default 1)
      * @param count Number of cards to draw (default 8)
      */
-    getDeckDraw(ante: number, round: number = 1, count: number = 8): Array<Card> {
+    getDeckDraw(ante: number, round: number = 1, count: number = 8): Card[] {
         const deck = this.getShuffledDeck(ante, round);
         return deck.slice(0, count);
     }
 
-    getStartingDeckDraw(count = 8, sort: 'rank' | 'suit' = 'rank'): Array<Card> {
+    getStartingDeckDraw(): Card[] {
         // pifreak loves you!
-        const hand =  this.getDeckDraw(1, 1, count);
-        if (sort === 'rank') {
-            return hand.sort((a, b) => {
-                const rankA = parseInt(a.getName().split('_')[1]);
-                const rankB = parseInt(b.getName().split('_')[1]);
-                return rankA - rankB;
-            });
-        }
-        else {
-            const suitOrder: Record<string, number> = { 'C': 1, 'D': 2, 'H': 3, 'S': 4 };
-            return hand.sort((a, b) => {
-                const suitA = a.getName().split('_')[0];
-                const suitB = b.getName().split('_')[0];
-                return suitOrder[suitA] - suitOrder[suitB];
-            });
-        }
+        return this.getDeckDraw(1, 1, 8);
     }
 }
-
diff --git a/src/modules/balatrots/Lock.ts b/src/modules/balatrots/Lock.ts
@@ -151,4 +151,4 @@ export class Lock implements ILock {
         if (ante == 5) this.unlock("The Serpent");
         if (ante == 6) this.unlock("The Ox");
     }
-}
+}
diff --git a/src/modules/balatrots/struct/InstanceParams.ts b/src/modules/balatrots/struct/InstanceParams.ts
@@ -70,4 +70,4 @@ export class InstanceParams {
     setVouchers(vouchers: Set<Voucher>): void {
         this.vouchers = vouchers;
     }
-}
+}

Original file line number	Diff line number	Diff line change
`@@ -74,4 +74,4 @@ export class Cache {`
`74`	`74`	`}`
`75`	`75`	`this.nodes.set(key, value);`
`76`	`76`	`}`
`77`		`-}`
	`77`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -151,4 +151,4 @@ export class Lock implements ILock {`
`151`	`151`	`if (ante == 5) this.unlock("The Serpent");`
`152`	`152`	`if (ante == 6) this.unlock("The Ox");`
`153`	`153`	`}`
`154`		`-}`
	`154`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -70,4 +70,4 @@ export class InstanceParams {`
`70`	`70`	`setVouchers(vouchers: Set<Voucher>): void {`
`71`	`71`	`this.vouchers = vouchers;`
`72`	`72`	`}`
`73`		`-}`
	`73`	`+}`