maid-poker-cli 1.0.0

package/README.md

@@ -0,0 +1,35 @@
+# Maid Poker (女仆扑克牌)
+
+A command-line multiplayer Dou Dizhu (斗地主) game built with Node.js and Socket.io.
+
+## Features
+- **Multiplayer**: Host and join games over local network.
+- **Beautiful UI**: ASCII art for cards, special effects for Bombs, Planes, and Rockets.
+- **Interactive**: Easy-to-use CLI interface.
+- **Rules**: Standard Dou Dizhu rules with robust card validation.
+
+## Installation
+
+```bash
+npm install -g maid-poker-cli
+```
+
+## Usage
+
+Start the game:
+```bash
+maid-poker
+```
+
+### Hosting
+1. Select "Host Game".
+2. Share your IP address with friends.
+3. Wait for players to join.
+
+### Joining
+1. Select "Join Game".
+2. Enter the Host's IP address.
+3. Enjoy!
+
+## License
+ISC

package/dist/client.js

@@ -0,0 +1,286 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GameClient = void 0;
+const socket_io_client_1 = require("socket.io-client");
+const inquirer_1 = __importDefault(require("inquirer"));
+const chalk_1 = __importDefault(require("chalk"));
+const figlet_1 = __importDefault(require("figlet"));
+const poker_1 = require("./game/poker");
+const view_1 = require("./game/view");
+class GameClient {
+    constructor(serverUrl, name) {
+        this.hand = [];
+        this.myTurn = false;
+        this.name = name;
+        this.socket = (0, socket_io_client_1.io)(serverUrl);
+        this.setupEvents();
+    }
+    setupEvents() {
+        this.socket.on('connect', () => {
+            console.log(chalk_1.default.green('已连接到服务器!'));
+            this.socket.emit('join_game', this.name);
+        });
+        this.socket.on('player_list_update', (names) => {
+            console.log(chalk_1.default.cyan(`\n当前玩家: ${names.join(', ')}`));
+        });
+        this.socket.on('error_msg', (msg) => {
+            console.log(chalk_1.default.red('错误:', msg));
+        });
+        this.socket.on('game_start', (data) => {
+            console.clear();
+            console.log(chalk_1.default.green(figlet_1.default.textSync('Game Start!', { font: 'Standard' })));
+            this.hand = data.hand;
+            this.printHand();
+            console.log(chalk_1.default.yellow('等待叫分...'));
+        });
+        this.socket.on('hand_update', (newHand) => {
+            this.hand = newHand;
+            this.printHand();
+        });
+        this.socket.on('landlord_chosen', (data) => {
+            console.log(chalk_1.default.yellow(`\n地主是 ${data.landlordName}!`));
+            console.log('底牌:');
+            console.log((0, view_1.renderCards)(data.hiddenCards));
+        });
+        this.socket.on('turn_update', (data) => {
+            if (data.playerName !== this.name) {
+                const actionText = data.action === 'bid' ? '叫分' : '出牌';
+                console.log(chalk_1.default.gray(`\n等待 ${data.playerName} ${actionText}...`));
+            }
+        });
+        this.socket.on('player_played', (data) => {
+            // Clear screen to make it cleaner?
+            // User requested: "出牌后清理上一轮命令行内容是否体验更好" -> Yes, but we need to redraw state.
+            // But if we clear, we lose history of what happened.
+            // Let's at least clear for the USER's OWN turn before input, or here if we want a fresh table.
+            // Let's try clearing console before showing the played cards to focus attention.
+            console.clear();
+            // Check for special effects
+            const { analyzeHand } = require('./game/logic');
+            const analysis = analyzeHand(data.cards);
+            if (analysis.type === 'rocket') {
+                // Rocket (King Bomb)
+                console.log(chalk_1.default.red.bold(figlet_1.default.textSync('ROCKET !!!', { font: 'Doom' })));
+                console.log(chalk_1.default.bgRed.white.bold.italic('       🚀 王 炸 🚀       '));
+            }
+            else if (analysis.type === 'bomb') {
+                // Determine bomb intensity based on rank (3-15)
+                const rank = analysis.rankValue;
+                let bombText = 'BOMB';
+                let fontToUse = 'Standard';
+                if (rank <= 7) {
+                    // Small bomb (3-7)
+                    fontToUse = 'Small'; // Assuming 'Small' font exists or fallback
+                }
+                else if (rank <= 13) {
+                    // Medium bomb (8-K)
+                    fontToUse = 'Standard';
+                }
+                else {
+                    // Big bomb (A-2)
+                    fontToUse = 'Big';
+                }
+                // Use Standard/Big since 'Small' might be too small or not exist in standard figlet import
+                // Let's stick to Standard vs Big vs Doom for simplicity
+                if (rank > 13)
+                    fontToUse = 'Big';
+                else
+                    fontToUse = 'Standard';
+                console.log(chalk_1.default.red.bold(figlet_1.default.textSync(bombText, { font: fontToUse })));
+                // Add magnitude indicator
+                // Add magnitude indicator
+                const stars = '⭐'.repeat(Math.min(5, Math.max(1, rank - 2)));
+                const r = rank === 11 ? 'J' : rank === 12 ? 'Q' : rank === 13 ? 'K' : rank === 14 ? 'A' : rank === 15 ? '2' : rank.toString();
+                console.log(chalk_1.default.bgRed.white.bold(`      💣 炸 弹 (${r}) 💣      `));
+            }
+            else if (analysis.type === 'airplane') {
+                // Airplane effect
+                console.log(chalk_1.default.cyan.bold(figlet_1.default.textSync('PLANE', { font: 'Standard' })));
+                console.log(chalk_1.default.bgBlue.white.bold('          ✈️  飞 机 ✈️          '));
+            }
+            else if (analysis.type === 'straight') {
+                // Straight effect
+                console.log(chalk_1.default.green.bold(figlet_1.default.textSync('STRAIGHT', { font: 'Standard' })));
+                console.log(chalk_1.default.bgGreen.white.bold('          🌊 顺 子 🌊          '));
+            }
+            console.log(chalk_1.default.bold(`\n${data.playerName} 打出了:`));
+            console.log((0, view_1.renderCards)(data.cards));
+            console.log(chalk_1.default.gray(`剩余 ${data.remainingCount} 张牌.`));
+            // Re-display my hand so context is not lost after clear
+            this.printHand();
+        });
+        this.socket.on('player_passed', (data) => {
+            console.log(chalk_1.default.gray(`\n${data.playerName} 要不起.`));
+        });
+        this.socket.on('new_round', (data) => {
+            console.log(chalk_1.default.green(`\n${data.playerName} 获得新回合!`));
+        });
+        this.socket.on('game_over', (data) => __awaiter(this, void 0, void 0, function* () {
+            console.log(chalk_1.default.magenta(figlet_1.default.textSync('Game Over')));
+            // data.role is 'landlord' or 'peasant'
+            const roleText = data.role === 'landlord' ? '地主' : '农民';
+            console.log(chalk_1.default.yellow(`赢家: ${data.winner} (${roleText} 胜利!)`));
+            // Replay Prompt
+            const { action } = yield inquirer_1.default.prompt([{
+                    type: 'list',
+                    name: 'action',
+                    message: '本局结束，你想做什么?',
+                    choices: ['继续游戏 (Play Again)', '退出 (Exit)']
+                }]);
+            if (action.includes('Exit')) {
+                process.exit(0);
+            }
+            else {
+                console.clear();
+                console.log(chalk_1.default.green('等待其他玩家准备...'));
+                this.socket.emit('player_ready');
+            }
+        }));
+        this.socket.on('your_turn', (data) => __awaiter(this, void 0, void 0, function* () {
+            this.myTurn = true;
+            setTimeout(() => this.handleTurn(data.action), 500);
+        }));
+    }
+    colorCard(c) {
+        const str = (0, poker_1.formatCard)(c);
+        if (c.suit === '♥' || c.suit === '♦' || c.rank === 'RJ') {
+            return chalk_1.default.red(str);
+        }
+        else {
+            return chalk_1.default.black.bgWhite(str);
+        }
+    }
+    printHand() {
+        console.log(chalk_1.default.blue('\n你的手牌:'));
+        console.log((0, view_1.renderCards)(this.hand));
+        console.log('\n');
+    }
+    handleTurn(action) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (action === 'bid') {
+                const { bid } = yield inquirer_1.default.prompt([{
+                        type: 'confirm',
+                        name: 'bid',
+                        message: '你想叫地主吗?',
+                        default: false
+                    }]);
+                this.socket.emit('bid_landlord', bid ? 1 : 0);
+            }
+            else {
+                // Updated to use input for cards
+                const { cardInput } = yield inquirer_1.default.prompt([{
+                        type: 'input',
+                        name: 'cardInput',
+                        message: '请输入要出的牌 (例如 "34567" 或 "3 4 5", 直接回车表示不出):'
+                    }]);
+                const inputStr = (cardInput || '').trim();
+                if (!inputStr) {
+                    const { confirmPass } = yield inquirer_1.default.prompt([{
+                            type: 'confirm',
+                            name: 'confirmPass',
+                            message: '确认不出(PASS)吗?',
+                            default: true
+                        }]);
+                    if (confirmPass) {
+                        this.socket.emit('pass');
+                    }
+                    else {
+                        return this.handleTurn('play');
+                    }
+                }
+                else {
+                    const selectedCards = this.parseCards(inputStr);
+                    if (!selectedCards) {
+                        console.log(chalk_1.default.red('无效的牌输入，请检查你的手牌和输入格式 (如 334455, 3 3 4 4)'));
+                        return this.handleTurn('play');
+                    }
+                    this.socket.emit('play_cards', selectedCards);
+                }
+            }
+            this.myTurn = false;
+        });
+    }
+    // Helper to match input string to hand cards
+    // Supports "34567", "3344", "3 4 5", "10 J Q K"
+    parseCards(input) {
+        const tempHand = [...this.hand]; // Copy to track usage
+        const selected = [];
+        let tokens = [];
+        // Revised parsing logic:
+        // Parse left-to-right, looking for valid tokens.
+        // Priority: Multi-char tokens (10, BJ, RJ) > Single-char tokens.
+        // Aliases: 0 -> 10, T -> 10.
+        let remaining = input.toUpperCase();
+        while (remaining.length > 0) {
+            // Skip separators
+            if (/^[\s,]+/.test(remaining)) {
+                remaining = remaining.replace(/^[\s,]+/, '');
+                continue;
+            }
+            let foundToken = '';
+            // 1. Check for specific multi-char tokens aliases first
+            if (remaining.startsWith('10')) {
+                foundToken = '10';
+                remaining = remaining.substring(2);
+            }
+            else if (remaining.startsWith('BJ')) {
+                foundToken = 'BJ';
+                remaining = remaining.substring(2);
+            }
+            else if (remaining.startsWith('RJ')) {
+                foundToken = 'RJ';
+                remaining = remaining.substring(2);
+            }
+            // 2. Check for Single char aliases for 10
+            else if (remaining.startsWith('0')) {
+                foundToken = '10';
+                remaining = remaining.substring(1);
+            }
+            else if (remaining.startsWith('T')) {
+                foundToken = '10';
+                remaining = remaining.substring(1);
+            }
+            // 3. Check for standard single chars
+            else {
+                const char = remaining[0];
+                if (poker_1.RANKS.includes(char)) {
+                    foundToken = char;
+                    remaining = remaining.substring(1);
+                }
+                else {
+                    // Invalid character found
+                    return null;
+                }
+            }
+            if (foundToken) {
+                tokens.push(foundToken);
+            }
+        }
+        // Now maps tokens to cards in hand
+        for (const token of tokens) {
+            // Token is already normalized rank string (e.g. '10', 'A', 'BJ')
+            const idx = tempHand.findIndex(c => c.rank === token);
+            if (idx === -1) {
+                // Not found in hand
+                return null;
+            }
+            // Remove from tempHand to avoid double counting same card
+            selected.push(tempHand[idx]);
+            tempHand.splice(idx, 1);
+        }
+        return selected;
+    }
+}
+exports.GameClient = GameClient;

