python十点半纸牌游戏教程

  • Post author:
  • Post category:python



作品:十点半 / TenPointHalf(?)

前言:这是我的python编程作业,一个python写的纸牌游戏。

本文适合python入门新手,都是python基础知识


文章底部会贴出完整代码,如不想看罗嗦教程可以直接下划


*其实这个游戏我总共写了两次,

第一次是按游戏的设计一步一步写的,那时我刚接触python,写的乱七八糟

其实现在大概也差不多,不过有些进步就是了。。

那么我把它写完了,结果后来老师说:用类的方法来写

我一下子傻了

看了看以前写的代码,简直不能看……

又乱又长可读性还差……

就想着干脆就直接重构它吧


花一晚上时间,一气呵成,把它重构了

*


原本我写这个破游戏居然写了500行……重构之后代码量大概在240行左右(不含注释)

文章底部会贴出完整代码



游戏仅涉及python基础知识

存档、读档(python文件读写)
python类的运用(如init方法,self)
random库和time库(洗牌和记录存档时间)
循环、数组、字典、函数、集合等..

游戏道具:扑克牌一副


我先讲讲这扑克牌游戏大概是怎么一回事

  1. 游戏支持2-4人游玩(这是作业的设定,其实只要你想,几个人都能玩):

    设定游戏人数,每个玩家输入自己的名字
  2. 开局,手动选择一名庄家:

    指定序号的玩家称为庄家,庄家不需要下注


——顺带一提,我最初制作的是所有玩家丢骰子决定谁当庄家,重构的时候嫌麻烦就没那么整了

  1. 除庄家外的玩家(称

    闲家

    )下注:

    最低下1元最高下20元(

    我定的


  2. 发牌,一人一张,闲家可根据情况选择是否继续要牌,

    点大的玩家赢



    但手牌总点数超过十点半就要输钱了(称爆牌)
  3. 当所有的

    闲家

    都选择不要牌时,

    庄家

    可以开始选择是否继续要牌


  4. 庄家

    也不要牌时就可以

    决胜

    了,所有玩家的点数放在一起对比,输赢计算方式看下方

对了,这游戏里

J/Q/K

被称为

人牌

,均代表

0.5




核心规则




*获胜者不能爆牌(手牌总点数不超过10.5)*


某玩家点数最大,且全场没有出现与之相同点数的玩家

:他单人获胜


某玩家点数最大,但存在其它玩家与之点数相同

:持最大点数的玩家

都获胜


所有玩家都爆牌,下注金额全部归作者)




发奖




*所有获胜者都有奖金,奖金是所有玩家本轮下注之和构成的奖池*


闲家赢,获得奖池中的钱,且庄家需要额外向获胜闲家支付与其下注金额等量的钱

(毕竟庄家不用下注…)


庄家赢,获得奖池中的钱

***多人获胜则平分奖池中的奖金***

首先是游戏道具,一副扑克牌,

Card

类;

    #扑克牌类
    class Card:
        #初始化方法,包含了扑克牌对象的3个属性
        #3个属性:{花色,牌号,所代表的点数}
        def __init__(self,suit,rank,value):
           self.suit = suit
           self.rank = rank
           self.value = value
        #创建一副全新的扑克牌
        def InitCard(self):
            #创建扑克牌盒子
            self.cards = []
            #创建花色
            for suit in ["♠","♥","♣","♦"]:
                #创建牌号
                for rank in ["A","2","3","4","5","6","7","8","9","10","J","Q","K"]:
                    #实例化扑克牌对象,并赋予属性,然后装进扑克牌盒子
                    self.cards.append(self.Card(suit,rank,self.Calculate(rank)))
            #引入随机模块
            from random import shuffle as refresh
            #洗牌
            refresh(self.cards)

这里用到了

Calculate

