maid-poker-cli 1.0.0 → 1.0.1

package/dist/game/logic.js

@@ -2,36 +2,74 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.analyzeHand = analyzeHand;
 exports.canBeat = canBeat;
-function analyzeHand(cards) {
+exports.getHandTypeForEffect = getHandTypeForEffect;
+// 获取牌的频率统计
+function getCardCounts(cards) {
+    const counts = {};
+    cards.forEach(c => counts[c.value] = (counts[c.value] || 0) + 1);
+    return counts;
+}
+// 统计王的数量
+function countJokers(cards) {
+    let big = 0, small = 0;
+    cards.forEach(c => {
+        if (c.value === 17)
+            big++;
+        if (c.value === 16)
+            small++;
+    });
+    return { big, small };
+}
+function analyzeHand(cards, gameMode = 'three_player') {
     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 };
+    const counts = getCardCounts(cards);
+    const jokers = countJokers(cards);
+    const totalJokers = jokers.big + jokers.small;
+    // ====== 四人模式特殊牌型 ======
+    if (gameMode === 'four_player') {
+        // 天王炸（4王，最强）- 2大王+2小王
+        if (len === 4 && totalJokers === 4) {
+            return { type: 'quad_joker', rankValue: 200, length: 4, bombLevel: 4 };
+        }
+        // 八炸（8张相同）
+        if (len === 8) {
+            const vals = Object.keys(counts).map(Number);
+            if (vals.length === 1 && counts[vals[0]] === 8) {
+                return { type: 'octo_bomb', rankValue: vals[0], length: 8, bombLevel: 3 };
+            }
+        }
+        // 普通王炸（1大1小）- 四人模式下等级为2，介于普通炸弹和八炸之间
+        if (len === 2 && jokers.big >= 1 && jokers.small >= 1) {
+            return { type: 'rocket', rankValue: 100, length: 2, bombLevel: 2 };
+        }
+    }
+    // ====== 通用牌型（三人和四人模式共享） ======
+    // 普通王炸（三人模式：1大1小；四人模式不适用这里，已在上面处理）
+    if (gameMode === 'three_player' && len === 2 && cards[0].value === 17 && cards[1].value === 16) {
+        return { type: 'rocket', rankValue: 100, length: 2, bombLevel: 5 }; // 三人模式王炸最大
     }
-    // Check Bomb (4 same rank)
+    // 普通炸弹（4张相同）
     if (len === 4 && cards[0].value === cards[3].value) {
-        return { type: 'bomb', rankValue: cards[0].value, length: 4 };
+        return { type: 'bomb', rankValue: cards[0].value, length: 4, bombLevel: 1 };
     }
-    // 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 };
         }
@@ -39,9 +77,8 @@ function analyzeHand(cards) {
             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 };
         }
@@ -49,29 +86,96 @@ function analyzeHand(cards) {
             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 (gameMode === 'four_player' && len === 6) {
+        const vals = Object.keys(counts).map(Number);
+        const fourVal = vals.find(v => counts[v] === 4);
+        if (fourVal !== undefined) {
+            // 找到4张相同的牌，剩下2张是单牌
+            const others = vals.filter(v => v !== fourVal);
+            if (others.length === 2 || (others.length === 1 && counts[others[0]] === 2)) {
+                return { type: 'four_with_two', rankValue: fourVal, length: 6 };
+            }
+        }
+    }
+    // 四带两对（四人模式）
+    if (gameMode === 'four_player' && len === 8) {
+        const vals = Object.keys(counts).map(Number);
+        const fourVal = vals.find(v => counts[v] === 4);
+        if (fourVal !== undefined) {
+            const others = vals.filter(v => v !== fourVal);
+            // 检查剩余是否都是对子
+            const allPairs = others.every(v => counts[v] === 2);
+            if (allPairs && others.length === 2) {
+                return { type: 'four_with_pairs', rankValue: fourVal, length: 8 };
+            }
+        }
+    }
+    // ====== 顺子 ======
+    // 三人模式：5张及以上连牌，不含2和王
+    // 四人模式：5张及以上连牌，可含2，不含王（如 A2345, 10JQKA 都可以）
     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 };