package/dist/game/logic.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeHand = analyzeHand;
+exports.canBeat = canBeat;
+function analyzeHand(cards) {
+    const len = cards.length;
+    if (len === 0)
+        return { type: 'invalid', rankValue: 0, length: 0 };
+    // Sort descending
+    cards.sort((a, b) => b.value - a.value);
+    // Check Rocket (Red Joker + Black Joker)
+    if (len === 2 && cards[0].value === 17 && cards[1].value === 16) {
+        return { type: 'rocket', rankValue: 100, length: 2 };
+    }
+    // Check Bomb (4 same rank)
+    if (len === 4 && cards[0].value === cards[3].value) {
+        return { type: 'bomb', rankValue: cards[0].value, length: 4 };
+    }
+    // Single
+    if (len === 1) {
+        return { type: 'single', rankValue: cards[0].value, length: 1 };
+    }
+    // Pair
+    if (len === 2 && cards[0].value === cards[1].value) {
+        return { type: 'pair', rankValue: cards[0].value, length: 2 };
+    }
+    // Triple
+    if (len === 3 && cards[0].value === cards[2].value) {
+        return { type: 'triple', rankValue: cards[0].value, length: 3 };
+    }
+    // Triple + One
+    if (len === 4) {
+        // 3 same + 1 diff. Because sorted, 3 same must be at start or end.
+        // AAA B or B AAA
+        if (cards[0].value === cards[2].value) { // AAA B
+            return { type: 'triple_one', rankValue: cards[0].value, length: 4 };
+        }
+        if (cards[1].value === cards[3].value) { // B AAA
+            return { type: 'triple_one', rankValue: cards[1].value, length: 4 };
+        }
+    }
+    // Triple + Pair
+    if (len === 5) {
+        // AAA BB or BB AAA
+        if (cards[0].value === cards[2].value && cards[3].value === cards[4].value) { // AAA BB
+            return { type: 'triple_pair', rankValue: cards[0].value, length: 5 };
+        }
+        if (cards[0].value === cards[1].value && cards[2].value === cards[4].value) { // BB AAA
+            return { type: 'triple_pair', rankValue: cards[2].value, length: 5 };
+        }
+    }
+    // Straight (顺子): 5+ cards, consecutive values, max rank A (14). 2 (15) and Jokers (16,17) cannot be in straight.
+    if (len >= 5) {
+        const isStraight = cards.every((c, i) => {
+            if (i === 0)
+                return true;
+            return c.value === cards[i - 1].value - 1;
+        });
+        // Check max value is not 2 or Joker 
+        // cards are sorted desc, so cards[0] is max
+        if (isStraight && cards[0].value < 15) {
+            return { type: 'straight', rankValue: cards[0].value, length: len };
+        }
+    }
+    // Consecutive Pairs (连对): 3+ pairs (6+ cards), consecutive pair values. No 2, No Joker.
+    if (len >= 6 && len % 2 === 0) {
+        let isConsecutivePairs = true;
+        for (let i = 0; i < len; i += 2) {
+            // Check pair
+            if (cards[i].value !== cards[i + 1].value) {
+                isConsecutivePairs = false;
+                break;
+            }
+            // Check consecutive with previous pair
+            if (i > 0) {
+                if (cards[i].value !== cards[i - 2].value - 1) {
+                    isConsecutivePairs = false;
+                    break;
+                }
+            }
+        }
+        if (isConsecutivePairs && cards[0].value < 15) {
+            return { type: 'consecutive_pairs', rankValue: cards[0].value, length: len };
+        }
+    }
+    // Airplane (飞机): Consecutive Triples (e.g., 333444). 
+    // Simplify: Just check strictly consecutive triples without wings for this detector, 
+    // or heuristic: if we find consecutive triples, we call it airplane for effect.
+    // Let's do a basic frequency map check.
+    const counts = {};
+    cards.forEach(c => counts[c.value] = (counts[c.value] || 0) + 1);
+    const triples = [];
+    for (const val in counts) {
+        if (counts[val] >= 3)
+            triples.push(Number(val));
+    }
+    triples.sort((a, b) => b - a); // Descending
+    // Check for consecutive triples
+    let consecutiveTriples = 0;
+    for (let i = 0; i < triples.length - 1; i++) {
+        if (triples[i] === triples[i + 1] + 1 && triples[i] < 15) { // No 2/Jokers in airplane
+            consecutiveTriples++;
+        }
+    }
+    // minimal airplane is 2 consecutive triples
+    if (consecutiveTriples >= 1) {
+        // This is a loose check, mostly for the Visual Effect triggering
+        // Since we want to show "Airplane" effect.
+        return { type: 'airplane', rankValue: triples[0], length: len };
+    }
+    return { type: 'invalid', rankValue: 0, length: 0 };
+}
+function canBeat(lastHand, newHand) {
+    const last = analyzeHand(lastHand);
+    const curr = analyzeHand(newHand);
+    if (curr.type === 'invalid')
+        return false;
+    // Rocket beats everything
+    if (curr.type === 'rocket')
+        return true;
+    if (last.type === 'rocket')
+        return false;
+    // Bomb beats everything except rocket and bigger bomb
+    if (curr.type === 'bomb') {
+        if (last.type === 'bomb')
+            return curr.rankValue > last.rankValue;
+        return true;
+    }
+    if (last.type === 'bomb')
+        return false; // Current is not bomb/rocket
+    // Otherwise, types must match and lengths must match (usually)
+    if (curr.type !== last.type)
+        return false;
+    if (curr.length !== last.length)
+        return false;
+    return curr.rankValue > last.rankValue;
+}

