python写打麻将程序python 麻将

Python写打麻将程序

1. 程序需求

打麻将是很受欢迎的一种棋牌游戏。你需要用Python编写一个打麻将的程序，能够实现如下功能：

1. 自动洗牌和发牌功能，牌库包含条、万、筒三种花色，每个花色1－9总共27张牌
2. 实现胡牌算法，包括七对子，碰碰胡等常见胡法
3. 实现杠牌算法，包括明杠、暗杠、补杠等常见杠法
4. 实现听牌算法，可以打出哪些牌使得自己能够胡牌
5. 实现出牌算法，可以自动打出一张牌，并计算出下一步的最优策略

2. 程序设计

为了实现上述功能，我们需要先定义麻将游戏中常见的对象：麻将牌、玩家、游戏等。

2.1 麻将牌

在麻将游戏中，每种花色有1-9九张牌，加上风牌、箭牌总共136张牌。我们可以用一个长度为136的一维数组来存储所有的牌，并对每张牌进行编码，以条1－9为例，可以分别用11－19表示：

    class Mahjong:
        def __init__(self):
            self.tile_count=4
            self.tiles=[i for i in range(1, 10)] * self.tile_count * 3

        # 洗牌
        def shuffle(self):
            from random import shuffle
            shuffle(self.tiles)

        # 发牌
        def deal(self):
            if len(self.tiles)==0:
                return None

            return self.tiles.pop()

2.2 玩家

每个玩家需要保持手牌、碰、杠、胡等状态，并根据不同的胡法进行不同的分数计算。我们可以定义一个Player类来表示玩家：

    class Player:
        def __init__(self, player_id):
            self.id=player_id
            self.tiles=[]    # 手牌
            self.pongs=[]    # 碰牌
            self.kongs=[]    # 杠牌
            self.chows=[]    # 吃牌
            self.wins=[]     # 胡牌
            self.round_score=0  # 单局得分
            self.total_score=0  # 总得分

        # 摸牌
        def draw(self, tile):
            self.tiles.append(tile)

        # 打牌
        def discard(self, tile):
            self.tiles.remove(tile)

        # 碰牌
        def pong(self, tile):
            if self.tiles.count(tile) >=2:
                self.tiles.remove(tile)
                self.tiles.remove(tile)
                self.pongs.append(tile)

        # 杠牌
        def kong(self, tile, kong_type='concealed'):
            if self.tiles.count(tile)==3 or kong_type=='concealed':
                self.tiles.remove(tile)
                self.tiles.remove(tile)
                self.tiles.remove(tile)
                self.kongs.append(kong_type + ' kong ' + str(tile))

2.3 游戏管理

游戏管理需要实现理牌、胡牌、杠牌、听牌、让牌等算法，并实现出牌、检查胡等功能。注意到游戏与玩家之间存在很多依赖关系，我们可以将游戏管理设计为一个Mediator类：

    class Mediator:
        def __init__(self, num_players):
            self.mahjong=Mahjong()
            self.num_players=num_players
            self.players=[Player(i) for i in range(num_players)]

        # 发牌并排序
        def deal(self):
            self.mahjong.shuffle()

            for i in range(13):
                for p in self.players:
                    p.draw(self.mahjong.deal())

        # 检查是否胡牌
        def check_win(self, player, tile):
            pass

        # 计算胡牌分数
        def calculate_score(self, winner, loser, win_type):
            pass

        # 检查是否杠牌
        def check_kong(self, player, tile):
            pass

        # 计算杠牌分数
        def calculate_kong_score(self, konger, payer, kong_type):
            pass

        # 听牌检查
        def check_ready(self, player):
            pass

        # 让牌检查
        def check_charleston(self, player):
            pass

        # 出牌
        def discard(self, player, tile):
            pass

        # 下一步最优策略
        def get_optimal_action(self, player):
            pass

3. 程序实现

根据上述设计，我们可以先实现Mahjong类，包括洗牌和发牌功能：

    mahjong=Mahjong()
    mahjong.shuffle()
    print(mahjong.tiles[:13])

接着，实现Player类，包括摸牌、打牌、碰牌、杠牌等功能：

    player=Player(0)
    player.draw(1)
    player.draw(2)
    print(player.tiles)
    player.discard(1)
    print(player.tiles)
    player.pong(2)
    print(player.tiles)
    player.kong(1, 'concealed')
    print(player.tiles, player.kongs)

最后，实现Mediator类，包括发牌、出牌、胡牌、杠牌、听牌、让牌等核心算法：

    mediator=Mediator(4)
    mediator.deal()
    print(mediator.players[0].tiles)

    player=mediator.players[0]
    tile=player.tiles[0]
    mediator.discard(player, tile)

    if mediator.check_win(player, tile):
        print(player.id, 'won')
        print(mediator.calculate_score(player, None, 'self_drawn'))

    if mediator.check_kong(player, tile):
        mediator.calculate_kong_score(player, None, 'concealed')

    if mediator.check_ready(player):
        print(player.id, 'is ready')

    if mediator.check_charleston(player):
        print(player.id, 'is charlestoned')

    print(mediator.get_optimal_action(player))

4. 程序总结

在麻将游戏的Python实现中，我们需要定义麻将牌、玩家、游戏等对象，并实现洗牌、发牌、打牌、胡牌、杠牌、听牌、让牌等核心算法。通过定义Mediator类，我们将游戏管理和玩家之间的依赖关系处理得更为清晰，方便后续的调试和维护。