13×13：一个扑克牌游戏的简单实现

一、游戏规则

13×13是一款扑克牌游戏，使用一副扑克牌（大小王除外）。游戏每局都会随机出牌并分配给两名玩家，然后每个玩家持有一部分牌进行操作。

每次操作可以出任意数量的顺子、对子，或者三条，并且必须按照牌点从小到大排列。比如，可以出：2 3 4、6 6、7 7 7，但是不能出：3 2 4、6 6 5 或者 6 7 6。

如果当前玩家无法出牌，则另一位玩家可以任意出牌，直到有一方手牌全部出完或者无法出牌为止。

游戏结束后，双方牌数少的一方获胜。

二、游戏实现

1、牌型

class Card:
    def __init__(self, number):
        self.number = number
        self.weight = number % 13

    def __str__(self):
        suits = ['S', 'H', 'C', 'D']
        ranks = ['A', '2', '3', '4', '5', '6', '7', '8', '9', 'T', 'J', 'Q', 'K']
        return ranks[self.weight] + suits[self.number // 13]

使用Card类表示扑克牌，其中number表示牌的编号，weight表示牌的点数。

2、出牌规则

def is_valid(cards):
    if len(cards) == 0:
        return False
    if len(cards) == 1:
        return True
    if len(cards) == 2 and cards[0].weight == cards[1].weight:
        return True
    if len(cards) == 3 and cards[0].weight == cards[1].weight and cards[1].weight == cards[2].weight:
        return True
    if len(cards) >= 5 and judge_shunzi(cards):
        return True
    return False

def judge_shunzi(cards):
    if cards[-1].weight - cards[0].weight != len(cards) - 1:
        return False
    for i in range(len(cards) - 1):
        if cards[i + 1].weight != cards[i].weight + 1:
            return False
    return True

is_valid函数接受一组牌，判断这组牌是否可以出。如果可以出，则返回True，否则返回False。出牌必须按照顺子、对子、三条的顺序进行。

judge_shunzi函数则判断是否为顺子。

3、游戏逻辑

class Game:
    def __init__(self, deck):
        self.players = [Player(), Player()]
        random.shuffle(deck)
        for i in range(26):
            self.players[i % 2].add_card(deck.pop())
        self.last_player = None
        self.last_cards = []

    def run(self):
        player = self.last_player or random.choice(self.players)
        while self.players[0].get_card_count() and self.players[1].get_card_count():
            if player == self.last_player:
                self.last_cards = []
            self.last_player = player
            valid_cards = []

            while not is_valid(valid_cards):
                print(f"Player {player.get_id()} cards:", player)
                if self.last_cards:
                    print("Last cards:", self.last_cards)
                cards_str = input("Enter cards to play: ")
                valid_cards = [Card(int(card_str, 16)) for card_str in cards_str.split()]
            player.remove_cards(valid_cards)

            print(f"Player {player.get_id()} plays:", valid_cards)
            self.last_cards = valid_cards

            if player.get_card_count() == 0:
                break

            player = self.players[1] if player == self.players[0] else self.players[0]

        winner = [p for p in self.players if p.get_card_count() > 0][0]
        print(f"Player {winner.get_id()} wins!")

Game类用于表示一个游戏，初始化时分配两个玩家的牌。每次操作时，询问当前玩家出牌，判断是否符合规则，然后将出的牌交给对方。如果当前玩家无法出牌，则交给对方操作。

最后，判断哪个玩家手牌数量最少，即为胜利方。

三、测试结果

if __name__ == '__main__':
    deck = [Card(i) for i in range(52)]
    game = Game(deck)
    game.run()

测试结果截图：

四、总结

通过实现13×13这个扑克牌游戏，我们可以学习到如何使用类和函数来表示基础的游戏规则和逻辑。如果想要玩起来更顺畅，可以考虑增加AI模块，让电脑自动出牌。