package/dist/game/poker.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RANKS = void 0;
+exports.getCardValue = getCardValue;
+exports.createDeck = createDeck;
+exports.shuffleDeck = shuffleDeck;
+exports.sortHand = sortHand;
+exports.formatCard = formatCard;
+exports.RANKS = ['3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A', '2', 'BJ', 'RJ'];
+function getCardValue(rank) {
+    const index = exports.RANKS.indexOf(rank);
+    // 3 is index 0 -> value 3
+    // ...
+    return index + 3;
+}
+function createDeck() {
+    const suits = ['♠', '♥', '♣', '♦'];
+    // Normal cards 3 to 2
+    const normalRanks = exports.RANKS.slice(0, 13); // 3 to 2
+    let deck = [];
+    for (const r of normalRanks) {
+        for (const s of suits) {
+            deck.push({ suit: s, rank: r, value: getCardValue(r) });
+        }
+    }
+    // Jokers
+    deck.push({ suit: '', rank: 'BJ', value: 16 });
+    deck.push({ suit: '', rank: 'RJ', value: 17 });
+    return deck;
+}
+function shuffleDeck(deck) {
+    for (let i = deck.length - 1; i > 0; i--) {
+        const j = Math.floor(Math.random() * (i + 1));
+        [deck[i], deck[j]] = [deck[j], deck[i]];
+    }
+    return deck;
+}
+function sortHand(hand) {
+    // Sort descending by value
+    return hand.sort((a, b) => b.value - a.value);
+}
+function formatCard(c) {
+    // Add colors later via chalk in client, here just string
+    if (c.rank === 'RJ')
+        return ' [ 大王 ] '; // Big Joker
+    if (c.rank === 'BJ')
+        return ' [ 小王 ] '; // Little Joker
+    // Pad rank with space if single digit for alignment
+    const r = c.rank === '10' ? '10' : ` ${c.rank}`;
+    return ` [${c.suit}${r}] `;
+}

