balatro-cli 0.1.0

package/README.md

@@ -0,0 +1,56 @@
+# Poker Roguelike CLI
+
+Command-line poker roguelike inspired by Balatro (小丑牌). All output is styled as server logs so it looks like monitoring output.
+
+## Requirements
+
+- Node.js 18+
+
+## Install & Run
+
+**全局安装后一键启动：**
+
+```bash
+npm install -g balatro-cli
+balatro-cli
+```
+
+**本地开发运行：**
+
+```bash
+node bin/start.js
+# or
+npm start
+```
+
+## How to play
+
+- **Goal**: Each round (blind) has a target score. Play 5-card poker hands to reach it before you run out of hands (4) and discards (4).
+- **Flow**: 8 Antes; each Ante has Small Blind, Big Blind, and Boss Blind. Beat the target in a blind to get money and enter the shop. Win Ante 8 Boss to win.
+- **Shop**: Buy Jokers (passive effects), Planet cards (upgrade a hand type), Vouchers (+1 joker slot, etc.), or refresh. Jokers apply in order: +chips left, +mult middle, ×mult right.
+- **Input**:
+  - During a round: type 5 card positions (1–8), e.g. `1 3 5 6 8` to play those cards, or `discard 2 5` to discard cards 2 and 5.
+  - Small/Big blind: `f` to fight, `s` to skip (get a tag, no money/shop).
+  - Shop: `1`/`2` buy joker, `p` planet, `v` voucher, `r` refresh, `q` leave.
+- **关闭提示**: 启动时设置环境变量 `POKER_HIDE_HINTS=1` 可关闭操作提示；或在出牌阶段输入 `/hint`（或 `hint`、`/提示`）随时切换提示开关。
+
+## Test
+
+```bash
+npm test
+```
+
+测试覆盖：牌堆与手牌、牌型判定、计分与小丑牌效果（加筹码/加倍率/乘倍率、对子加成、未弃牌、每张小丑）、星球牌等级、商店（购买/出售小丑、星球牌、优惠券、刷新）、盲注配置、回合出牌与弃牌、CLI 解析。塔罗牌/幻灵牌当前未实现，故无对应单测。
+
+## Project layout
+
+- `src/logStyle.js` – log-style formatter
+- `src/deck.js` – deck, deal, play, discard
+- `src/handRank.js` – 5-card hand detection
+- `src/scoring.js` – score = chips × mult, joker order
+- `src/jokers.js` – joker definitions and effects
+- `src/blinds.js` – ante/blind targets and debuffs
+- `src/round.js` – single blind round loop
+- `src/shop.js` – shop and purchases
+- `src/cli.js` – readline input
+- `src/index.js` – main game loop

package/bin/start.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+
+import { runGame } from '../src/index.js';
+
+runGame().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "balatro-cli",
+  "version": "0.1.0",
+  "description": "CLI poker roguelike (Balatro-style) with server-log aesthetic",
+  "type": "module",
+  "main": "src/index.js",
+  "bin": {
+    "balatro-cli": "bin/start.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "start": "node bin/start.js",
+    "test": "node --test src/tests/deck.test.js src/tests/handRank.test.js src/tests/scoring_jokers.test.js src/tests/shop_cli_round.test.js"
+  },
+  "keywords": [
+    "balatro",
+    "poker",
+    "roguelike",
+    "cli",
+    "game"
+  ],
+  "license": "MIT",
+  "files": [
+    "bin",
+    "src"
+  ]
+}

package/src/blinds.js

@@ -0,0 +1,38 @@
+/**
+ * Ante / Blind config: 8 Antes, each with small / big / boss. Target scores and optional boss debuffs.
+ */
+
+const DEFAULT_HANDS = 4;
+const DEFAULT_DISCARDS = 4;
+
+/** Target score by ante index (0..7). Scale up for big/boss. */
+function baseTarget(anteIndex) {
+  const base = [300, 600, 1200, 2400, 4800, 9600, 19200, 40000];
+  return base[Math.min(anteIndex, base.length - 1)] ?? 40000;
+}
+
+export function getBlindConfig(anteIndex, blindType) {
+  const base = baseTarget(anteIndex);
+  if (blindType === 'small') return { target: base, hands: DEFAULT_HANDS, discards: DEFAULT_DISCARDS, debuff: null };
+  if (blindType === 'big') return { target: Math.floor(base * 1.5), hands: DEFAULT_HANDS, discards: DEFAULT_DISCARDS, debuff: null };
+  if (blindType === 'boss') {
+    const target = Math.floor(base * 2);
+    const debuffs = ['none', 'no_discard', 'target_2x', 'must_play_5'];
+    const debuff = debuffs[anteIndex % debuffs.length];
+    return {
+      target: debuff === 'target_2x' ? target * 2 : target,
+      hands: DEFAULT_HANDS,
+      discards: debuff === 'no_discard' ? 0 : DEFAULT_DISCARDS,
+      debuff,
+    };
+  }
+  return { target: base, hands: DEFAULT_HANDS, discards: DEFAULT_DISCARDS, debuff: null };
+}
+
+export const BLIND_ORDER = ['small', 'big', 'boss'];
+
+export function getBlindLabel(blindType) {
+  return { small: 'Small Blind', big: 'Big Blind', boss: 'Boss Blind' }[blindType] || blindType;
+}
+
+export const ANTES_COUNT = 8;

