Python小游戏练习 - 炸金花

# 一副牌去重大小王，每人发3张牌，牌面高的胜出, 豹子>同花顺>同花>顺子>对子>散牌； 无其他特殊规则
import random

# 生成牌堆
poke_colour = ['♠', '♥', '♣', '◆']
poke_number = [' 2', ' 3', ' 4', ' 5', ' 6', ' 7', ' 8', ' 9', '10', ' J', ' Q', ' K', ' A']
poke_list = []
for idx, colour in enumerate(poke_colour):
    count = 1
    for number in poke_number:
        # print(f'{colour}{number}')
        count += 1
        poke_list.append([f'{colour}{number}', count, 4 - idx])
# print(poke_list)


# 给玩家发牌
player_list = ['周润发', '刘德华', '周星驰', '黎明']
player_poke_dict = {}
for player in player_list:
    choice_list = random.sample(poke_list, 3)
    player_poke_dict[player] = choice_list
    for poke in choice_list:
        poke_list.remove(poke)
    # print(f'玩家[{player}]的牌型为：{choice_list}')


# 冒泡排序
def bubble_sort(player_poke_list):
    player_score_list = [unit_poke[1] for unit_poke in player_poke_list]
    n = len(player_score_list)
    for a in range(n):
        for b in range(0, n - a - 1):
            if player_score_list[b] > player_score_list[b + 1]:
                player_score_list[b + 1], player_score_list[b] = player_score_list[b], player_score_list[b + 1]
    return player_score_list


# 牌型排序
def player_poke_colour(player_poke_list):
    player_score_list = [unit_poke[1] * 10 + unit_poke[2] for unit_poke in player_poke_list]
    player_colour_list = [unit_poke[0:] for unit_poke in player_poke_list]
    n = len(player_score_list)
    for a in range(n):
        for b in range(0, n - a - 1):
            if player_score_list[b] > player_score_list[b + 1]:
                player_score_list[b + 1], player_score_list[b] = player_score_list[b], player_score_list[b + 1]
                player_colour_list[b + 1], player_colour_list[b] = player_colour_list[b], player_colour_list[b + 1]
    return player_colour_list


# 单牌权重计算
def player_poke_simple(player_poke_list, cal_score, result_type):
    sort_poke_list = bubble_sort(player_poke_list)
    if len(set(sort_poke_list)) == 3:
        cal_score += sort_poke_list[0] * 0.1 + sort_poke_list[1] + sort_poke_list[2] * 10
    else:
        cal_score += sort_poke_list[2] * 10
    return cal_score, result_type


# 对子权重计算
def player_poke_pair(player_poke_list, cal_score, result_type):
    pair_poke = bubble_sort(player_poke_list)
    if len(set(pair_poke)) == 2:
        cal_score += pair_poke[0] * 10 + pair_poke[1] * 100
        result_type = '对子'
    return cal_score, result_type


# 顺子权重计算
def player_poke_straight(player_poke_list, cal_score, result_type):
    straight_poke = bubble_sort(player_poke_list)
    minus_num1 = straight_poke[1] - straight_poke[0]
    minus_num2 = straight_poke[2] - straight_poke[1]
    if minus_num1 == 1 and minus_num2 == 1:
        cal_score += straight_poke[0] * 100 + straight_poke[1] * 1000 + straight_poke[2] * 10000
        result_type = '顺子'
    return cal_score, result_type


# 同花权重计算
def player_poke_same(player_poke_list, cal_score, result_type):
    same_colour = [unit_poke[0][0] for unit_poke in player_poke_list]
    if len(set(same_colour)) == 1:
        colour_idx = poke_colour.index(same_colour[0])
        cal_score += (4 - colour_idx) * 100000
        result_type = '同花'
    return cal_score, result_type


# 同花顺权重计算
def player_poke_same_straight(player_poke_list, cal_score, result_type):
    straight_poke = bubble_sort(player_poke_list)
    minus_num1 = straight_poke[1] - straight_poke[0]
    minus_num2 = straight_poke[2] - straight_poke[1]
    same_colour = [unit_poke[0][0] for unit_poke in player_poke_list]
    length_set = len(set(same_colour))
    if minus_num1 == 1 and minus_num2 == 1 and length_set == 1:
        cal_score += straight_poke[0] * 100 + straight_poke[1] * 1000 + straight_poke[2] * 10000
        colour_idx = poke_colour.index(same_colour[0])
        cal_score += (4 - colour_idx) * 100000
        result_type = '同花顺'
    return cal_score, result_type


# 豹子权重计算
def player_poke_leopard(player_poke_list, cal_score, result_type):
    leopard_poke = bubble_sort(player_poke_list)
    if len(set(leopard_poke)) == 1:
        cal_score += leopard_poke[0] * 1000000
        result_type = '豹子'
    return cal_score, result_type


# 函数列表
function_list = [
    player_poke_simple,
    player_poke_pair,
    player_poke_straight,
    player_poke_same,
    player_poke_same_straight,
    player_poke_leopard
]

# 输出每位玩家的牌型和最后得分
score_list = []
for player_name, poke_list in player_poke_dict.items():
    poke_show_list = player_poke_colour(poke_list)
    print_show_list = [poke[0] for poke in poke_show_list]
    score = 0
    poke_type = '单牌'
    for func in function_list:
        func_result = func(poke_list, score, poke_type)
        score += func_result[0]
        poke_type = func_result[1]
    score_list.append([player_name, score, poke_show_list])
    print(f'玩家 [{player_name}]\t牌面为 {print_show_list},\t牌型: {poke_type}')

# 如果存在相同分数的牌型，则取出最大分数的最大牌型
winner_score = bubble_sort(score_list)[-1]
max_poke_list = []
for member in score_list:
    if member[1] == winner_score:
        max_poke_list.append(member[-1][-1])
max_poke_list = player_poke_colour(max_poke_list)[-1]

# 遍历取出最后赢家
for i in score_list:
    if i[-1][-1] == max_poke_list:
        print(f'恭喜玩家 [{i[0]}] 胜出!')