maid-poker-cli 1.0.0 → 1.0.1

package/dist/game/__tests__/logic.test.js

@@ -0,0 +1,467 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const logic_1 = require("../logic");
+// 辅助函数：快速创建牌
+function createCard(rank, suit = '♠') {
+    const RANKS = ['3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A', '2', 'BJ', 'RJ'];
+    const value = RANKS.indexOf(rank) + 3;
+    return { suit, rank, value };
+}
+// 辅助函数：创建多张同一花色的牌
+function createCards(ranks, suit = '♠') {
+    return ranks.map(r => createCard(r, suit));
+}
+// 辅助函数：创建指定数量的相同牌
+function createSameCards(rank, count) {
+    const suits = ['♠', '♥', '♣', '♦'];
+    return Array.from({ length: count }, (_, i) => createCard(rank, suits[i % 4]));
+}
+// 辅助函数：创建用于四人模式的双副牌中的相同牌
+function createSameCardsDouble(rank, count) {
+    const suits = ['♠', '♥', '♣', '♦'];
+    const cards = [];
+    for (let i = 0; i < count; i++) {
+        const deckIndex = Math.floor(i / 4);
+        cards.push({
+            suit: suits[i % 4],
+            rank,
+            value: createCard(rank).value,
+            deckIndex
+        });
+    }
+    return cards;
+}
+// 辅助函数：创建4张王（天王炸）
+function createQuadJoker() {
+    return [
+        { suit: '', rank: 'RJ', value: 17, deckIndex: 0 },
+        { suit: '', rank: 'RJ', value: 17, deckIndex: 1 },
+        { suit: '', rank: 'BJ', value: 16, deckIndex: 0 },
+        { suit: '', rank: 'BJ', value: 16, deckIndex: 1 },
+    ];
+}
+describe('三人斗地主 (Three Player Mode)', () => {
+    const gameMode = 'three_player';
+    describe('牌型识别 (analyzeHand)', () => {
+        test('单张', () => {
+            const cards = createCards(['7']);
+            const result = (0, logic_1.analyzeHand)(cards, gameMode);
+            expect(result.type).toBe('single');
+            expect(result.rankValue).toBe(7);
+        });
+        test('对子', () => {
+            const cards = createSameCards('Q', 2);
+            const result = (0, logic_1.analyzeHand)(cards, gameMode);
+            expect(result.type).toBe('pair');
+            expect(result.rankValue).toBe(12);
+        });
+        test('三张', () => {
+            const cards = createSameCards('8', 3);
+            const result = (0, logic_1.analyzeHand)(cards, gameMode);
+            expect(result.type).toBe('triple');
+            expect(result.rankValue).toBe(8);
+        });
+        test('三带一', () => {
+            const cards = [...createSameCards('8', 3), createCard('6')];
+            const result = (0, logic_1.analyzeHand)(cards, gameMode);
+            expect(result.type).toBe('triple_one');
+            expect(result.rankValue).toBe(8);
+        });
+        test('三带对', () => {
+            const cards = [...createSameCards('8', 3), ...createSameCards('6', 2)];
+            const result = (0, logic_1.analyzeHand)(cards, gameMode);
+            expect(result.type).toBe('triple_pair');
+            expect(result.rankValue).toBe(8);
+        });
+        test('顺子 (5张)', () => {
+            const cards = createCards(['3', '4', '5', '6', '7']);
+            const result = (0, logic_1.analyzeHand)(cards, gameMode);
+            expect(result.type).toBe('straight');
+            expect(result.rankValue).toBe(7);
+            expect(result.length).toBe(5);
+        });
+        test('顺子 (10-A)', () => {
+            const cards = createCards(['10', 'J', 'Q', 'K', 'A']);
+            const result = (0, logic_1.analyzeHand)(cards, gameMode);
+            expect(result.type).toBe('straight');
+            expect(result.rankValue).toBe(14); // A的值
+        });
+        test('顺子不能包含2', () => {
+            const cards = createCards(['J', 'Q', 'K', 'A', '2']);
+            const result = (0, logic_1.analyzeHand)(cards, gameMode);
+            expect(result.type).toBe('invalid');
+        });
+        test('连对 (3对)', () => {
+            const cards = [
+                ...createSameCards('7', 2),
+                ...createSameCards('8', 2),
+                ...createSameCards('9', 2)
+            ];
+            const result = (0, logic_1.analyzeHand)(cards, gameMode);
+            expect(result.type).toBe('consecutive_pairs');
+            expect(result.rankValue).toBe(9);
+        });
+        test('飞机 (不带)', () => {
+            const cards = [...createSameCards('3', 3), ...createSameCards('4', 3)];
+            const result = (0, logic_1.analyzeHand)(cards, gameMode);
+            expect(result.type).toBe('airplane');
+        });
+        test('飞机带单', () => {
+            const cards = [
+                ...createSameCards('3', 3),
+                ...createSameCards('4', 3),
+                createCard('7'),
+                createCard('9')
+            ];
+            const result = (0, logic_1.analyzeHand)(cards, gameMode);
+            expect(result.type).toBe('airplane');
+        });
+        test('飞机带对', () => {
+            const cards = [
+                ...createSameCards('3', 3),
+                ...createSameCards('4', 3),
+                ...createSameCards('7', 2),
+                ...createSameCards('9', 2)
+            ];
+            const result = (0, logic_1.analyzeHand)(cards, gameMode);
+            expect(result.type).toBe('airplane');
+        });
+        test('炸弹', () => {
+            const cards = createSameCards('6', 4);
+            const result = (0, logic_1.analyzeHand)(cards, gameMode);
+            expect(result.type).toBe('bomb');
+            expect(result.rankValue).toBe(6);
+            expect(result.bombLevel).toBe(1);
+        });
+        test('王炸', () => {
+            const cards = [createCard('RJ', ''), createCard('BJ', '')];
+            const result = (0, logic_1.analyzeHand)(cards, gameMode);
+            expect(result.type).toBe('rocket');
+            expect(result.bombLevel).toBe(5); // 三人模式王炸最大
+        });
+    });
+    describe('牌型比较 (canBeat)', () => {
+        test('大单张打小单张', () => {
+            const last = createCards(['7']);
+            const curr = createCards(['8']);
+            expect((0, logic_1.canBeat)(last, curr, gameMode)).toBe(true);
+        });
+        test('小单张不能打大单张', () => {
+            const last = createCards(['8']);
+            const curr = createCards(['7']);
+            expect((0, logic_1.canBeat)(last, curr, gameMode)).toBe(false);
+        });
+        test('大对子打小对子', () => {
+            const last = createSameCards('7', 2);
+            const curr = createSameCards('K', 2);
+            expect((0, logic_1.canBeat)(last, curr, gameMode)).toBe(true);
+        });
+        test('大炸弹打小炸弹', () => {
+            const last = createSameCards('5', 4);
+            const curr = createSameCards('9', 4);
+            expect((0, logic_1.canBeat)(last, curr, gameMode)).toBe(true);
+        });
+        test('小炸弹不能打大炸弹', () => {
+            const last = createSameCards('9', 4);
+            const curr = createSameCards('5', 4);
+            expect((0, logic_1.canBeat)(last, curr, gameMode)).toBe(false);
+        });
+        test('炸弹打非炸弹', () => {
+            const last = createCards(['7']);
+            const curr = createSameCards('3', 4);
+            expect((0, logic_1.canBeat)(last, curr, gameMode)).toBe(true);
+        });
+        test('炸弹打顺子', () => {
+            const last = createCards(['3', '4', '5', '6', '7']);
+            const curr = createSameCards('3', 4);
+            expect((0, logic_1.canBeat)(last, curr, gameMode)).toBe(true);
+        });
+        test('王炸打炸弹', () => {
+            const last = createSameCards('A', 4);
+            const curr = [createCard('RJ', ''), createCard('BJ', '')];
+            expect((0, logic_1.canBeat)(last, curr, gameMode)).toBe(true);
+        });
+        test('王炸打王炸不行（同级别同点数）', () => {
+            const last = [createCard('RJ', ''), createCard('BJ', '')];
+            const curr = [createCard('RJ', ''), createCard('BJ', '')];
+            expect((0, logic_1.canBeat)(last, curr, gameMode)).toBe(false);
+        });
+        test('不同牌型不能比较（除炸弹）', () => {
+            const last = createCards(['7']);
+            const curr = createSameCards('A', 2);
+            expect((0, logic_1.canBeat)(last, curr, gameMode)).toBe(false);
+        });
+        test('长度不同的顺子不能比较', () => {
+            const last = createCards(['3', '4', '5', '6', '7']);
+            const curr = createCards(['5', '6', '7', '8', '9', '10']);
+            expect((0, logic_1.canBeat)(last, curr, gameMode)).toBe(false);
+        });
+        test('大顺子打小顺子', () => {
+            const last = createCards(['3', '4', '5', '6', '7']);
+            const curr = createCards(['5', '6', '7', '8', '9']);
+            expect((0, logic_1.canBeat)(last, curr, gameMode)).toBe(true);
+        });
+    });
+});
+describe('四人斗地主 (Four Player Mode)', () => {
+    const gameMode = 'four_player';
+    describe('牌型识别 (analyzeHand)', () => {
+        test('单张', () => {
+            const cards = createCards(['7']);
+            const result = (0, logic_1.analyzeHand)(cards, gameMode);
+            expect(result.type).toBe('single');
+        });
+        test('对子', () => {
+            const cards = createSameCards('Q', 2);
+            const result = (0, logic_1.analyzeHand)(cards, gameMode);
+            expect(result.type).toBe('pair');
+        });
+        test('四带二 (带2张单牌)', () => {
+            const cards = [...createSameCards('9', 4), createCard('6'), createCard('8')];
+            const result = (0, logic_1.analyzeHand)(cards, gameMode);
+            expect(result.type).toBe('four_with_two');
+            expect(result.rankValue).toBe(9);
+        });
+        test('四带两对', () => {
+            const cards = [
+                ...createSameCards('9', 4),
+                ...createSameCards('5', 2),
+                ...createSameCards('7', 2)
+            ];
+            const result = (0, logic_1.analyzeHand)(cards, gameMode);
+            expect(result.type).toBe('four_with_pairs');
+            expect(result.rankValue).toBe(9);
+        });
+        test('顺子可以包含2 (A2345)', () => {
+            const cards = createCards(['A', '2', '3', '4', '5']);
+            const result = (0, logic_1.analyzeHand)(cards, gameMode);
+            expect(result.type).toBe('straight');
+        });
+        test('顺子 10JQKA', () => {
+            const cards = createCards(['10', 'J', 'Q', 'K', 'A']);
+            const result = (0, logic_1.analyzeHand)(cards, gameMode);
+            expect(result.type).toBe('straight');
+        });
+        test('炸弹 (4张相同)', () => {
+            const cards = createSameCards('6', 4);
+            const result = (0, logic_1.analyzeHand)(cards, gameMode);
+            expect(result.type).toBe('bomb');
+            expect(result.bombLevel).toBe(1);
+        });
+        test('王炸 (1大1小) - 四人模式等级为2', () => {
+            // 四人模式中，1大1小的王炸等级为2，介于普通炸弹和八炸之间
+            const cards = [
+                { suit: '', rank: 'RJ', value: 17, deckIndex: 0 },
+                { suit: '', rank: 'BJ', value: 16, deckIndex: 0 },
+            ];
+            const result = (0, logic_1.analyzeHand)(cards, gameMode);
+            expect(result.type).toBe('rocket');
+            expect(result.bombLevel).toBe(2);
+        });
+        test('天王炸 (4张王 = 2大王+2小王)', () => {
+            // 在双副牌中，4张王就是2大王+2小王，这就是天王炸
+            const cards = createQuadJoker();
+            const result = (0, logic_1.analyzeHand)(cards, gameMode);
+            expect(result.type).toBe('quad_joker');
+            expect(result.bombLevel).toBe(4); // 天王炸最强
+        });
+        test('八炸 (8张相同)', () => {
+            const cards = createSameCardsDouble('8', 8);
+            const result = (0, logic_1.analyzeHand)(cards, gameMode);
+            expect(result.type).toBe('octo_bomb');
+            expect(result.rankValue).toBe(8);
+            expect(result.bombLevel).toBe(3);
+        });
+    });
+    describe('牌型比较 (canBeat) - 炸弹等级', () => {
+        test('普通炸弹打非炸弹', () => {
+            const last = createCards(['7']);
+            const curr = createSameCards('3', 4);
+            expect((0, logic_1.canBeat)(last, curr, gameMode)).toBe(true);
+        });
+        test('大炸弹打小炸弹 (同为普通炸)', () => {
+            const last = createSameCards('5', 4);
+            const curr = createSameCards('9', 4);
+            expect((0, logic_1.canBeat)(last, curr, gameMode)).toBe(true);
+        });
+        test('八炸打普通炸弹', () => {
+            const last = createSameCards('A', 4);
+            const curr = createSameCardsDouble('3', 8);
+            expect((0, logic_1.canBeat)(last, curr, gameMode)).toBe(true);
+        });
+        test('大八炸打小八炸', () => {
+            const last = createSameCardsDouble('5', 8);
+            const curr = createSameCardsDouble('9', 8);
+            expect((0, logic_1.canBeat)(last, curr, gameMode)).toBe(true);
+        });
+        test('小八炸不能打大八炸', () => {
+            const last = createSameCardsDouble('9', 8);
+            const curr = createSameCardsDouble('5', 8);
+            expect((0, logic_1.canBeat)(last, curr, gameMode)).toBe(false);
+        });
+        test('天王炸打八炸', () => {
+            const last = createSameCardsDouble('2', 8); // 2的八炸（最大八炸）
+            const curr = createQuadJoker();
+            expect((0, logic_1.canBeat)(last, curr, gameMode)).toBe(true);
+        });
+        test('天王炸打普通炸弹', () => {
+            const last = createSameCards('A', 4);
+            const curr = createQuadJoker();
+            expect((0, logic_1.canBeat)(last, curr, gameMode)).toBe(true);
+        });
+        test('普通炸弹不能打八炸', () => {
+            const last = createSameCardsDouble('3', 8);
+            const curr = createSameCards('2', 4);
+            expect((0, logic_1.canBeat)(last, curr, gameMode)).toBe(false);
+        });
+        test('八炸不能打天王炸', () => {
+            const last = createQuadJoker();
+            const curr = createSameCardsDouble('2', 8);
+            expect((0, logic_1.canBeat)(last, curr, gameMode)).toBe(false);
+        });
+        test('四带二的比较', () => {
+            const last = [...createSameCards('5', 4), createCard('3'), createCard('7')];
+            const curr = [...createSameCards('9', 4), createCard('4'), createCard('8')];
+            expect((0, logic_1.canBeat)(last, curr, gameMode)).toBe(true);
+        });
+        test('小四带二不能打大四带二', () => {
+            const last = [...createSameCards('9', 4), createCard('3'), createCard('7')];
+            const curr = [...createSameCards('5', 4), createCard('4'), createCard('8')];
+            expect((0, logic_1.canBeat)(last, curr, gameMode)).toBe(false);
+        });
+        test('炸弹可以打四带二', () => {
+            const last = [...createSameCards('A', 4), createCard('3'), createCard('7')];
+            const curr = createSameCards('3', 4);
+            expect((0, logic_1.canBeat)(last, curr, gameMode)).toBe(true);
+        });
+        test('王炸打普通炸弹', () => {
+            const last = createSameCards('2', 4); // 2的炸弹（最大普通炸弹）
+            const curr = [
+                { suit: '', rank: 'RJ', value: 17, deckIndex: 0 },
+                { suit: '', rank: 'BJ', value: 16, deckIndex: 0 },
+            ];
+            expect((0, logic_1.canBeat)(last, curr, gameMode)).toBe(true);
+        });
+        test('普通炸弹不能打王炸', () => {
+            const last = [
+                { suit: '', rank: 'RJ', value: 17, deckIndex: 0 },
+                { suit: '', rank: 'BJ', value: 16, deckIndex: 0 },
+            ];
+            const curr = createSameCards('2', 4);
+            expect((0, logic_1.canBeat)(last, curr, gameMode)).toBe(false);
+        });
+        test('八炸打王炸', () => {
+            const last = [
+                { suit: '', rank: 'RJ', value: 17, deckIndex: 0 },
+                { suit: '', rank: 'BJ', value: 16, deckIndex: 0 },
+            ];
+            const curr = createSameCardsDouble('3', 8); // 3的八炸（最小八炸）
+            expect((0, logic_1.canBeat)(last, curr, gameMode)).toBe(true);
+        });
+        test('王炸不能打八炸', () => {
+            const last = createSameCardsDouble('3', 8);
+            const curr = [
+                { suit: '', rank: 'RJ', value: 17, deckIndex: 0 },
+                { suit: '', rank: 'BJ', value: 16, deckIndex: 0 },
+            ];
+            expect((0, logic_1.canBeat)(last, curr, gameMode)).toBe(false);
+        });
+        test('天王炸打王炸', () => {
+            const last = [
+                { suit: '', rank: 'RJ', value: 17, deckIndex: 0 },
+                { suit: '', rank: 'BJ', value: 16, deckIndex: 0 },
+            ];
+            const curr = createQuadJoker();
+            expect((0, logic_1.canBeat)(last, curr, gameMode)).toBe(true);
+        });
+    });
+    describe('顺子规则 (四人模式特殊)', () => {
+        test('普通顺子 34567', () => {
+            const cards = createCards(['3', '4', '5', '6', '7']);
+            const result = (0, logic_1.analyzeHand)(cards, gameMode);
+            expect(result.type).toBe('straight');
+        });
+        test('顺子 JQKA2 (四人可含2)', () => {
+            const cards = createCards(['J', 'Q', 'K', 'A', '2']);
+            const result = (0, logic_1.analyzeHand)(cards, gameMode);
+            expect(result.type).toBe('straight');
+        });
+        test('顺子不能包含王', () => {
+            const cards = [...createCards(['J', 'Q', 'K', 'A']), createCard('RJ', '')];
+            const result = (0, logic_1.analyzeHand)(cards, gameMode);
+            expect(result.type).toBe('invalid');
+        });
+    });
+});
+describe('边界情况和无效牌型', () => {
+    test('空手牌', () => {
+        const result = (0, logic_1.analyzeHand)([], 'three_player');
+        expect(result.type).toBe('invalid');
+    });
+    test('无效的牌型组合', () => {
+        const cards = createCards(['3', '5', '7']);
+        const result = (0, logic_1.analyzeHand)(cards, 'three_player');
+        expect(result.type).toBe('invalid');
+    });
+    test('两张不同的牌不是对子', () => {
+        const cards = createCards(['3', '5']);
+        const result = (0, logic_1.analyzeHand)(cards, 'three_player');
+        expect(result.type).toBe('invalid');
+    });
+    test('4张不连续的牌不是顺子', () => {
+        const cards = createCards(['3', '5', '7', '9']);
+        const result = (0, logic_1.analyzeHand)(cards, 'three_player');
+        expect(result.type).toBe('invalid');
+    });
+});
+describe('炸弹等级验证', () => {
+    describe('三人模式炸弹等级', () => {
+        test('王炸等级为5（最高）', () => {
+            const cards = [createCard('RJ', ''), createCard('BJ', '')];
+            const result = (0, logic_1.analyzeHand)(cards, 'three_player');
+            expect(result.bombLevel).toBe(5);
+        });
+        test('普通炸弹等级为1', () => {
+            const cards = createSameCards('K', 4);
+            const result = (0, logic_1.analyzeHand)(cards, 'three_player');
+            expect(result.bombLevel).toBe(1);
+        });
+    });
+    describe('四人模式炸弹等级顺序', () => {
+        test('普通炸弹等级 = 1', () => {
+            const cards = createSameCards('K', 4);
+            const result = (0, logic_1.analyzeHand)(cards, 'four_player');
+            expect(result.bombLevel).toBe(1);
+        });
+        test('王炸等级 = 2', () => {
+            const cards = [
+                { suit: '', rank: 'RJ', value: 17, deckIndex: 0 },
+                { suit: '', rank: 'BJ', value: 16, deckIndex: 0 },
+            ];
+            const result = (0, logic_1.analyzeHand)(cards, 'four_player');
+            expect(result.bombLevel).toBe(2);
+        });
+        test('八炸等级 = 3', () => {
+            const cards = createSameCardsDouble('K', 8);
+            const result = (0, logic_1.analyzeHand)(cards, 'four_player');
+            expect(result.bombLevel).toBe(3);
+        });
+        test('天王炸等级 = 4（最高）', () => {
+            const cards = createQuadJoker();
+            const result = (0, logic_1.analyzeHand)(cards, 'four_player');
+            expect(result.bombLevel).toBe(4);
+        });
+        test('炸弹等级：天王炸 > 八炸 > 王炸 > 普通炸弹', () => {
+            const normalBomb = (0, logic_1.analyzeHand)(createSameCards('2', 4), 'four_player');
+            const rocket = (0, logic_1.analyzeHand)([
+                { suit: '', rank: 'RJ', value: 17, deckIndex: 0 },
+                { suit: '', rank: 'BJ', value: 16, deckIndex: 0 },
+            ], 'four_player');
+            const octoBomb = (0, logic_1.analyzeHand)(createSameCardsDouble('3', 8), 'four_player');
+            const quadJoker = (0, logic_1.analyzeHand)(createQuadJoker(), 'four_player');
+            expect(normalBomb.bombLevel).toBeLessThan(rocket.bombLevel);
+            expect(rocket.bombLevel).toBeLessThan(octoBomb.bombLevel);
+            expect(octoBomb.bombLevel).toBeLessThan(quadJoker.bombLevel);
+        });
+    });
+});