package/dist/game/view.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderCards = renderCards;
+const chalk_1 = __importDefault(require("chalk"));
+function renderCards(cards) {
+    if (cards.length === 0)
+        return '';
+    let line1 = '';
+    let line2 = '';
+    let line3 = '';
+    let line4 = '';
+    const colorMap = (c, str) => {
+        if (c.suit === '♥' || c.suit === '♦' || c.rank === 'RJ') {
+            return chalk_1.default.red(str);
+        }
+        else if (c.suit === '♠' || c.suit === '♣' || c.rank === 'BJ') {
+            return chalk_1.default.white(str); // Spades/Clubs white on black terminal usually best, or black on white
+        }
+        return str;
+    };
+    cards.forEach((card, i) => {
+        const isFirst = i === 0;
+        // Rank Display (2 chars)
+        let rankStr = card.rank;
+        if (card.rank === '10')
+            rankStr = '10';
+        else if (card.rank === 'BJ')
+            rankStr = 'BJ';
+        else if (card.rank === 'RJ')
+            rankStr = 'RJ';
+        else
+            rankStr = `${card.rank} `; // Pad single digit
+        // Suit Display (2 chars)
+        let suitStr = card.suit ? `${card.suit} ` : '  ';
+        // Apply colors to inner content
+        const coloredRank = colorMap(card, rankStr);
+        const coloredSuit = colorMap(card, suitStr);
+        // Build segments
+        // Top: ┌──┐ or ──┐
+        // Mid1: │RR│ or RR│
+        // Mid2: │SS│ or SS│
+        // Bot: └──┘ or ──┘
+        if (isFirst) {
+            line1 += `┌──┐`;
+            line2 += `│${coloredRank}│`;
+            line3 += `│${coloredSuit}│`;
+            line4 += `└──┘`;
+        }
+        else {
+            line1 += `──┐`;
+            line2 += `${coloredRank}│`;
+            line3 += `${coloredSuit}│`;
+            line4 += `──┘`;
+        }
+    });
+    return `${line1}\n${line2}\n${line3}\n${line4}`;
+}

