温馨提示×

温馨提示×

您好,登录后才能下订单哦!

密码登录×
登录注册×
其他方式登录
点击 登录注册 即表示同意《亿速云用户服务条款》

怎么利用Python编写简易版德州扑克小游戏

发布时间:2022-03-25 09:14:54 来源:亿速云 阅读:162 作者:小新 栏目:开发技术

小编给大家分享一下怎么利用Python编写简易版德州扑克小游戏,希望大家阅读完这篇文章之后都有所收获,下面让我们一起去探讨吧!

    德州扑克简要介绍

    什么是德州扑克

    德州扑克不知道大家是否玩过,它是起源于美国的得克萨斯州的一种博弈类卡牌游戏,英文名叫做Texas Hold’em Poker。玩法上又分为常规桌(Cash, 现金局),单桌赛(SNG)和多桌锦标赛(MTT)。虽然扑克种类繁多,但基本的扑克规则通常保持一致。它是一种考验心态与谋略的游戏。

    游戏规则简要介绍

    一、使用道具

    一副标准扑克牌去掉大小王后的52张牌进行游戏。

    二、游戏人数

    一般2-10个玩家,个别情况有12个玩家的。

    三、游戏目的

    赢取其他玩家筹码

    四、下注宗旨

    玩家之间同时继续看牌或比牌需要下同样注额筹码,筹码不足的玩家all-in全下后可以看到底并参与比牌。

    五、发牌下注

    发牌一般分为5个步骤,分别为,

    Perflop——先下大小盲注,然后给每个玩家发2张底牌,大盲注后面第一个玩家选择跟注、加注或者盖牌放弃,按照顺时针方向,其他玩家依次表态,大盲注玩家最后表态,如果玩家有加注情况,前面已经跟注的玩家需要再次表态甚至多次表态。

    Flop——同时发三张公牌,由小盲注开始(如果小盲注已盖牌,由后面最近的玩家开始,以此类推),按照顺时针方向依次表态,玩家可以选择下注、加注、或者盖牌放弃。

    Turn——发第4张牌,由小盲注开始,按照顺时针方向依次表态。

    River——发第五张牌,由小盲注开始,按照顺时针方向依次表态,玩家可以选择下注、加注、或者盖牌放弃。

    比牌——经过前面4轮发牌和下注,剩余的玩家开始亮牌比大小,成牌最大的玩家赢取池底。

    六、比牌方法

    用自己的2张底牌和5张公共牌结合在一起,选出5张牌,不论手中的牌使用几张(甚至可以不用手中的底牌),凑成最大的成牌,跟其他玩家比大小。

    比牌先比牌型,大的牌型大于小的牌型,牌型一般分为10种,从大到小为:

    怎么利用Python编写简易版德州扑克小游戏

    德州扑克游戏的python实现过程

    游戏初始化

    #调用random库中的sample函数,用于从卡牌堆中随机抽取卡牌
    from random import sample
    
    #利用列表存储卡牌的花色与数字
    color = ['黑桃','红桃','梅花','方块']
    number = ['2','3','4','5','6','7','8','9','10','J','Q','K','A']

    导入random库中的sample函数,后续用于从卡牌堆中随机抽取卡牌。同时利用列表分别将卡牌的颜色与数字存储在color与number中。

    #PokerGenerator函数用于生成一组卡牌
    def PokerGenerator():
        #将卡牌存储于列表中
        Poker = []
        # 用字典表示卡牌,在Poker列表中添加52张空白的卡牌
        for i in range(0,52):
            t = {'数字':0,'花色':''}    
            Poker.append(t)
        #对每张卡牌进行赋值,每种花色各有13种花色,共四种花色,52张卡牌。  
        for i in range(0,52):
            Poker[i].update({'数字':number[i%13],'花色':color[i//13]})  
        #将存储有52张卡牌的列表Poker返回
        return Poker

    函数PokerGenerator用于生成一副新的扑克牌,德州扑克所采用的扑克牌标准牌组,包含四种花色(‘黑桃’,‘红桃’,‘梅花’,‘方块’),每种花色有’2’到’A’等13张卡牌,共52张扑克,不包含大小王。

    #根据玩家人数分发卡牌
    def Pokerinitial(playersum):
        Playerpoker = []
        Poker = PokerGenerator()#初始化一副新的卡牌
        num = 52
        
        for i in range(0,playersum):
            Pripoker = sample(Poker,2)#从卡牌中随机抽取两张卡牌作为一名玩家的手牌
            Playerpoker.append(Pripoker)#所抽取的卡牌以元组形式假加入Playerpoker列表中,以Playerpoker的下标序号代表玩家的序号
            #将每位玩家所抽取的卡牌从卡牌堆中删除,即实现不放回抽样
            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]#将玩家手牌,剩余的牌堆,公共牌组返回

    给每位玩家分发两张手牌,分发游戏开始时的三张公共牌,并将每位玩家的手牌情况与公共情况输出显示,利用字典表示扑克牌。

    评选赢家

    实现德州扑克最关键的一步便是计算出那位玩家的手牌最大,确定最终的赢家,若最终赢家有多位则平分奖池。我用0到8等9个数字分别代表高牌到同花顺等四个等级,我不专门为皇家同花顺列一个等级,若场上同时出现两个同花顺,则根据同花顺中最大的卡牌数字来确定赢家,接下来开始介绍判断各种手牌类别的方法。

    #判断玩家的牌与公共牌是否构成顺子
    def judgestraight(finalpoker):
        result = [0, 0]#用于储存结果,result[0]中储存此位玩家最好的五张牌的类别,从高牌到皇家同花顺编号为0到9。result[1]储存当前开组中数字最大的牌
        pokernum = []#存储卡牌的数字
        for i in range(0, len(finalpoker)):
            pokernum.append(number.index(finalpoker[i]['数字']))
        pokernum.sort()#将卡牌号码从小到大进行排序
        #判断玩家卡牌与公共卡牌的组合是否能构成顺子
        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

    judgestraight函数用于判断玩家手牌与五张公共牌是否能构成顺子,需要输入参数finalpoker。finalpoker应接受一个列表对象,其内应包含玩家手牌与最终的公共牌,总计7张牌。而后判断其中是否有顺子,并将判断结果返回。结果中包含了两个信息:result[0]若为4则表明其内包含有顺子,为0则不包含。若包含顺子result[1]中会存储顺子中最大的卡牌数字。

    #判断卡组中是否存在同花
    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['数字']))
                    result[1] = max(pokernum)
            for ele in flush:
                finalpoker.remove(ele)
            flush.clear()
        return result

    judgeflush函数用于判断玩家的手牌中是否包含有同花,并将结果返回。同上,judgestraight函数所返回的结果包含两个信息,玩家的手牌与公共拍的组合中是否包含有同花,若有同花则同时将同花中的最大数字返回。

    #判断卡组中是否存在四条、三条、两对或一对
    def judgesame(finalpoker):
        result = [0, 0]
        four = -1   #记录卡组中是否存在四条
        three = -1  #记录卡组中是否存在三条
        two = [-1, -1] #记录卡组中是否存在两对与一对
    
        count = 1
        pokernum = []
        bottom = 0
        #将卡组的所有卡牌号存储进pokernum中,并进行排序
        for i in range(0, len(finalpoker)):
            pokernum.append(number.index(finalpoker[i]['数字']))
        pokernum.sort()
        #判断卡组中是否存在四条、三条、两对或一对等,并将所对应最大的卡牌数字进行存储
        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

    这个函数相较于上面两个函数相对长很多,因为它一个函数实现了三个功能,判断玩家手牌与公共牌的组合中是否含有一对、两对、三条或四条。与上述函数功能相似,judgesame会判断所接受卡组中是否含有上述四种情况,若有则将等级最高的情况返回,同时将该情况中所含最大的卡牌数字返回。

    #计算出玩家所持卡组中最大的组合牌类型
    def computeresult(Playerpoker, Publicpoker):
        finalresult = [0, 0]
        finalpoker = []
        finalpoker = Playerpoker + Publicpoker
        a = finalpoker.copy()
        b = finalpoker.copy()
        c = finalpoker.copy()
        #分别存储同花、顺子、四条、三条(即数字相同的个数与情况)等的判断结果
        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]
        #确定最终结果,即玩家所拥有的最大卡牌种类
        finalresult[0] = t_0
        finalresult[1] = t_1
    
        return finalresult

    我最终利用computeresult函数计算出每位玩家最终所拥有的最高等级卡组。在此函数中我分别调用了以上三个函数,通过比较得出玩家所拥有的最高等级卡组,并将结果返回。

    游戏主题函数

    我们编写的函数已能够实现游戏初始化与游戏结果的计算,接下来我们便利用以上函数编写德州扑克游戏的真正的主体。

    #游戏函数主体
    def gamestart(playersum):
        finalresult = []#用于存储每个玩家的最大手牌
        [playerpoker,Poker,Publicpoker] = Pokerinitial(playersum)#根据玩家数初始化一副卡牌,并给每位玩家分发两张手牌,并分发初始的三张公共牌
        playerlist = list(range(1,playersum+1))#记录每轮回合过后还剩下的玩家
        playerlist_t = []
        Playerpoker = []
        
        while len(Publicpoker) < 5 and len(playerlist) > 1:#当公共牌数为5或仅剩一个玩家时,游戏结束进行结算
            tag = 0 #标识符,标注所输入的继续游戏的玩家是否有误,若有误则重新输入
            playerkeep = input("请输入继续游戏的玩家:")
            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))#若选择继续游戏的玩家仅有一人,则游戏结束进行结算
                    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)+"   ")#将本回合的公共牌进行显示
    
                    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))#将每位玩家的手牌与公共牌代入计算最终结果
     
        finalscore = []
        finalscore_t = []
        finalplayer = []
        winner = []
        for t in range(0, len(finalresult)):
            finalscore.append(finalresult[t][0])
        
        maxscore = max(finalscore)#判断此时所有玩家中最大的组合牌类型
        #若有多位玩家同时拥有最大类型的组合牌,则对他们最大的牌数字进行比较
        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

    gamestart函数唯一需要输出的参数便是玩家的人数。在游戏的开始,我们利用Pokerinitial函数获得一副新卡牌,为每位玩家分发两张手牌,并分发三张初始公共牌。当玩家人数在游戏中途仅剩1时,我们认为游戏已结束,并显示最终赢家。若游戏正常进行到最后(有两位及以上玩家坚持到最后回合),则对每位玩家所拥有的最高等级卡牌组合进行计算与比较,得出最终赢家。若中途输入继续游戏的玩家并不在当前玩家队伍中时,系统会报错并提示重新输入。好了,话不多说,接下来我们便开始体验游戏吧!

    游戏体验与展示

    from Texas_Hold_em_Poker import gamestart

    我们首先导入我们所写的德州扑克游戏模块,并且仅需其中的gamstart函数。

    n = input('请输入要进行的游戏的玩家人数:')
    gamestart(int(n))

    接着我们便通过编写input函数从控制台获取进行游戏的玩家人数。

    怎么利用Python编写简易版德州扑克小游戏

    我们将参与游戏的玩家人数定为5

    怎么利用Python编写简易版德州扑克小游戏

    怎么利用Python编写简易版德州扑克小游戏

    接着屏幕上便出现了每个玩家的手牌与公共牌。

    怎么利用Python编写简易版德州扑克小游戏

    接着我们输入继续游戏的玩家

    怎么利用Python编写简易版德州扑克小游戏

    接着出现了下一回合的公共牌,我们接着让1,2,3号玩家继续游戏

    怎么利用Python编写简易版德州扑克小游戏

    可以看到出现了最后回合的公共牌,并计算出了最终赢家。此时我们尝试输入上一回合并未继续参与游戏的玩家号,看看会出现什么。

    怎么利用Python编写简易版德州扑克小游戏

    怎么利用Python编写简易版德州扑克小游戏

    我们仍然将游戏玩家人数定为5,并仍在第一回合让1,2,3号玩家继续游戏

    怎么利用Python编写简易版德州扑克小游戏

    但我们在下一回合输入已经退出游戏的玩家4号与5号

    怎么利用Python编写简易版德州扑克小游戏

    可以看到系统报错,并提示重新输入,此时我们只需要输入正确的玩家号码便可以得到正确的结果。

    看完了这篇文章,相信你对“怎么利用Python编写简易版德州扑克小游戏”有了一定的了解,如果想了解更多相关知识,欢迎关注亿速云行业资讯频道,感谢各位的阅读!

    向AI问一下细节

    免责声明:本站发布的内容(图片、视频和文字)以原创、转载和分享为主,文章观点不代表本网站立场,如果涉及侵权请联系站长邮箱:is@yisu.com进行举报,并提供相关证据,一经查实,将立刻删除涉嫌侵权内容。

    AI