balatro-cli 0.1.0

package/src/tests/deck.test.js

@@ -0,0 +1,82 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import {
+  createDeck,
+  createGameDeck,
+  draw,
+  dealHand,
+  cardChipValue,
+  sortHand,
+  formatCard,
+  formatCardPadded,
+} from '../deck.js';
+
+const stripAnsi = (s) => s.replace(/\x1b\[[0-9;]*m/g, '');
+
+test('deck: createDeck has 52 unique cards', () => {
+  const deck = createDeck();
+  assert.equal(deck.length, 52);
+  const set = new Set(deck.map((c) => `${c.rank}-${c.suit}`));
+  assert.equal(set.size, 52);
+});
+
+test('deck: cardChipValue matches Balatro ranks', () => {
+  assert.equal(cardChipValue('A'), 11);
+  assert.equal(cardChipValue('K'), 10);
+  assert.equal(cardChipValue('Q'), 10);
+  assert.equal(cardChipValue('J'), 10);
+  assert.equal(cardChipValue('2'), 2);
+  assert.equal(cardChipValue('9'), 9);
+});
+
+test('deck: draw and reshuffle from discard when empty', () => {
+  const state = { drawPile: [{ rank: 'A', suit: 'spades' }], discardPile: [{ rank: 'K', suit: 'hearts' }] };
+  const first = draw(state, 1);
+  assert.equal(first.length, 1);
+  assert.equal(first[0].rank, 'A');
+  const second = draw(state, 1);
+  assert.equal(second.length, 1);
+  assert.equal(second[0].rank, 'K');
+});
+
+test('deck: dealHand draws 8 cards from game deck', () => {
+  const state = createGameDeck();
+  const hand = dealHand(state);
+  assert.equal(hand.length, 8);
+  assert.equal(state.drawPile.length, 52 - 8);
+});
+
+test('deck: sortHand orders by rank then suit', () => {
+  const hand = [
+    { rank: 'A', suit: 'hearts' },
+    { rank: '2', suit: 'spades' },
+    { rank: '10', suit: 'clubs' },
+    { rank: '10', suit: 'diamonds' },
+    { rank: 'K', suit: 'clubs' },
+  ];
+  sortHand(hand);
+  const ranks = hand.map((c) => c.rank + c.suit[0]);
+  // 2 最小，其次 10c, 10d, Kc, Ah
+  assert.deepEqual(ranks, ['2s', '10c', '10d', 'Kc', 'Ah']);
+});
+
+test('deck: formatCard adds suit symbol and optional color', () => {
+  const c = { rank: 'A', suit: 'hearts' };
+  const colored = formatCard(c, true);
+  const plain = formatCard(c, false);
+  assert.equal(stripAnsi(colored), 'A♥');
+  assert.equal(plain, 'A♥');
+});
+
+test('deck: formatCardPadded enforces visible width', () => {
+  const hand = [
+    { rank: '2', suit: 'spades' },
+    { rank: '10', suit: 'hearts' },
+    { rank: 'Q', suit: 'diamonds' },
+  ];
+  for (const c of hand) {
+    const s = formatCardPadded(c, 5);
+    assert.equal(stripAnsi(s).length, 5);
+  }
+});

package/src/tests/handRank.test.js

@@ -0,0 +1,73 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { evaluateHand, HAND_IDS } from '../handRank.js';
+
+const c = (rank, suit) => ({ rank, suit });
+
+test('handRank: HighCard', () => {
+  const hand = [c('A', 'spades'), c('9', 'hearts'), c('5', 'clubs'), c('3', 'diamonds'), c('2', 'clubs')];
+  const r = evaluateHand(hand);
+  assert.equal(r.handId, HAND_IDS.HIGH_CARD);
+  assert.equal(r.scoringCards.length, 1);
+});
+
+test('handRank: Pair', () => {
+  const hand = [c('A', 'spades'), c('A', 'hearts'), c('5', 'clubs'), c('3', 'diamonds'), c('2', 'clubs')];
+  const r = evaluateHand(hand);
+  assert.equal(r.handId, HAND_IDS.PAIR);
+});
+
+test('handRank: TwoPair', () => {
+  const hand = [c('A', 'spades'), c('A', 'hearts'), c('K', 'clubs'), c('K', 'diamonds'), c('2', 'clubs')];
+  const r = evaluateHand(hand);
+  assert.equal(r.handId, HAND_IDS.TWO_PAIR);
+});
+
+test('handRank: ThreeOfAKind', () => {
+  const hand = [c('A', 'spades'), c('A', 'hearts'), c('A', 'clubs'), c('5', 'diamonds'), c('2', 'clubs')];
+  const r = evaluateHand(hand);
+  assert.equal(r.handId, HAND_IDS.THREE_OF_A_KIND);
+});
+
+test('handRank: Straight (A2345 wheel)', () => {
+  const hand = [c('A', 'spades'), c('2', 'hearts'), c('3', 'clubs'), c('4', 'diamonds'), c('5', 'clubs')];
+  const r = evaluateHand(hand);
+  assert.equal(r.handId, HAND_IDS.STRAIGHT);
+});
+
+test('handRank: Straight (TJQKA)', () => {
+  const hand = [c('10', 'spades'), c('J', 'hearts'), c('Q', 'clubs'), c('K', 'diamonds'), c('A', 'clubs')];
+  const r = evaluateHand(hand);
+  assert.equal(r.handId, HAND_IDS.STRAIGHT);
+});
+
+test('handRank: Flush', () => {
+  const hand = [c('2', 'spades'), c('5', 'spades'), c('8', 'spades'), c('J', 'spades'), c('K', 'spades')];
+  const r = evaluateHand(hand);
+  assert.equal(r.handId, HAND_IDS.FLUSH);
+});
+
+test('handRank: FullHouse', () => {
+  const hand = [c('A', 'spades'), c('A', 'hearts'), c('A', 'clubs'), c('K', 'diamonds'), c('K', 'clubs')];
+  const r = evaluateHand(hand);
+  assert.equal(r.handId, HAND_IDS.FULL_HOUSE);
+});
+
+test('handRank: FourOfAKind', () => {
+  const hand = [c('A', 'spades'), c('A', 'hearts'), c('A', 'clubs'), c('A', 'diamonds'), c('K', 'clubs')];
+  const r = evaluateHand(hand);
+  assert.equal(r.handId, HAND_IDS.FOUR_OF_A_KIND);
+});
+
+test('handRank: StraightFlush', () => {
+  const hand = [c('6', 'hearts'), c('7', 'hearts'), c('8', 'hearts'), c('9', 'hearts'), c('10', 'hearts')];
+  const r = evaluateHand(hand);
+  assert.equal(r.handId, HAND_IDS.STRAIGHT_FLUSH);
+});
+
+test('handRank: RoyalFlush', () => {
+  const hand = [c('10', 'spades'), c('J', 'spades'), c('Q', 'spades'), c('K', 'spades'), c('A', 'spades')];
+  const r = evaluateHand(hand);
+  assert.equal(r.handId, HAND_IDS.ROYAL_FLUSH);
+});

package/src/tests/scoring_jokers.test.js

@@ -0,0 +1,85 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { computeScore, getHandBaseChipsMult } from '../scoring.js';
+import { getJokerById } from '../jokers.js';
+
+const c = (rank, suit) => ({ rank, suit });
+
+test('scoring: base chips and mult for FourOfAKind', () => {
+  const base = getHandBaseChipsMult('FourOfAKind', 1);
+  assert.equal(base.chips, 60);
+  assert.equal(base.mult, 7);
+});
+
+test('scoring: computeScore without jokers (FourOfAKind)', () => {
+  const hand = [
+    c('A', 'spades'),
+    c('A', 'hearts'),
+    c('A', 'clubs'),
+    c('A', 'diamonds'),
+    c('K', 'clubs'),
+  ];
+  const r = computeScore(hand, {}, []);
+  // chips = base(60) + cards(4*A*11 + K*10 = 54) = 114, mult=7
+  assert.equal(r.chips, 114);
+  assert.equal(r.mult, 7);
+  assert.equal(r.score, 114 * 7);
+});
+
+test('scoring: PlusMult then TimesMult jokers', () => {
+  const hand = [
+    c('A', 'spades'),
+    c('A', 'hearts'),
+    c('A', 'clubs'),
+    c('A', 'diamonds'),
+    c('K', 'clubs'),
+  ];
+  const plusMult = getJokerById('Joker_PlusMult'); // +3 mult
+  const timesMult = getJokerById('Joker_TimesMult'); // x2 mult
+  const r = computeScore(hand, {}, [plusMult, timesMult]);
+  // base chips=114, base mult=7 -> +3 =>10, *2 =>20
+  assert.equal(r.mult, 20);
+  assert.equal(r.score, 114 * 20);
+});
+
+test('scoring: Pair bonus only for Pair hand', () => {
+  const pairHand = [c('A', 'spades'), c('A', 'hearts'), c('2', 'clubs'), c('3', 'diamonds'), c('4', 'clubs')];
+  const highHand = [c('A', 'spades'), c('K', 'hearts'), c('2', 'clubs'), c('3', 'diamonds'), c('4', 'clubs')];
+  const pairJoker = getJokerById('Joker_Pair'); // +mult when handId=Pair
+
+  const rPair = computeScore(pairHand, {}, [pairJoker]);
+  const rHigh = computeScore(highHand, {}, [pairJoker]);
+
+  assert.ok(rPair.mult > rHigh.mult, 'Pair joker should increase mult only for Pair');
+});
+
+test('scoring: NoDiscard joker depends on discardsLeft', () => {
+  const hand = [c('A', 'spades'), c('A', 'hearts'), c('2', 'clubs'), c('3', 'diamonds'), c('4', 'clubs')];
+  const noDiscard = getJokerById('Joker_NoDiscard');
+
+  const withDiscard = computeScore(hand, {}, [noDiscard], { discardsLeft: 1 });
+  const noBonus = computeScore(hand, {}, [noDiscard], { discardsLeft: 0 });
+
+  assert.ok(withDiscard.mult > noBonus.mult);
+});
+
+test('scoring: PerJokerMult scales with joker count', () => {
+  const hand = [c('A', 'spades'), c('A', 'hearts'), c('2', 'clubs'), c('3', 'diamonds'), c('4', 'clubs')];
+  const perJoker = getJokerById('Joker_EveryJoker');
+  const baseJoker = getJokerById('Joker_Base');
+
+  const rOne = computeScore(hand, {}, [perJoker]);
+  const rThree = computeScore(hand, {}, [perJoker, baseJoker, baseJoker]);
+
+  assert.ok(rThree.mult > rOne.mult, 'more jokers should give higher mult for PerJoker joker');
+});
+
+test('scoring: planet level increases base chips/mult', () => {
+  const hand = [c('A', 'spades'), c('A', 'hearts'), c('2', 'clubs'), c('3', 'diamonds'), c('4', 'clubs')];
+  const r1 = computeScore(hand, { Pair: 1 }, []);
+  const r3 = computeScore(hand, { Pair: 3 }, []); // +2 levels
+
+  assert.ok(r3.chips > r1.chips);
+  assert.ok(r3.mult > r1.mult);
+});

package/src/tests/shop_cli_round.test.js

@@ -0,0 +1,139 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { createShopState, canBuyJoker, buyJoker, sellJoker, buyPlanet, buyVoucher, refreshShop } from '../shop.js';
+import { parsePlayIndices, parseDiscardIndices } from '../cli.js';
+import { playHand, doDiscard } from '../round.js';
+import { getBlindConfig, BLIND_ORDER, ANTES_COUNT } from '../blinds.js';
+
+const c = (rank, suit) => ({ rank, suit });
+
+test('cli: parsePlayIndices supports spaces, commas and no spaces', () => {
+  assert.deepEqual(parsePlayIndices('1 3 5 6 8'), [0, 2, 4, 5, 7]);
+  assert.deepEqual(parsePlayIndices('1,3,5,6,8'), [0, 2, 4, 5, 7]);
+  assert.deepEqual(parsePlayIndices('13568'), [0, 2, 4, 5, 7]);
+});
+
+test('cli: parseDiscardIndices supports q 2 5 and q25', () => {
+  assert.deepEqual(parseDiscardIndices('q 2 5'), [1, 4]);
+  assert.deepEqual(parseDiscardIndices('q25'), [1, 4]);
+  assert.deepEqual(parseDiscardIndices('discard 1 3'), [0, 2]);
+});
+
+test('shop: createShopState generates jokers, optional planet and voucher', () => {
+  const runState = { money: 10, jokers: [], voucherBoughtThisAnte: false };
+  const s = createShopState(runState);
+  assert.ok(Array.isArray(s.jokers));
+  assert.ok(s.jokers.length <= 2);
+  assert.ok(Array.isArray(s.planet));
+  assert.ok(s.voucher === null || typeof s.voucher === 'object');
+});
+
+test('shop: canBuyJoker, buyJoker, sellJoker', () => {
+  const runState = { money: 10, jokers: [], jokerSlots: 2 };
+  const s = createShopState(runState);
+  const j = s.jokers[0];
+  assert.ok(canBuyJoker(runState, j));
+  const beforeMoney = runState.money;
+  const ok = buyJoker(runState, j).ok;
+  assert.ok(ok);
+  assert.equal(runState.jokers.length, 1);
+  assert.equal(runState.money, beforeMoney - j.price);
+
+  const sell = sellJoker(runState, 0);
+  assert.ok(sell.ok);
+  assert.equal(runState.jokers.length, 0);
+  assert.ok(sell.money >= 1 && sell.money <= j.price);
+});
+
+test('shop: buyPlanet upgrades hand level', () => {
+  const runState = { money: 10, handLevels: {} };
+  const planet = { handId: 'Pair', price: 4 };
+  const res = buyPlanet(runState, planet);
+  assert.ok(res.ok);
+  assert.equal(runState.handLevels.Pair, 2); // from default 1 -> 2
+});
+
+test('shop: buyVoucher updates jokerSlots and flag', () => {
+  const runState = { money: 20, jokerSlots: 5, voucherBoughtThisAnte: false };
+  const voucher = { id: 'Blank', price: 10 };
+  const res = buyVoucher(runState, voucher);
+  assert.ok(res.ok);
+  assert.equal(runState.voucherBoughtThisAnte, true);
+  assert.equal(runState.jokerSlots, 6);
+});
+
+test('shop: refreshShop consumes money and rerolls', () => {
+  const runState = { money: 20, jokers: [] };
+  const state = createShopState(runState);
+  const oldCost = state.refreshCost;
+  const oldJokerNames = state.jokers.map((j) => j.id).sort();
+  const res = refreshShop(state, runState);
+  assert.ok(res.ok);
+  assert.equal(state.refreshCost, oldCost + 1);
+  const newNames = state.jokers.map((j) => j.id).sort();
+  // 不强制不同，但刷新后至少结构合理
+  assert.ok(Array.isArray(state.jokers));
+});
+
+test('round: playHand enforces must_play_5 and handsLeft', () => {
+  const fiveExtra = [
+    { rank: '2', suit: 'hearts' },
+    { rank: '3', suit: 'hearts' },
+    { rank: '4', suit: 'hearts' },
+    { rank: '5', suit: 'hearts' },
+    { rank: '6', suit: 'hearts' },
+  ];
+  const roundState = {
+    deckState: { drawPile: [...fiveExtra], discardPile: [] },
+    hand: [c('A', 'spades'), c('K', 'spades'), c('Q', 'spades'), c('J', 'spades'), c('10', 'spades')],
+    handsLeft: 1,
+    discardsLeft: 1,
+    target: 0,
+    debuff: 'must_play_5',
+    playedHandTypes: new Set(),
+    mustPlay5: true,
+  };
+  const state = { handLevels: {}, jokers: [] };
+  let r = playHand(roundState, state, [0, 1, 2, 3]);
+  assert.equal(r.error, 'must_play_5');
+  r = playHand(roundState, state, [0, 1, 2, 3, 4]);
+  assert.equal(r.error, undefined);
+  assert.equal(roundState.handsLeft, 0);
+  assert.ok(r.cleared);
+});
+
+test('blinds: getBlindConfig returns target, hands, discards, boss debuff', () => {
+  const small = getBlindConfig(0, 'small');
+  assert.equal(small.target, 300);
+  assert.equal(small.hands, 4);
+  assert.equal(small.discards, 4);
+  assert.equal(small.debuff, null);
+
+  const big = getBlindConfig(0, 'big');
+  assert.equal(big.target, 450);
+  assert.ok(big.target > small.target);
+
+  const boss = getBlindConfig(0, 'boss');
+  assert.ok(boss.target >= 600);
+  assert.ok(['none', 'no_discard', 'target_2x', 'must_play_5'].includes(boss.debuff));
+});
+
+test('blinds: ANTES_COUNT and BLIND_ORDER', () => {
+  assert.equal(ANTES_COUNT, 8);
+  assert.deepEqual(BLIND_ORDER, ['small', 'big', 'boss']);
+});
+
+test('round: doDiscard decrements discardsLeft and errors when none left', () => {
+  const roundState = {
+    deckState: { drawPile: [c('2', 'hearts')], discardPile: [] },
+    hand: [c('A', 'spades'), c('K', 'spades')],
+    handsLeft: 1,
+    discardsLeft: 1,
+  };
+  let res = doDiscard(roundState, [0]);
+  assert.ok(res.success);
+  assert.equal(roundState.discardsLeft, 0);
+  res = doDiscard(roundState, [0]);
+  assert.equal(res.error, 'no_discards_left');
+});