#調(diào)用random庫中的sample函數(shù)，用于從卡牌堆中隨機(jī)抽取卡牌
from random import sample

#利用列表存儲卡牌的花色與數(shù)字
color = ['黑桃','紅桃','梅花','方塊']
number = ['2','3','4','5','6','7','8','9','10','J','Q','K','A']

#PokerGenerator函數(shù)用于生成一組卡牌
def PokerGenerator():
    #將卡牌存儲于列表中
    Poker = []
    # 用字典表示卡牌，在Poker列表中添加52張空白的卡牌
    for i in range(0,52):
        t = {'數(shù)字':0,'花色':''}    
        Poker.append(t)
    #對每張卡牌進(jìn)行賦值，每種花色各有13種花色，共四種花色，52張卡牌。  
    for i in range(0,52):
        Poker[i].update({'數(shù)字':number[i%13],'花色':color[i//13]})  
    #將存儲有52張卡牌的列表Poker返回
    return Poker

#根據(jù)玩家人數(shù)分發(fā)卡牌
def Pokerinitial(playersum):
    Playerpoker = []
    Poker = PokerGenerator()#初始化一副新的卡牌
    num = 52
    
    for i in range(0,playersum):
        Pripoker = sample(Poker,2)#從卡牌中隨機(jī)抽取兩張卡牌作為一名玩家的手牌
        Playerpoker.append(Pripoker)#所抽取的卡牌以元組形式假加入Playerpoker列表中，以Playerpoker的下標(biāo)序號代表玩家的序號
        #將每位玩家所抽取的卡牌從卡牌堆中刪除，即實(shí)現(xiàn)不放回抽樣
        for n in [0,1]:
            for m in range(0,num):
                if Poker[m] == Pripoker[n]:
                    del Poker[m]
                    num -=1
                    break               
                
    Publicpoker = sample(Poker,3)#從牌堆中再抽取三張牌作為公共牌
    #將所抽取的公共牌從牌堆中刪除
    for n in [0,1,2]:
            for m in range(0,num):
                if Poker[m] == Publicpoker[n]:
                    del Poker[m]
                    num -=1
                    break
    #將每位玩家的手牌與公共牌輸出顯示
    for i in range(0,playersum):
        print("玩家 %d"%(i+1)+"：牌1："+str(Playerpoker[i][0])+"  牌2："+str(Playerpoker[i][1]))
        print("")
        
    print("")
    print("")    
    print("公共牌: "+str(Publicpoker)+"   ")
    
    return [Playerpoker,Poker,Publicpoker]#將玩家手牌，剩余的牌堆，公共牌組返回

#判斷玩家的牌與公共牌是否構(gòu)成順子
def judgestraight(finalpoker):
? ? result = [0, 0]#用于儲存結(jié)果，result[0]中儲存此位玩家最好的五張牌的類別，從高牌到皇家同花順編號為0到9。result[1]儲存當(dāng)前開組中數(shù)字最大的牌
? ? pokernum = []#存儲卡牌的數(shù)字
? ? for i in range(0, len(finalpoker)):
? ? ? ? pokernum.append(number.index(finalpoker[i]['數(shù)字']))
? ? pokernum.sort()#將卡牌號碼從小到大進(jìn)行排序
? ? #判斷玩家卡牌與公共卡牌的組合是否能構(gòu)成順子
? ? maxp = minp = 0
? ? for i in range(1, len(finalpoker)):
? ? ? ? if (pokernum[i - 1] + 1) == pokernum[i]:
? ? ? ? ? ? maxp = i
? ? ? ? else:
? ? ? ? ? ? minp = i
? ? ? ? if (maxp - minp) == 4:
? ? ? ? ? ? result[0] = 4
? ? ? ? ? ? result[1] = max(pokernum[minp:maxp + 1])

? ? return result

#判斷卡組中是否存在同花
def judgeflush(finalpoker):
    result = [0, 0]
    pokernum = []
    flush = []#用于存儲相同花色的卡牌

    while len(finalpoker) >= 5:
        #抽出卡組中同花色的卡牌
        flush.append(finalpoker[0])
        for i in range(1, len(finalpoker)):
            if finalpoker[i]['花色'] == finalpoker[0]['花色']:
                flush.append(finalpoker[i])
            #若同花色卡牌不少于五張，那么卡組存在同花
            if len(flush) >= 5:
                result[0] = 5
                for ele in flush:
                    pokernum.append(number.index(ele['數(shù)字']))
                result[1] = max(pokernum)
        for ele in flush:
            finalpoker.remove(ele)
        flush.clear()
    return result

#判斷卡組中是否存在四條、三條、兩對或一對
def judgesame(finalpoker):
    result = [0, 0]
    four = -1   #記錄卡組中是否存在四條
    three = -1  #記錄卡組中是否存在三條
    two = [-1, -1] #記錄卡組中是否存在兩對與一對

    count = 1
    pokernum = []
    bottom = 0
    #將卡組的所有卡牌號存儲進(jìn)pokernum中，并進(jìn)行排序
    for i in range(0, len(finalpoker)):
        pokernum.append(number.index(finalpoker[i]['數(shù)字']))
    pokernum.sort()
    #判斷卡組中是否存在四條、三條、兩對或一對等，并將所對應(yīng)最大的卡牌數(shù)字進(jìn)行存儲
    for i in range(1, len(finalpoker)):
        if pokernum[i] == pokernum[bottom]:
            count += 1
        else:
            if count == 2:
                if pokernum[bottom] > min(two):
                    numid = two.index(min(two))
                    two[numid] = pokernum[bottom]
            if count == 3:
                if pokernum[bottom] > three:
                    three = pokernum[bottom]
            if count == 4:
                four = pokernum[bottom]

            bottom = i
            count = 1
    #判斷卡組中所存在的最大的組合牌類型
    if four >= 0:
        result[0] = 7
        result[1] = four
    elif three >= 0 and max(two) >= 0:
        result[0] = 6
        t = three * 10 + max(two)
        result[1] = t
    elif three >= 0:
        result[0] = 3
        result[1] = three
    elif min(two) >= 0:
        result[0] = 2
        result[1] = max(two)
    elif max(two) >= 0:
        result[0] = 1
        result[1] = max(two)

    return result

#計算出玩家所持卡組中最大的組合牌類型
def computeresult(Playerpoker, Publicpoker):
    finalresult = [0, 0]
    finalpoker = []
    finalpoker = Playerpoker + Publicpoker
    a = finalpoker.copy()
    b = finalpoker.copy()
    c = finalpoker.copy()
    #分別存儲同花、順子、四條、三條（即數(shù)字相同的個數(shù)與情況）等的判斷結(jié)果
    result_1 = judgeflush(a)
    result_2 = judgestraight(b)
    result_3 = judgesame(c)
    #判斷是否是同花順
    if result_1[0] != 0 and result_2[0] != 0:
        finalresult[0] = 8
        finalresult[1] = result_2[1]
    #若不是同花順，則判斷玩家手牌與公共牌所在組成的最大卡組種類
    else:
        t_0 = result_1[0]
        t_1 = result_1[1]
        if result_2[0] > t_0:
            t_0 = result_2[0]
            t_1 = result_2[1]
        if result_3[0] > t_0:
            t_0 = result_3[0]
            t_1 = result_3[1]
    #確定最終結(jié)果，即玩家所擁有的最大卡牌種類
    finalresult[0] = t_0
    finalresult[1] = t_1

    return finalresult

#游戲函數(shù)主體
def gamestart(playersum):
    finalresult = []#用于存儲每個玩家的最大手牌
    [playerpoker,Poker,Publicpoker] = Pokerinitial(playersum)#根據(jù)玩家數(shù)初始化一副卡牌，并給每位玩家分發(fā)兩張手牌，并分發(fā)初始的三張公共牌
    playerlist = list(range(1,playersum+1))#記錄每輪回合過后還剩下的玩家
    playerlist_t = []
    Playerpoker = []
    
    while len(Publicpoker) < 5 and len(playerlist) > 1:#當(dāng)公共牌數(shù)為5或僅剩一個玩家時，游戲結(jié)束進(jìn)行結(jié)算
        tag = 0 #標(biāo)識符，標(biāo)注所輸入的繼續(xù)游戲的玩家是否有誤，若有誤則重新輸入
        playerkeep = input("請輸入繼續(xù)游戲的玩家:")
        playerlist_t = eval(playerkeep)
            
        if isinstance(playerlist_t,int):
            if playerlist_t in playerlist:
                winplayer = playerlist_t
                print("game over. The winner is "+str(winplayer))#若選擇繼續(xù)游戲的玩家僅有一人，則游戲結(jié)束進(jìn)行結(jié)算
                return
                playerlist.clear()
            else:
                print("輸入有誤，請重新輸入")#若輸入玩家在本回合中不存在則報錯并重新輸入

        elif isinstance(playerlist_t, tuple):
            playerlist_t = list(playerlist_t)
            for i in playerlist_t:
                if i not in playerlist:
                    tag = 1
            if tag == 1:
                print("輸入有誤，請重新輸入")#若輸入的玩家中有玩家在本回合中不存在則報錯并重新輸入
            else:
                playerlist = playerlist_t
                pokerkeep = sample(Poker,1)#從剩余卡牌中再抽取一張作為公共牌
                Publicpoker += pokerkeep
                pokerkeep = pokerkeep[0]
                print("公共牌: "+str(Publicpoker)+"   ")#將本回合的公共牌進(jìn)行顯示

                for n in range(0,len(Poker)):#將所抽取的公共牌從剩余卡牌中刪除
                    if Poker[n] == pokerkeep:
                        del Poker[n]                        
                        break
    for i in playerlist:
        Playerpoker.append(playerpoker[i-1])
    for ppoker in Playerpoker:
        finalresult.append(computeresult(ppoker, Publicpoker))#將每位玩家的手牌與公共牌代入計算最終結(jié)果
 
    finalscore = []
    finalscore_t = []
    finalplayer = []
    winner = []
    for t in range(0, len(finalresult)):
        finalscore.append(finalresult[t][0])
    
    maxscore = max(finalscore)#判斷此時所有玩家中最大的組合牌類型
    #若有多位玩家同時擁有最大類型的組合牌，則對他們最大的牌數(shù)字進(jìn)行比較
    for t in range(0, len(finalresult)):
        if finalscore[t] == maxscore:
            finalplayer.append(t)    
    for t in finalplayer:
        finalscore_t.append(finalresult[t][1])
    maxscore_t = max(finalscore_t)    
    for t in finalplayer:
        if finalresult[t][1] == maxscore_t:
            winner.append(playerlist[t])
    ##輸出最終玩家
    print("game over.The winner is:")
    for t in winner:
        print("玩家:"+str(t))
    return 

from Texas_Hold_em_Poker import gamestart

n = input('請輸入要進(jìn)行的游戲的玩家人數(shù):')
gamestart(int(n))