+        // 检查是否包含王
+        const hasJoker = cards.some(c => c.value >= 16);
+        if (!hasJoker) {
+            let isStraight = true;
+            // 四人模式特殊处理：支持包含2的顺子
+            if (gameMode === 'four_player') {
+                // 检查是否是 A2345 这种情况（A作为1使用）
+                const sortedValues = cards.map(c => c.value).sort((a, b) => a - b);
+                const minVal = sortedValues[0];
+                const maxVal = sortedValues[sortedValues.length - 1];
+                // 正常顺子检查
+                for (let i = 0; i < len - 1; i++) {
+                    if (sortedValues[i + 1] - sortedValues[i] !== 1) {
+                        isStraight = false;
+                        break;
+                    }
+                }
+                // 检查 A2345 (值: 3,4,5,14,15 -> 需要把A视为1)
+                if (!isStraight && sortedValues.includes(14) && sortedValues.includes(15)) {
+                    const adjustedValues = sortedValues.map(v => v === 14 ? 1 : v === 15 ? 2 : v).sort((a, b) => a - b);
+                    isStraight = true;
+                    for (let i = 0; i < len - 1; i++) {
+                        if (adjustedValues[i + 1] - adjustedValues[i] !== 1) {
+                            isStraight = false;
+                            break;
+                        }
+                    }
+                    if (isStraight) {
+                        return { type: 'straight', rankValue: 15, length: len }; // 2是最大值
+                    }
+                }
+            }
+            else {
+                // 三人模式：不能包含2
+                if (cards[0].value >= 15) {
+                    isStraight = false;
+                }
+                else {
+                    for (let i = 0; i < len - 1; i++) {
+                        if (cards[i].value - cards[i + 1].value !== 1) {
+                            isStraight = false;
+                            break;
+                        }
+                    }
+                }
+            }
+            if (isStraight && cards[0].value < 16) {
+                return { type: 'straight', rankValue: cards[0].value, length: len };
+            }
         }
     }
-    // Consecutive Pairs (连对): 3+ pairs (6+ cards), consecutive pair values. No 2, No Joker.
+    // ====== 连对 ======
+    // 三人模式：3对及以上连对，不含2和王
+    // 四人模式：3对及以上连对
     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;
@@ -79,59 +183,112 @@ function analyzeHand(cards) {
                 }
             }
         }