package/dist/index.js

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const inquirer_1 = __importDefault(require("inquirer"));
+const chalk_1 = __importDefault(require("chalk"));
+const figlet_1 = __importDefault(require("figlet"));
+const server_1 = require("./server");
+const client_1 = require("./client");
+const os_1 = __importDefault(require("os"));
+console.clear();
+console.log(chalk_1.default.red(figlet_1.default.textSync('Maid Poker', { font: 'Standard' })));
+function getLocalIPs() {
+    const nets = os_1.default.networkInterfaces();
+    const results = [];
+    for (const name of Object.keys(nets)) {
+        for (const net of nets[name]) {
+            // Skip over non-IPv4 and internal (i.e. 127.0.0.1) addresses
+            if (net.family === 'IPv4' && !net.internal) {
+                results.push(net.address);
+            }
+        }
+    }
+    return results.length > 0 ? results : ['127.0.0.1'];
+}
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { mode } = yield inquirer_1.default.prompt([
+            {
+                type: 'list',
+                name: 'mode',
+                message: '你想创建游戏(Host)还是加入游戏(Join)?',
+                choices: ['创建游戏 (Host Game)', '加入游戏 (Join Game)']
+            }
+        ]);
+        if (mode.includes('Host')) {
+            const ips = getLocalIPs();
+            console.log(chalk_1.default.blue(`\n服务器已启动，请尝试以下IP: \n${ips.map(ip => ` - ${ip}`).join('\n')}`));
+            // Start the server
+            new server_1.GameServer();
+            const { joinAsPlayer } = yield inquirer_1.default.prompt([{
+                    type: 'confirm',
+                    name: 'joinAsPlayer',
+                    message: '你想在本机参与游戏吗?',
+                    default: true
+                }]);
+            if (joinAsPlayer) {
+                const { name } = yield inquirer_1.default.prompt([{
+                        type: 'input',
+                        name: 'name',
+                        message: '请输入你的昵称:',
+                        default: '房主'
+                    }]);
+                new client_1.GameClient('http://localhost:3000', name);
+            }
+        }
+        else {
+            const { ip, name } = yield inquirer_1.default.prompt([
+                {
+                    type: 'input',
+                    name: 'ip',
+                    message: '请输入主机IP地址:',
+                    default: '127.0.0.1'
+                },
+                {
+                    type: 'input',
+                    name: 'name',
+                    message: '请输入你的昵称:',
+                }
+            ]);
+            new client_1.GameClient(`http://${ip}:3000`, name);
+        }
+    });
+}
+main().catch(console.error);