package/src/cli.js

@@ -0,0 +1,117 @@
+/**
+ * CLI: readline for user input. Prompt disguised as "Gateway >". Parse play indices or discard command.
+ */
+
+import readline from 'readline';
+
+const PROMPT = 'Gateway > ';
+
+export function createInterface() {
+  return readline.createInterface({ input: process.stdin, output: process.stdout });
+}
+
+export function ask(rl, question) {
+  return new Promise((resolve) => {
+    rl.question(question || PROMPT, (answer) => resolve((answer || '').trim()));
+  });
+}
+
+/**
+ * Parse "1 3 5 6 8" / "1,3,5,6,8" / "13568" (无空格) into 0-based indices (1-8 -> 0-7).
+ */
+export function parsePlayIndices(input) {
+  const s = (input || '').trim().replace(/,/g, ' ');
+  if (/^[1-8]{5}$/.test(s)) {
+    const indices = s.split('').map((d) => parseInt(d, 10) - 1);
+    return indices;
+  }
+  const parts = s.split(/\s+/).filter(Boolean);
+  const indices = parts.map((p) => parseInt(p, 10) - 1).filter((n) => n >= 0 && n < 8);
+  return indices.length === 5 ? indices : null;
+}
+
+/**
+ * Parse "discard 2 5" / "d 2 5" / "q 2 5" / "q25" (无空格) -> indices.
+ * 支持 q25 或 q 2 5
+ */
+export function parseDiscardIndices(input) {
+  const s = (input || '').trim();
+  const lower = s.toLowerCase();
+  const m = lower.match(/^(?:discard|d|弃牌|q)(?:\s*(.+))?$/);
+  if (!m) return null;
+  let rest = (m[1] || '').trim();
+  if (!rest) return null;
+  let parts;
+  if (/^[1-8]+$/.test(rest)) {
+    parts = rest.split('');
+  } else {
+    parts = rest.split(/\s+/).filter(Boolean);
+  }
+  const indices = parts.map((p) => parseInt(p, 10) - 1).filter((n) => n >= 0 && n < 8);
+  return indices.length > 0 ? indices : null;
+}
+
+export function isDiscardCommand(input) {
+  const s = (input || '').trim().toLowerCase();
+  return /^(?:discard|d|弃牌|q)/.test(s);
+}
+
+/**
+ * Ask for play: 5 indices (1-8) or discard command. Returns { action: 'play'|'discard'|'toggleHint', indices }.
+ */
+export async function askPlayOrDiscard(rl, log) {
+  const raw = await ask(rl, '');
+  const t = (raw || '').trim().toLowerCase();
+  if (t === '/hint' || t === 'hint' || t === '/提示') return { action: 'toggleHint' };
+  if (isDiscardCommand(raw)) {
+    const indices = parseDiscardIndices(raw);
+    return { action: 'discard', indices: indices || [] };
+  }
+  const indices = parsePlayIndices(raw);
+  return { action: 'play', indices: indices || [] };
+}
+
+/**
+ * Ask shop choice: 1/2=买小丑 p=星球 v=优惠券 r=刷新 s1/s2=卖掉小丑1/2 q=离开
+ */
+export async function askShopChoice(rl, shopState, runState) {
+  const options = [];
+  shopState.jokers.forEach((j, i) => options.push(`${i + 1}: ${j.nameZh || j.name} (¥${j.price})`));
+  if (shopState.planet && shopState.planet[0]) options.push(`p: 星球牌 (¥${shopState.planet[0].price})`);
+  if (shopState.voucher) options.push(`v: 优惠券 (¥${shopState.voucher.price})`);
+  options.push(`r: 刷新 (¥${shopState.refreshCost})`);
+  const myJokers = runState.jokers || [];
+  myJokers.forEach((j, i) => options.push(`s${i + 1}: 出售小丑${i + 1}(${j.nameZh || j.name})`));
+  options.push('q: 离开');
+  const line = options.join(' | ');
+  const raw = await ask(rl, line + '\n' + PROMPT);
+  const c = (raw || '').trim().toLowerCase();
+  if (c === 'q') return { action: 'leave' };
+  if (c === 'p') return { action: 'planet' };
+  if (c === 'v') return { action: 'voucher' };
+  if (c === 'r') return { action: 'refresh' };
+  const sellMatch = c.match(/^s(\d+)$/);
+  if (sellMatch) {
+    const idx = parseInt(sellMatch[1], 10) - 1;
+    if (idx >= 0 && idx < (runState.jokers || []).length) return { action: 'sellJoker', index: idx };
+  }
+  const j = parseInt(c, 10);
+  if (j >= 1 && j <= (shopState.jokers || []).length) return { action: 'joker', index: j - 1 };
+  return { action: 'invalid' };
+}
+
+export async function askSkipOrFight(rl) {
+  const raw = await ask(rl, '可选: f 迎战 s 跳过（跳过不得钱不进商店，获标签）\n' + PROMPT);
+  const c = (raw || '').trim().toLowerCase();
+  return c === 's' || c === '跳过' ? 'skip' : 'fight';
+}
+
+export async function askMainMenu(rl) {
+  const raw = await ask(rl, '可选: 1 新对局 2 继续 q 退出\n' + PROMPT);
+  const c = (raw || '').trim().toLowerCase();
+  if (c === 'q' || c === '退出') return 'exit';
+  if (c === '2' || c === '继续') return 'continue';
+  return 'new';
+}
+
+export { PROMPT };