-        if (isConsecutivePairs && cards[0].value < 15) {
+        // 三人模式不能包含2
+        const maxVal = gameMode === 'three_player' ? 14 : 15;
+        if (isConsecutivePairs && cards[0].value <= maxVal) {
             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++;
+    triples.sort((a, b) => b - a);
+    // 检查连续三张的数量
+    if (triples.length >= 2) {
+        // 找最长的连续三张序列
+        let maxConsecutive = 1;
+        let currentConsecutive = 1;
+        let startTriple = triples[0];
+        for (let i = 0; i < triples.length - 1; i++) {
+            const maxAllowed = gameMode === 'three_player' ? 14 : 15; // 三人模式不含2
+            if (triples[i] <= maxAllowed && triples[i] === triples[i + 1] + 1) {
+                currentConsecutive++;
+                if (currentConsecutive > maxConsecutive) {
+                    maxConsecutive = currentConsecutive;
+                    startTriple = triples[i - maxConsecutive + 2];
+                }
+            }
+            else {
+                currentConsecutive = 1;
+            }
+        }
+        if (maxConsecutive >= 2) {
+            // 验证翅膀数量
+            const tripleCount = maxConsecutive;
+            const expectedLen = tripleCount * 3; // 无翅膀
+            const expectedLenWithSingles = tripleCount * 4; // 带单
+            const expectedLenWithPairs = tripleCount * 5; // 带对
+            if (len === expectedLen || len === expectedLenWithSingles || len === expectedLenWithPairs) {
+                return { type: 'airplane', rankValue: startTriple, length: len };
+            }
         }
-    }
-    // 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);
+function canBeat(lastHand, newHand, gameMode = 'three_player') {
+    const last = analyzeHand(lastHand, gameMode);
+    const curr = analyzeHand(newHand, gameMode);
     if (curr.type === 'invalid')
         return false;
-    // Rocket beats everything
-    if (curr.type === 'rocket')
+    // ====== 炸弹比较逻辑 ======
+    const isBombType = (type) => ['bomb', 'rocket', 'quad_joker', 'octo_bomb'].includes(type);
+    const currIsBomb = isBombType(curr.type);
+    const lastIsBomb = isBombType(last.type);
+    if (currIsBomb && lastIsBomb) {
+        // 都是炸弹类型，比较炸弹级别
+        // 炸弹等级：普通炸(1) < 双王炸(2) < 八炸(3) < 天王炸(4) ; 三人王炸(5)
+        const currLevel = curr.bombLevel || 0;
+        const lastLevel = last.bombLevel || 0;
+        if (currLevel !== lastLevel) {
+            return currLevel > lastLevel;
+        }
+        // 同级别炸弹比较点数
+        return curr.rankValue > last.rankValue;
+    }
+    // 炸弹类型打非炸弹类型
+    if (currIsBomb && !lastIsBomb) {
         return true;
-    if (last.type === 'rocket')
+    }
+    // 非炸弹类型不能打炸弹类型
+    if (!currIsBomb && lastIsBomb) {
         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;
 }
+// 导出用于特效判断
+function getHandTypeForEffect(cards, gameMode = 'three_player') {
+    const analysis = analyzeHand(cards, gameMode);
+    const typeNames = {
+        'single': '单张',
+        'pair': '对子',
+        'triple': '三张',
+        'triple_one': '三带一',
+        'triple_pair': '三带对',
+        'four_with_two': '四带二',
+        'four_with_pairs': '四带两对',
+        'bomb': '炸弹',
+        'rocket': gameMode === 'four_player' ? '双王炸' : '王炸',
+        'quad_joker': '天王炸',
+        'octo_bomb': '八炸',
+        'straight': '顺子',
+        'consecutive_pairs': '连对',
+        'airplane': '飞机',
+        'invalid': '无效'
+    };
+    return {
+        type: analysis.type,
+        rankValue: analysis.rankValue,
+        displayName: typeNames[analysis.type]
+    };
+}

package/dist/game/poker.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RANKS = void 0;
 exports.getCardValue = getCardValue;
 exports.createDeck = createDeck;
+exports.createDoubleDeck = createDoubleDeck;
 exports.shuffleDeck = shuffleDeck;
 exports.sortHand = sortHand;
 exports.formatCard = formatCard;
@@ -28,6 +29,24 @@ function createDeck() {
     deck.push({ suit: '', rank: 'RJ', value: 17 });
     return deck;
 }
+// 创建双副牌（用于四人斗地主，共108张牌）
+function createDoubleDeck() {
+    const suits = ['♠', '♥', '♣', '♦'];
+    const normalRanks = exports.RANKS.slice(0, 13); // 3 to 2
+    let deck = [];
+    // 两副牌
+    for (let deckIdx = 0; deckIdx < 2; deckIdx++) {
+        for (const r of normalRanks) {
+            for (const s of suits) {
+                deck.push({ suit: s, rank: r, value: getCardValue(r), deckIndex: deckIdx });
+            }
+        }
+        // Jokers
+        deck.push({ suit: '', rank: 'BJ', value: 16, deckIndex: deckIdx });
+        deck.push({ suit: '', rank: 'RJ', value: 17, deckIndex: deckIdx });
+    }
+    return deck; // 共 108 张牌
+}
 function shuffleDeck(deck) {
     for (let i = deck.length - 1; i > 0; i--) {
         const j = Math.floor(Math.random() * (i + 1));

package/dist/index.js

@@ -45,10 +45,41 @@ function main() {
             }
         ]);
         if (mode.includes('Host')) {
+            // 选择游戏模式
+            const { gameMode } = yield inquirer_1.default.prompt([
+                {
+                    type: 'list',
+                    name: 'gameMode',
+                    message: '请选择游戏模式:',
+                    choices: [
+                        { name: '三人斗地主 (1副牌, 每人17张)', value: 'three_player' },
+                        { name: '四人斗地主 (2副牌, 每人25张)', value: 'four_player' }
+                    ]
+                }
+            ]);
+            const selectedMode = gameMode;
+            const requiredPlayers = selectedMode === 'three_player' ? 3 : 4;
+            const modeText = selectedMode === 'three_player' ? '三人斗地主' : '四人斗地主(2副牌)';
+            console.log(chalk_1.default.magenta(`\n已选择: ${modeText}`));
+            console.log(chalk_1.default.gray(`需要 ${requiredPlayers} 位玩家参与\n`));
+            // 显示规则提示
+            if (selectedMode === 'four_player') {
+                console.log(chalk_1.default.yellow('=== 四人斗地主规则 ==='));
+                console.log(chalk_1.default.gray('• 使用2副牌(108张)，每人25张，8张底牌'));
+                console.log(chalk_1.default.gray('• 顺子可含2 (如 A2345, 10JQKA)'));
+                console.log(chalk_1.default.gray('• 新增牌型:'));
+                console.log(chalk_1.default.cyan('  - 四带二: 4张相同 + 2张单牌'));
+                console.log(chalk_1.default.cyan('  - 四带两对: 4张相同 + 2对'));
+                console.log(chalk_1.default.cyan('  - 双王炸: 2大王 + 2小王'));
+                console.log(chalk_1.default.cyan('  - 八炸: 8张相同牌'));
+                console.log(chalk_1.default.cyan('  - 天王炸: 4张王 (最强)'));
+                console.log(chalk_1.default.gray('• 炸弹大小: 天王炸 > 八炸 > 双王炸 > 普通炸弹'));
+                console.log('');
+            }
             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();
+            // Start the server with selected game mode
+            new server_1.GameServer(selectedMode);
             const { joinAsPlayer } = yield inquirer_1.default.prompt([{
                     type: 'confirm',
                     name: 'joinAsPlayer',