package/dist/server.js

@@ -0,0 +1,240 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GameServer = void 0;
+const poker_1 = require("./game/poker");
+const socket_io_1 = require("socket.io");
+const http_1 = require("http");
+const PORT = 3000;
+class GameServer {
+    constructor() {
+        this.players = [];
+        this.state = {
+            phase: 'waiting',
+            deck: [],
+            currentTurnIndex: 0,
+            landlordIndex: -1,
+            lastPlayedCards: [],
+            lastPlayedIndex: -1
+        };
+        const httpServer = (0, http_1.createServer)();
+        this.io = new socket_io_1.Server(httpServer);
+        this.io.on('connection', (socket) => {
+            socket.on('join_game', (name) => this.handleJoin(socket, name));
+            socket.on('disconnect', () => this.handleDisconnect(socket));
+            socket.on('player_ready', () => this.handleReady(socket));
+            // Game events
+            socket.on('bid_landlord', (bid) => this.handleBid(socket, bid));
+            socket.on('play_cards', (cards) => this.handlePlay(socket, cards));
+            socket.on('pass', () => this.handlePass(socket));
+        });
+        httpServer.listen(PORT, '0.0.0.0', () => {
+            // Logs handled in index.ts usually, but good to have here
+        });
+    }
+    handleJoin(socket, name) {
+        if (this.players.length >= 3) {
+            socket.emit('error_msg', '房间已满');
+            return;
+        }
+        // Allow joining if in waiting phase
+        if (this.state.phase !== 'waiting' && this.state.phase !== 'ended') {
+            socket.emit('error_msg', '游戏进行中');
+            return;
+        }
+        const newPlayer = {
+            id: socket.id,
+            socket,
+            name,
+            hand: [],
+            role: 'peasant',
+            isReady: false
+        };
+        this.players.push(newPlayer);
+        console.log(`${name} 加入了游戏. (${this.players.length}/3)`);
+        // Broadcast updated player list
+        this.broadcastPlayerList();
+        // If 3 players, ask them to get ready (or auto-ready for first game?)
+        // For UX consistency, let's treat "Join" as implicitly ready for the first game if we want instant start,
+        // BUT for "Restart" feature, explicit ready is better.
+        // Let's make the first game auto-start when 3 join for simplicity, 
+        // and subsequent games require explicit ready.
+        if (this.players.length === 3) {
+            console.log('房间已满，准备开始...');
+            // Mark all valid players as ready for the first game? 
+            // Or just start immediately.
+            this.startGame();
+        }
+    }
+    handleReady(socket) {
+        const player = this.players.find(p => p.id === socket.id);
+        if (!player)
+            return;
+        player.isReady = true;
+        console.log(`${player.name} 已准备.`);
+        // Notify others?
+        // Check if all 3 are ready
+        if (this.players.length === 3 && this.players.every(p => p.isReady)) {
+            this.startGame();
+        }
+    }
+    handleDisconnect(socket) {
+        const player = this.players.find(p => p.id === socket.id);
+        this.players = this.players.filter(p => p.id !== socket.id);
+        if (player) {
+            console.log(`客户端断开连接: ${player.name} (${socket.id})`);
+        }
+        this.broadcastPlayerList();
+        // Reset game if someone leaves during play
+        if (this.state.phase !== 'waiting' && this.state.phase !== 'ended') {
+            this.io.emit('error_msg', '玩家断开连接，游戏重置。');
+            this.resetGame();
+        }
+    }
+    broadcastPlayerList() {
+        const names = this.players.map(p => p.name);
+        this.io.emit('player_list_update', names);
+    }
+    startGame() {
+        console.log('所有玩家准备就绪，游戏开始!');
+        this.state.phase = 'bidding';
+        this.state.lastPlayedCards = [];
+        this.state.lastPlayedIndex = -1;
+        this.state.landlordIndex = -1;
+        this.state.deck = [];
+        // Reset ready status for next time? No, do it at end.
+        this.players.forEach(p => {
+            p.isReady = false;
+            p.role = 'peasant';
+            p.hand = [];
+        });
+        // 1. Shuffle and Deal
+        const fullDeck = (0, poker_1.shuffleDeck)((0, poker_1.createDeck)());
+        this.state.deck = fullDeck.splice(0, 3); // 3 hidden cards
+        // Deal 17 cards to each
+        this.players[0].hand = (0, poker_1.sortHand)(fullDeck.splice(0, 17));
+        this.players[1].hand = (0, poker_1.sortHand)(fullDeck.splice(0, 17));
+        this.players[2].hand = (0, poker_1.sortHand)(fullDeck.splice(0, 17));
+        this.players.forEach(p => {
+            p.socket.emit('game_start', { hand: p.hand });
+        });
+        // 2. Start Bidding (Simple random start for now)
+        this.state.currentTurnIndex = Math.floor(Math.random() * 3);
+        this.notifyTurn('bid');
+    }
+    notifyTurn(action) {
+        const player = this.players[this.state.currentTurnIndex];
+        this.io.emit('turn_update', {
+            playerIndex: this.state.currentTurnIndex,
+            playerName: player.name,
+            action
+        });
+        player.socket.emit('your_turn', { action });
+    }
+    // Placeholder handlers
+    handleBid(socket, bid) {
+        const playerIndex = this.players.findIndex(p => p.id === socket.id);
+        if (playerIndex !== this.state.currentTurnIndex)
+            return;
+        if (bid > 0) {
+            // Claimed!
+            this.state.landlordIndex = playerIndex;
+            this.players[playerIndex].role = 'landlord';
+            this.players[playerIndex].hand.push(...this.state.deck);
+            this.players[playerIndex].hand = (0, poker_1.sortHand)(this.players[playerIndex].hand);
+            this.state.phase = 'playing';
+            this.io.emit('landlord_chosen', {
+                landlordName: this.players[playerIndex].name,
+                hiddenCards: this.state.deck
+            });
+            // Sync new hand
+            this.players[playerIndex].socket.emit('hand_update', this.players[playerIndex].hand);
+            // Landlord plays first
+            this.notifyTurn('play');
+        }
+        else {
+            // Pass bid
+            this.state.currentTurnIndex = (this.state.currentTurnIndex + 1) % 3;
+            // MVP: Infinite loop until someone takes it
+            this.notifyTurn('bid');
+        }
+    }
+    handlePlay(socket, cards) {
+        const playerIndex = this.players.findIndex(p => p.id === socket.id);
+        if (playerIndex !== this.state.currentTurnIndex)
+            return;
+        // Validate Play
+        const { canBeat, analyzeHand } = require('./game/logic');
+        // If this is a new round (lastPlayedCards is empty), just check validity of the hand itself
+        if (this.state.lastPlayedCards.length === 0) {
+            const analysis = analyzeHand(cards);
+            if (analysis.type === 'invalid') {
+                socket.emit('error_msg', '无效的牌型!');
+                this.players[playerIndex].socket.emit('your_turn', { action: 'play' });
+                return;
+            }
+        }
+        else {
+            // Check if it beats the last played cards
+            const valid = canBeat(this.state.lastPlayedCards, cards);
+            if (!valid) {
+                socket.emit('error_msg', '出牌无效: 你的牌必须大过上家!');
+                this.players[playerIndex].socket.emit('your_turn', { action: 'play' });
+                return;
+            }
+        }
+        this.state.lastPlayedCards = cards;
+        this.state.lastPlayedIndex = playerIndex;
+        // Remove cards from hand
+        const p = this.players[playerIndex];
+        cards.forEach(c => {
+            const idx = p.hand.findIndex(h => h.suit === c.suit && h.rank === c.rank);
+            if (idx !== -1)
+                p.hand.splice(idx, 1);
+        });
+        p.socket.emit('hand_update', p.hand);
+        this.io.emit('player_played', {
+            playerName: p.name,
+            cards: cards,
+            remainingCount: p.hand.length
+        });
+        if (p.hand.length === 0) {
+            this.state.phase = 'ended';
+            this.io.emit('game_over', { winner: p.name, role: p.role });
+            // Don't kill server, wait for ready
+        }
+        else {
+            this.state.currentTurnIndex = (this.state.currentTurnIndex + 1) % 3;
+            this.notifyTurn('play');
+        }
+    }
+    handlePass(socket) {
+        const playerIndex = this.players.findIndex(p => p.id === socket.id);
+        if (playerIndex !== this.state.currentTurnIndex)
+            return;
+        if (this.state.lastPlayedIndex === playerIndex || this.state.lastPlayedIndex === -1) {
+            // Cannot pass if you started the round
+            socket.emit('error_msg', '这是新回合，必须出牌');
+            this.players[playerIndex].socket.emit('your_turn', { action: 'play' });
+            return; // Ask them to play again
+        }
+        this.io.emit('player_passed', { playerName: this.players[playerIndex].name });
+        this.state.currentTurnIndex = (this.state.currentTurnIndex + 1) % 3;
+        // If next player is the one who played last, they win the round and start new
+        if (this.state.currentTurnIndex === this.state.lastPlayedIndex) {
+            this.state.lastPlayedCards = []; // Clear
+            this.io.emit('new_round', { playerName: this.players[this.state.currentTurnIndex].name });
+        }
+        this.notifyTurn('play');
+    }
+    resetGame() {
+        this.state.phase = 'waiting';
+        this.players.forEach(p => {
+            p.hand = [];
+            p.role = 'peasant';
+            p.isReady = false;
+        });
+        this.state.deck = [];
+        this.broadcastPlayerList();
+    }
+}
+exports.GameServer = GameServer;

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "maid-poker-cli",
+  "version": "1.0.0",
+  "description": "女仆扑克牌 (Maid Poker) - A Command Line Dou Dizhu Game",
+  "main": "dist/index.js",
+  "bin": {
+    "maid-poker": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "start": "ts-node src/index.ts",
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "game",
+    "poker",
+    "dou-dizhu",
+    "cli",
+    "multiplayer"
+  ],
+  "author": "Joyeka",
+  "license": "ISC",
+  "dependencies": {
+    "@types/figlet": "^1.7.0",
+    "@types/inquirer": "^9.0.9",
+    "@types/node": "^25.0.3",
+    "chalk": "^4.1.2",
+    "figlet": "^1.9.4",
+    "inquirer": "^8.2.5",
+    "socket.io": "^4.8.3",
+    "socket.io-client": "^4.8.3",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.7.3"
+  }
+}