,赋予每张扑克牌点数

    #牌点计算器,用于在创建扑克牌对象时提供每张牌的点数
    #输入参数:{牌号}
    def Calculate(rank):
        #字典,数据来源
        dictionary = {"A":1,"2":2,"3":3,"4":4,"5":5,"6":6,"7":7,"8":8,"9":9,"10":10,"J":0.5,"Q":0.5,"K":0.5}
        #约定点数并返回
        value = dictionary[rank]
        return value

接着是游戏参与者,

Players

类;

    class Players:
        #初始化方法,包含了玩家对象的9个属性
        #9个属性:{序号,名称,手牌,庄家标记,要牌标记,未爆牌标记,下注,金钱,牌点}
        def __init__(self,number,name,hand,banker,want,inboom,bet,money,point):
           self.number = number
           self.name = name
           self.hand = hand
           self.banker = banker
           self.want = want
           self.inboom = inboom
           self.bet = bet
           self.money = money
           self.point = point

上面我给玩家设定了很多属性,

方便

后面继续写……(并不方便



以上是游戏核心组成部分,下面开始真正的游戏结构

游戏从

Game

类的

Process

开始

Game.Process(Game)

上面这句是放在全局最后面用来启动游戏的,我们看看下面的

Game



顺带一提,游戏的一切都包围在

Game

类里

#游戏类
class Game:
    #一般游戏进程,从读取存档开始
    def Process(self):
        #初始回合数为0
        self.rounds = 0
        #初始Continue标记为True
        self.Continue = True
        #读取游戏
        self.Read(self)
        #当Continue标记为True时循环进行游戏
        while self.Continue:
            #创建一个玩家集合
            self.player_set = set()
            #初始化扑克牌
            self.Card.InitCard(self)
            #每轮的开始都将重置每名玩家的部分信息
            for i in range(self.player_amount):
                self.player_set.add(i)
                self.player_list[i].banker = False
                self.player_list[i].want = True
                self.player_list[i].inboom = True
                self.player_list[i].bet = 0
                #下面两句是加牌操作,每名玩家1张
                self.player_list[i].hand = [self.cards[0]]
                del self.cards[0]
            #进入叫庄环节
            self.Banker(self,self.player_amount,self.player_set)

上面这段代码会先执行到

Read

,游戏尝试读档

	#读取游戏的程序
    def Read(self):
        #首先进入读取游戏的子程序,子程序将判断系统是否能够读取游戏数据
        if self.__Read(self):
            #读取游戏存档
            with open("save.txt","r") as data:
                save = data.readlines()
            #让玩家选择是开始新游戏还是继续上一局
            if input(">>>系统检测到您已存在游戏数据:\n{}\n{}\n>>>是否要接着玩呢?输y继续玩,输其它开始新游戏:".format((save[0])[0:save[0].find("[Savetime]")],save[1])) in ("y","Y"):
                player_name = []
                #读取玩家数量信息
                self.player_amount = int((save[1])[save[1].find("[Rounds]")+8:save[1].find("[Players]")])
                #读取游戏回合信息
                self.rounds = int((save[1])[0:save[1].find("[Rounds]")])
                #读取玩家名称信息
                for i in range(self.player_amount):
                    player_name.append((save[i+2])[save[i+2].find("[Num]")+5:save[i+2].find("[Name]")])
                #初始化扑克牌
                self.Card.InitCard(self)
                #初始化游戏,初始化方法为1
                self.InitGame(self,player_name,self.player_amount,1)
                #读取玩家金钱信息
                for i in range(self.player_amount):
                    self.player_list[i].money = int((save[i+2])[save[i+2].find("[Name]")+6:save[i+2].find("[Money]")])
                #清除读取的save,释放内存
                del save
                input(">>>已恢复上局游戏数据~<<<\n\n-戳回车键查看玩家信息并继续游戏")
                #展示所有玩家信息
                self.Show(self,self.player_amount)
                #初始化游戏,初始化方法为3
                self.InitGame(self,player_name,self.player_amount,3)
            #若玩家选择不读取,则开始新游戏
            else:
                self.Start(self)


Read

这里最开始是进入

__Read

,判断能否读到存档

如果读不到存档就进入

Start

(全新开始)

    #读取游戏的子程序
    def __Read(self):
        try:
            #检验是否能正常读取游戏数据,若能读取则返回True
            with open("save.txt","r"):
                return True
        #否则将直接开始新游戏
        except:
            print(">>>系统未检测到游戏数据喔,新游戏将开始<<<")
            self.Start(self)

这个是

Start

    #游戏进程,从零开始
    def Start(self):
        #初始化扑克牌
        self.Card.InitCard(self)
        #初始化玩家
        self.PlayerInit(self)

绕了一圈,现在我们回到

Read


如果读到了存档,程序就只用初始化扑克牌

Card.InitCard

毕竟从存档读取到了玩家的信息,不需要用

PlayerInit

方法

既然有了玩家和扑克牌,就可以初始化游戏了

#初始化游戏,初始化方法为1
self.InitGame(self,player_name,self.player_amount,1)

我们先来看看

InitGame

函数

这里我们给的

Action

参数是

1

    #初始化游戏,有三种初始化方法
    #输入参数:{玩家名称列表,玩家数量,初始化方式}
    def InitGame(self,player_name,player_amount,Action):
        #Action参数小于3时执行游戏初始化
        if Action < 3:
            #创建玩家列表,玩家集合
            self.player_list = []
            self.player_set = set()
            #给每位玩家添加初始数据
            for i in range(self.player_amount):
                self.player_list.append(self.Players(i,player_name[i],[self.cards[0]],False,True,True,0,100,0))
                self.player_set.add(i)
                #因为中间涉及到了发牌,所以要从牌堆删除发给玩家的牌
                del self.cards[0]
            #若Action等于2追加执行,进入叫庄环节
            if Action == 2:
                self.Banker(self,self.player_amount,self.player_set)
        #Action参数等于3时不进行初始化,直接进入叫庄环节(成功读取到游戏数据)
        if Action == 3:
            self.Banker(self,self.player_amount,self.player_set)

那么

InitGame

只会执行创建玩家信息并给牌的操作

再次回到

Read

,读取每名玩家的金钱信息

为什么不在一开始就读取呢?主要是因为我流程设计的原因…只能放到后面…

接着进入

Show

,展示玩家们的信息

    #展示所有玩家信息的程序
    #输入参数:{玩家数量}
    def Show(self,player_amount):
        #此Flag用于记录玩家金钱是否不足以进行下一局游戏,初始值为True
        Flag = True
        #对于所有玩家
        for i in range(self.player_amount):
            #展示玩家信息
            print("\n>>>玩家{}:[{}]\n>>>庄家:{}\n>>>手牌:".format(i + 1,self.player_list[i].name,self.player_list[i].banker),end = "")
            #若此玩家金钱不足,Flag将设定为False,游戏将结束
            if int(self.player_list[i].money) <= 0:
                Flag = False
            #展示玩家信息
            for n in range(len(self.player_list[i].hand)):
                print(self.player_list[i].hand[n].suit + self.player_list[i].hand[n].rank,end = " ")
            print("\n>>>手牌点数:{}\n>>>本轮下注:{}$\n>>>钱包余额:{}$".format(self.player_list[i].point,self.player_list[i].bet,self.player_list[i].money))
        return Flag


Show

的作用有两个:一个是展示所有玩家的信息,另一个是判断玩家有没有输光

这里玩家还是有钱的,所以展示完成后又回到

Read

,执行到下面这段

#初始化游戏,初始化方法为3
self.InitGame(self,player_name,self.player_amount,3)

初始化函数里

Action

参数为

3

的时候其实已经不是初始化了

这里是直接进入叫庄环节(

banker

),游戏开始了

Banker(self,self.player_amount,self.player_set)
    #叫庄环节
    #输入参数:{玩家数量,玩家集合}
    def Banker(self,player_amount,player_set):
        #进入叫庄意味着游戏正式开始,回合数将加1
        self.rounds += 1
        while True:
            try:
                #输入庄家的玩家序号
                banker_number = int(input("第{}局游戏开始,请您选出一名庄家,庄家不需要下注哟!\n>>>请指定庄家的序号,1-{}号都可以:".format(self.rounds,self.player_amount))) - 1
                #若玩家序号没有错误将执行子程序
                if banker_number in range(self.player_amount):
                    self.__Banker(self,self.player_amount,banker_number,self.player_set)
                    break
                #玩家序号输入错误则报错
                else:
                    print(">>>请输入正确的玩家序号哟,再试一次吧!<<<")
            #若输入非数字将报出此错
            except:
                print("\n>>>系统监测到了错误,但是系统不知道怎么解决")


Banker

负责判断玩家序号是否输入正确,若正确则进入

__Banker

修改庄家信息

    #叫庄子程序
    #输入参数:{玩家数量,庄家编号,玩家集合}
    def __Banker(self,player_amount,banker_number,player_set):
        #修改该名玩家的庄家标识符
        self.player_list[banker_number].banker = True
        #从玩家集合中除去这名庄家,将其变为闲家集合
        self.player_set -= {banker_number}
        print("\n>>>{}号玩家:[{}]通过选举成为了庄家!".format(banker_number + 1,self.player_list[banker_number].name))
        #进入下注环节
        self.Bet(self,self.player_amount,banker_number,self.player_set)

庄家被确定,游戏进入下一个环节:下注

Bet

    #下注环节
    #输入参数:{玩家数量,庄家编号,闲家集合}
    def Bet(self,player_amount,banker_number,player_set):
        #对于每名闲家
        for i in self.player_set:
            while True:
                try:
                    #输入下注值
                    bet = int(input("-闲家{}:[{}],轮到你下注了!\n>>>最低下1$,最高可以下20$:".format(i + 1,self.player_list[i].name)))
                    #限制下注值在1-20范围之间
                    if bet in range(1,21):
                        #进入下注子程序
                        if self.__Bet(self,i,bet):
                            break
                    #若下注不符合范围规定则报错
                    else:
                        print(">>>下注区间是1-20$,请注意下呢!<<<")
                #若输入非整数将报此错
                except:
                    print("\n>>>系统监测到了错误,但是系统不知道怎么解决")
        #进入补牌环节
        self.AugmentCard(self,self.player_amount,banker_number,self.player_set)



Banker

一样,

Bet

这里只负责判断,真正修改下注数据需要执行

__Bet

    #下注子程序
    #输入参数:{下注者编号,下注金额}
    def __Bet(self,i,bet):
        #判断该名玩家是否下假注(钱包里根本没那么多钱)
        if (self.player_list[i].money - bet) >= 0:
            #未超额,正常下注
            self.player_list[i].money -= bet
            self.player_list[i].bet = bet
            print("\n>>>闲家{}:[{}]下了{}$,钱包还剩{}$!".format(i + 1,self.player_list[i].name,bet,self.player_list[i].money))
            return True
        #超额了,返回False给主程序,主程序将给予回应
        else:
            print(">>>您的钱不够,您只有{}$!请重新下注!".format(self.player_list[i].money))
            return False

当每名闲家下注完,程序回到

Bet

这里,开始下一个环节:补牌

#进入补牌环节
self.AugmentCard(self,self.player_amount,banker_number,self.player_set)

补牌环节是这个游戏里相对复杂的流程



也是这个游戏中比较能体现

[博弈]

的场景

牌点又要大过别人,又不能超过 10.5

而且也不知道扑克牌堆里的下一张是什么,说不定一抽就成千古恨了

说实话我感觉自己写的不怎么样……有点长乱

    #补牌环节
    #输入参数:{玩家数量,庄家编号,闲家集合}
    def AugmentCard(self,player_amount,banker_number,player_set):
        #初始化补牌轮数为0
        count = 0
        #完成补牌的玩家数为0
        success = 0
        #设定补牌未完成标识为True
        insuccess = True
        print("\n>>>补牌阶段开始,闲家优先!<<<\n")
        #若补牌未完成标识为True
        while insuccess:
            #补牌轮数加1
            count += 1
            print("-第{}轮补牌开始!".format(count))
            #对于每名闲家
            for i in self.player_set:
                #若该名闲家的要牌标记为True且不爆牌标记为True
                if self.player_list[i].want and self.player_list[i].inboom:
                    #玩家可决定是否补牌,若输入为Y、y将进入补牌子程序
                    if input(">>>闲家{}:[{}]轮到你选择了!\n-目前牌点为{},若要补牌请输入y:".format(i + 1,self.player_list[i].name,self.__calculate(self,i))) in ("Y","y"):
                        self.__AugmentCard(self,i)
                    #玩家选择不补牌则将玩家的要牌标记设为False
                    else:
                        print("\n>闲家{}不敢补了。".format(i + 1))
                        self.player_list[i].want = False
                #补牌完成了,完成补牌的玩家数量加1
                else:
                    success += 1
                    #若所有闲家均完成补牌,则将未完成标识符设为False,循环将停止
                    if success == self.player_amount - 1:
                        insuccess = False
        #接下来轮到庄家补牌了
        i = banker_number
        while True:
            #循环条件为庄家要牌标记为True且不爆牌标记为True
            if self.player_list[i].want and self.player_list[i].inboom:
                #玩家可决定是否补牌,若输入为Y、y将进入补牌子程序
                if input("\n>>>庄家{}:[{}]请注意!现在轮到你选择了!\n-目前牌点为{},若要补牌请输入y:".format(i + 1,self.player_list[i].name,self.__calculate(self,i))) in ("Y","y"):
                    self.__AugmentCard(self,i)
                #玩家选择不补牌则将玩家的要牌标记设为False
                else:
                    print("\n>庄家{}不敢补了。".format(i + 1))
                    self.player_list[i].want = False
            #所有玩家完成补牌,结束循环
            else:
                break
        #进入决胜环节
        self.Fight(self,self.player_amount,banker_number)

总而言之就是闲家补完庄家补,且爆牌者即刻出局,不得参与补牌……

这里

可能

有一些……

复杂的判断

…所以写的比较长乱…水平有限……

和前面一样,

AugmentCard

也只负责表面工作,真正修改扑克牌数据是在

__AugmentCard

里面进行的

    #补牌子程序
    #输入参数:{要牌者玩家编号}
    def __AugmentCard(self,i):
        print("\n-玩家{}:[{}]抽到了{}{}:{}点!".format(i + 1,self.player_list[i].name,self.cards[0].suit,self.cards[0].rank,self.cards[0].value))
        #从牌堆顶摸一张牌给玩家
        self.player_list[i].hand.append(self.cards[0])
        del self.cards[0]
        #玩家得牌后计算该名玩家的手牌点数,若大于10.5则爆牌
        if self.__calculate(self,i) > 10.5:
            print(">>>目前的点数为{}!您爆了,神仙也救不了您!".format(self.player_list[i].point))
            #修改不爆牌标记
            self.player_list[i].inboom = False
        #若未爆则对赌徒进行鼓励,增加赌场的预期收入
        else:
            print(">>>目前的点数为{}!再接再励哟!".format(self.player_list[i].point))


__AugmentCard

负责告诉玩家自己抽到牌的点数,并判断玩家是否爆牌

若玩家爆牌则修改一下该名玩家的爆牌标记,该名玩家即刻退出补牌环节

这里调用了

__calculate

计算牌点

    #玩家牌点计算器
    #输入参数:{被计算牌点的玩家编号}
    def __calculate(self,i):
        #计算前先将记录玩家牌点的属性归零,因为稍后将给予新的数值
        self.player_list[i].point = 0
        #将玩家手中每张牌的点数加起来
        for n in range(len(self.player_list[i].hand)):
            self.player_list[i].point += self.player_list[i].hand[n].value
        #返回该名玩家的牌点
        return self.player_list[i].point


__calculate

将返回指定玩家手牌点数的总和

好了,回到我们的

AugmentCard

,接下来要进入到最终环节

Fight

,亮牌决胜

#进入决胜环节
self.Fight(self,self.player_amount,banker_number)

这个环节同样比较长,比较

复杂

…… 也许只是我写的比较复杂而已……

    #决胜环节
    #输入参数:{玩家数量,庄家编号}
    def Fight(self,player_amount,banker_number):
        #为了方便决出胜负,创建点数列表用于存放所有玩家的牌点
        point_list = []
        #创建奖金,初始值为0
        bouns = 0
        #对所有玩家进行操作
        for i in range(self.player_amount):
            #奖金为玩家下注总和
            bouns += self.player_list[i].bet
            #若玩家未爆牌(手牌点数和小于10.5)
            if self.player_list[i].point <= 10.5:
                #则在点数列表中添加相应玩家的手牌点数
                point_list.append(self.player_list[i].point)
            else:
                #否则为这名玩家添加大小为"-1"的点数
                point_list.append(-1)
        #判断玩家是否全爆,判断依据为:"-1"数量是否小于玩家的总数
        if point_list.count(-1) < self.player_amount:
            #玩家未全爆,则找出点数最大值
            biggest = max(point_list)
            #若点数最大值出现重复现象
            if point_list.count(biggest) > 1:
                #创建获胜玩家列表,重复且最高的玩家都将获胜
                winner = [i for i,repeat in enumerate(point_list) if repeat == biggest]
                print("\n>>>本轮游戏共有{}名玩家获胜:".format(len(winner)))
                #对于每名获胜玩家,进入发奖子程序
                for i in winner:
                    self.__Bouns(self,i,bouns/len(winner),banker_number)
            #若点数最大值未出现重复现象
            else:
                #获胜者为该最大点数的所有者
                i = point_list.index(biggest)
                print("\n>>>恭喜玩家{}:[{}]获得本轮的胜利!<<<".format(i + 1,self.player_list[i].name))
                #进入发奖子程序
                self.__Bouns(self,i,bouns,banker_number)
        #若所有玩家都爆牌将不进行任何发奖
        else:
            print(">>>\n你们都爆了,这里的{}$谁也拿不走!".format(bouns),banker_number)
        #程序将在此停顿,接到回车键命令后继续进行
        input("\n>>>戳回车键展示所有玩家的数据<<<\n")
        #保存游戏数据
        self.Save(self,self.player_amount)
        #进入Show程序,程序在展示玩家数据的同时将判断是否有玩家输光,若未出现输光情况则可以继续进行下一轮游戏
        if self.Show(self,self.player_amount):
            if input("\n>>>还来一把?\n-输入n可以结束游戏,不输n继续游戏:") in ("n","N"):
                #若玩家选择不继续,将结束游戏
                self.GameExit(self)
        #若Show程序发现有玩家已经输光
        else:
            print(">>>啊哦,好像有人输光了!<<<")
            #结束游戏
            self.GameExit(self)


Fight

主要的工作是判断获胜者,处理奖金,并将获胜者交给

__Bouns

颁奖

对于多名玩家获胜的判断,这里用到了一点链表

下面是

__Bouns

    #发奖子程序
    #输入参数:{获奖者玩家编号,奖金,庄家编号}
    def __Bouns(self,i,bouns,banker_number):
        #若该名获奖者不是庄家
        if not self.player_list[i].banker:
            #从庄家的钱包中扣除该名获奖者在本轮中的下注金额,并将其加入奖池
            self.player_list[banker_number].money -= self.player_list[i].bet
            bouns += self.player_list[i].bet
            print("\n>>>闲家获胜,庄家要额外付给他与他下注同样多的钱,总共{}$!".format(self.player_list[i].bet))
        #发奖给获奖者
        self.player_list[i].money += bouns
        print(">>>玩家{}:[{}]共获得{}$奖金,钱包余额为{}$!".format(i + 1,self.player_list[i].name,bouns,self.player_list[i].money))


__Bouns

的工作很简单,判断一下然后发钱就行了,再顺便告诉一下玩家自己赢(输)了多少钱

奖发完了,同时宣告这轮游戏正式结束,程序进入

Save

尝试保存游戏数据

    #保存游戏的程序
    #输入参数:{玩家数量}
    def Save(self,player_amount):
        #首先进入保存游戏的子程序,子程序将判断系统是否能够保存游戏数据
        if self.__Save(self):
            #引入时间库,记录存档时间
            import datetime as date
            #重新格式化时间文本
            time = date.datetime.now().strftime("%Y.%m.%d-%H:%M:%S")
            #保存数据
            with open("save.txt","w+") as data:
                #游戏数据:保存时间、游戏回合、玩家数量
                data.writelines("{}[Savetime]\n{}[Rounds]{}[Players]\n".format(time,self.rounds,self.player_amount))
                #玩家数据:玩家序号、玩家名称、玩家金钱
                for i in range(self.player_amount):    
                    data.writelines("{}[Num]{}[Name]{}[Money]\n".format(self.player_list[i].number,self.player_list[i].name,int(self.player_list[i].money)))


__Save



__Read

一样,就是用来测试能否读写文件的,其实这俩函数合并成一个就行了……

    #保存游戏的子程序,用于判断能否保存游戏数据
    def __Save(self):
        try:
            with open("save.txt","w+"):
                #若执行成功程序将返回True
                return True
        #执行失败将报错
        except:
            print("\n>>>不知为何,系统无法保存游戏数据<<<")


Save

运行后在py运行目录下写出一个txt存档,然后我们回到

Fight

,进行到执行

Show

        #进入Show程序,程序在展示玩家数据的同时将判断是否有玩家输光,若未出现输光情况则可以继续进行下一轮游戏
        if self.Show(self,self.player_amount):
            if input("\n>>>还来一把?\n-输入n可以结束游戏,不输n继续游戏:") in ("n","N"):
                #若玩家选择不继续,将结束游戏
                self.GameExit(self)
        #若Show程序发现有玩家已经输光
        else:
            print(">>>啊哦,好像有人输光了!<<<")
            #结束游戏
            self.GameExit(self)

前面也提到过

Show

的两个作用,展示数据,以及判断玩家是否输光

如果存在任意一名玩家输光了钱,那当然是强制结束游戏,赶出赌场了,进入

GameExit

当然,如果所有玩家都还有钱,还是可以主动选择是否结束游戏(

GameExit

)的

    #结束游戏的程序
    def GameExit(self):
        self.Continue = False
        input("\n>>>十点半游戏到此结束!\nCopyright ©2018 武澳博\n>>>有问题的话欢迎来找我交流!\n\n-请按回车键结束程序")

当然,如果选择不结束,游戏会不断循环进行,直到有玩家输光,或者玩到你不想玩了为止

控制循环的部分在

Game.Process

,由一个

Continue

标记决定,回去上面看看吧


到这本文也就结束了,作者刚读大一,水平有限,欢迎交流指正

以前总看别人的文章,这下自己也写个一篇,继续努力


下面贴出这个十点半游戏的完整代码:

https://blog.csdn.net/qq_26373925/article/details/87288054


原创



版权声明:本文为qq_26373925原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。