package/src/deck.js

@@ -0,0 +1,133 @@
+/**
+ * Deck: 52 cards, shuffle, deal 8, draw after play/discard. Reshuffle discard when empty.
+ */
+
+const SUITS = ['hearts', 'diamonds', 'clubs', 'spades'];
+const RANKS = ['2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A'];
+
+/** 花色符号：红桃♥ 方片♦ 梅花♣ 黑桃♠ */
+export const SUIT_SYMBOLS = { hearts: '♥', diamonds: '♦', clubs: '♣', spades: '♠' };
+
+/** ANSI 颜色：红桃红 方片粉 黑桃默认黑 梅花青 */
+const SUIT_COLORS = {
+  hearts: '\x1b[31m',    // 红
+  diamonds: '\x1b[35m',  // 品红/粉
+  clubs: '\x1b[36m',     // 青
+  spades: '\x1b[0m',     // 默认（黑）
+};
+const RESET = '\x1b[0m';
+
+/** 单张牌显示：点数+花色符号（带颜色），如 A♠ 10♥ */
+export function formatCard(c, useColor = true) {
+  if (!c) return '???';
+  const symbol = SUIT_SYMBOLS[c.suit] ?? c.suit[0];
+  if (!useColor || !SUIT_COLORS[c.suit]) return `${c.rank}${symbol}`;
+  return `${c.rank}${SUIT_COLORS[c.suit]}${symbol}${RESET}`;
+}
+
+/** 去掉 ANSI 后的可见长度 */
+function visibleLength(s) {
+  return s.replace(/\x1b\[[0-9;]*m/g, '').length;
+}
+
+/** 固定可见宽度的牌面，序号与手牌对齐用 */
+export function formatCardPadded(c, visibleWidth = 5) {
+  const s = formatCard(c);
+  const n = visibleLength(s);
+  const pad = n < visibleWidth ? ' '.repeat(visibleWidth - n) : '';
+  return s + pad;
+}
+
+/** 点数顺序：2~10, J, Q, K, A */
+const RANK_ORDER = { '2': 0, '3': 1, '4': 2, '5': 3, '6': 4, '7': 5, '8': 6, '9': 7, '10': 8, 'J': 9, 'Q': 10, 'K': 11, 'A': 12 };
+/** 花色顺序：梅花 方片 红桃 黑桃 */
+const SUIT_ORDER = { clubs: 0, diamonds: 1, hearts: 2, spades: 3 };
+
+/** 手牌排序：先按点数再按花色 */
+export function sortHand(hand) {
+  hand.sort((a, b) => {
+    const r = (RANK_ORDER[a.rank] ?? 0) - (RANK_ORDER[b.rank] ?? 0);
+    if (r !== 0) return r;
+    return (SUIT_ORDER[a.suit] ?? 0) - (SUIT_ORDER[b.suit] ?? 0);
+  });
+  return hand;
+}
+
+export function createDeck() {
+  const cards = [];
+  for (const suit of SUITS) {
+    for (const rank of RANKS) {
+      cards.push({ suit, rank });
+    }
+  }
+  return cards;
+}
+
+export function shuffle(cards) {
+  const out = [...cards];
+  for (let i = out.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [out[i], out[j]] = [out[j], out[i]];
+  }
+  return out;
+}
+
+export function createShuffledDeck() {
+  return shuffle(createDeck());
+}
+
+/**
+ * Game deck state: draw pile and discard pile.
+ * drawPile[0] is top of deck.
+ */
+export function createGameDeck() {
+  return {
+    drawPile: createShuffledDeck(),
+    discardPile: [],
+  };
+}
+
+export function draw(state, n) {
+  const drawn = [];
+  for (let i = 0; i < n; i++) {
+    if (state.drawPile.length === 0) {
+      state.drawPile = shuffle(state.discardPile);
+      state.discardPile = [];
+    }
+    if (state.drawPile.length === 0) break;
+    drawn.push(state.drawPile.shift());
+  }
+  return drawn;
+}
+
+/** Deal 8 cards into hand; remove from draw pile. */
+export function dealHand(state) {
+  return draw(state, 8);
+}
+
+/** Play cards: move them from hand to discard, then draw same number to refill hand. */
+export function playCards(state, hand, indicesToPlay) {
+  const played = indicesToPlay.map((i) => hand[i]).filter(Boolean);
+  const remaining = hand.filter((_, i) => !indicesToPlay.includes(i));
+  state.discardPile.push(...played);
+  const newCards = draw(state, played.length);
+  return [...remaining, ...newCards];
+}
+
+/** Discard by indices: move to discard pile, draw same number. */
+export function discardCards(state, hand, indicesToDiscard) {
+  const discarded = indicesToDiscard.map((i) => hand[i]).filter(Boolean);
+  const remaining = hand.filter((_, i) => !indicesToDiscard.includes(i));
+  state.discardPile.push(...discarded);
+  const newCards = draw(state, discarded.length);
+  return [...remaining, ...newCards];
+}
+
+export function cardChipValue(rank) {
+  if (rank === 'A') return 11;
+  if (['K', 'Q', 'J'].includes(rank)) return 10;
+  const n = parseInt(rank, 10);
+  return Number.isNaN(n) ? 0 : n;
+}
+
+export { SUITS, RANKS };

package/src/handRank.js

@@ -0,0 +1,135 @@
+/**
+ * Detect 5-card poker hand type (high card to royal flush). Returns hand id and level for scoring.
+ */
+
+import { RANKS } from './deck.js';
+
+const RANK_ORDER = [...RANKS];
+const RANK_INDEX = Object.fromEntries(RANK_ORDER.map((r, i) => [r, i]));
+
+export const HAND_IDS = {
+  HIGH_CARD: 'HighCard',
+  PAIR: 'Pair',
+  TWO_PAIR: 'TwoPair',
+  THREE_OF_A_KIND: 'ThreeOfAKind',
+  STRAIGHT: 'Straight',
+  FLUSH: 'Flush',
+  FULL_HOUSE: 'FullHouse',
+  FOUR_OF_A_KIND: 'FourOfAKind',
+  STRAIGHT_FLUSH: 'StraightFlush',
+  ROYAL_FLUSH: 'RoyalFlush',
+};
+
+function rankIndex(rank) {
+  return RANK_INDEX[rank] ?? -1;
+}
+
+function countRanks(cards) {
+  const counts = {};
+  for (const c of cards) {
+    counts[c.rank] = (counts[c.rank] || 0) + 1;
+  }
+  return counts;
+}
+
+function countSuits(cards) {
+  const counts = {};
+  for (const c of cards) {
+    counts[c.suit] = (counts[c.suit] || 0) + 1;
+  }
+  return counts;
+}
+
+function isFlush(cards) {
+  const suits = countSuits(cards);
+  return Math.max(...Object.values(suits)) >= 5;
+}
+
+function sortedRankIndices(cards) {
+  return cards.map((c) => rankIndex(c.rank)).sort((a, b) => b - a);
+}
+
+/** Check if 5 cards form a straight (A high or A low). */
+function isStraight(cards) {
+  if (cards.length < 5) return false;
+  const indices = [...new Set(cards.map((c) => rankIndex(c.rank)))].sort((a, b) => b - a);
+  if (indices.length < 5) return false;
+  const hasAce = indices.includes(12);
+  for (let start = 0; start <= indices.length - 5; start++) {
+    const slice = indices.slice(start, start + 5);
+    let ok = true;
+    for (let i = 1; i < slice.length; i++) {
+      if (slice[i - 1] - slice[i] !== 1) {
+        ok = false;
+        break;
+      }
+    }
+    if (ok) return true;
+  }
+  if (hasAce) {
+    const wheel = [12, 3, 2, 1, 0];
+    const have = new Set(indices);
+    if (wheel.every((i) => have.has(i))) return true;
+  }
+  return false;
+}
+
+/** Must receive exactly 5 cards. Returns { handId, level, scoringCards } for chips. */
+export function evaluateHand(cards) {
+  if (!cards || cards.length !== 5) {
+    return { handId: HAND_IDS.HIGH_CARD, level: 1, scoringCards: cards?.slice(0, 1) || [] };
+  }
+  const rankCounts = countRanks(cards);
+  const values = Object.values(rankCounts);
+  const maxSame = Math.max(...values);
+  const suits = countSuits(cards);
+  const flush = Math.max(...Object.values(suits)) >= 5;
+  const straight = isStraight(cards);
+
+  const sorted = [...cards].sort((a, b) => rankIndex(b.rank) - rankIndex(a.rank));
+  const highRank = sorted[0]?.rank;
+
+  if (flush && straight) {
+    const isRoyal = sorted.every((c) => ['A', 'K', 'Q', 'J', '10'].includes(c.rank));
+    return {
+      handId: isRoyal ? HAND_IDS.ROYAL_FLUSH : HAND_IDS.STRAIGHT_FLUSH,
+      level: 1,
+      scoringCards: [...sorted],
+    };
+  }
+  if (maxSame === 4) {
+    const quadRank = Object.entries(rankCounts).find(([, v]) => v === 4)[0];
+    const quad = cards.filter((c) => c.rank === quadRank);
+    const kicker = cards.filter((c) => c.rank !== quadRank).sort((a, b) => rankIndex(b.rank) - rankIndex(a.rank))[0];
+    return { handId: HAND_IDS.FOUR_OF_A_KIND, level: 1, scoringCards: [...quad, kicker].filter(Boolean) };
+  }
+  if (maxSame === 3 && values.filter((v) => v >= 2).length >= 2) {
+    return { handId: HAND_IDS.FULL_HOUSE, level: 1, scoringCards: [...sorted] };
+  }
+  if (flush) {
+    return { handId: HAND_IDS.FLUSH, level: 1, scoringCards: [...sorted] };
+  }
+  if (straight) {
+    return { handId: HAND_IDS.STRAIGHT, level: 1, scoringCards: [...sorted] };
+  }
+  if (maxSame === 3) {
+    const tripRank = Object.entries(rankCounts).find(([, v]) => v === 3)[0];
+    const trip = cards.filter((c) => c.rank === tripRank);
+    const rest = cards.filter((c) => c.rank !== tripRank).sort((a, b) => rankIndex(b.rank) - rankIndex(a.rank)).slice(0, 2);
+    return { handId: HAND_IDS.THREE_OF_A_KIND, level: 1, scoringCards: [...trip, ...rest] };
+  }
+  const pairs = Object.entries(rankCounts).filter(([, v]) => v >= 2);
+  if (pairs.length >= 2) {
+    pairs.sort((a, b) => rankIndex(b[0]) - rankIndex(a[0]));
+    const twoPairCards = cards.filter((c) => c.rank === pairs[0][0] || c.rank === pairs[1][0]);
+    const kicker = cards.filter((c) => !twoPairCards.includes(c)).sort((a, b) => rankIndex(b.rank) - rankIndex(a.rank))[0];
+    return { handId: HAND_IDS.TWO_PAIR, level: 1, scoringCards: [...twoPairCards, kicker].filter(Boolean) };
+  }
+  if (pairs.length === 1) {
+    const pairRank = pairs[0][0];
+    const pair = cards.filter((c) => c.rank === pairRank);
+    const kickers = cards.filter((c) => c.rank !== pairRank).sort((a, b) => rankIndex(b.rank) - rankIndex(a.rank)).slice(0, 3);
+    return { handId: HAND_IDS.PAIR, level: 1, scoringCards: [...pair, ...kickers] };
+  }
+  return { handId: HAND_IDS.HIGH_CARD, level: 1, scoringCards: [sorted[0]] };
+}