第3个项目实操：用类与对象的方法编程

1. 明确项目目标

本关我们将在游戏中定义三种类型的角色：圣光骑士、暗影刺客、精灵弩手，他们三者之间也会互相克制。

2. 分析过程，拆解项目

3. 逐步执行，代码实现

上个版本代码：

import time,random

# 需要的数据和变量放在开头
player_list =  ['【狂血战士】','【森林箭手】','【光明骑士】','【独行剑客】','【格斗大师】','【枪弹专家】']
enemy_list = ['【暗黑战士】','【黑暗弩手】','【暗夜骑士】','【嗜血刀客】','【首席刺客】','【陷阱之王】']
players = random.sample(player_list,3)  
enemies = random.sample(enemy_list,3)
player_info = {}
enemy_info = {}

# 随机生成角色的属性
def born_role():
    life = random.randint(100,180)
    attack = random.randint(30,50)
    return life,attack

# 生成和展示角色信息
def show_role():
    for i in range(3):
        player_info[players[i]] = born_role()
        enemy_info[enemies[i]] = born_role()
    
    # 展示我方的3个角色
    print('----------------- 角色信息 -----------------')
    print('你的人物：')
    for i in range(3):
        print('%s  血量：%s  攻击：%s' 
        %(players[i],player_info[players[i]][0],player_info[players[i]][1]))
    print('--------------------------------------------')
    print('电脑敌人：')

    # 展示敌方的3个角色
    for i in range(3):
        print('%s  血量：%s  攻击：%s' 
        %(enemies[i],enemy_info[enemies[i]][0],enemy_info[enemies[i]][1]))
    print('--------------------------------------------')
    input('请按回车键继续。\n')  # 为了让玩家更有控制感，可以插入类似的代码来切分游戏进程。

# 角色排序，选择出场顺序。
def order_role(): 
    global players
    order_dict = {}
    for i in range(3):
        order = int(input('你想将 %s 放在第几个上场？(输入数字1~3)'% players[i]))
        order_dict[order] = players[i]  

    players = []
    for i in range(1,4):
        players.append(order_dict[i]) 
    
    print('\n我方角色的出场顺序是：%s、%s、%s' %(players[0],players[1],players[2]))
    print('敌方角色的出场顺序是：%s、%s、%s' %(enemies[0],enemies[1],enemies[2]))

# 角色PK
def pk_role(): 
    round = 1  
    score = 0
    for i in range(3):  # 一共要打三局
        player_name = players[i]  
        enemy_name = enemies[i] 
        player_life = player_info[players[i]][0]
        player_attack = player_info[players[i]][1]
        enemy_life = enemy_info[enemies[i]][0]
        enemy_attack = enemy_info[enemies[i]][1]

        # 每一局开战前展示战斗信息
        print('\n----------------- 【第%s局】 -----------------' % round)
        print('玩家角色：%s vs 敌方角色：%s ' %(player_name,enemy_name))
        print('%s 血量：%s  攻击：%s' %(player_name,player_life,player_attack))
        print('%s 血量：%s  攻击：%s' %(enemy_name,enemy_life,enemy_attack))
        print('--------------------------------------------')
        input('请按回车键继续。\n')

        # 开始判断血量是否都大于零，然后互扣血量。
        while player_life > 0 and enemy_life > 0:
            enemy_life = enemy_life - player_attack
            player_life = player_life - enemy_attack
            print('%s发起了攻击，%s剩余血量%s' % (player_name,enemy_name,enemy_life))
            print('%s发起了攻击，%s剩余血量%s' % (enemy_name,player_name,player_life))
            print('--------------------------------------------')
            time.sleep(1)
        else:  # 每局的战果展示，以及分数score和局数的变化。
            # 调用show_result()函数，打印返回元组中的result。
            print(show_result(player_life,enemy_life)[1])
            # 调用show_result()函数，完成计分变动。
            score += int(show_result(player_life,enemy_life)[0])
            round += 1
    input('\n点击回车，查看比赛的最终结果\n')

    if score > 0:
        print('【最终结果：你赢了！】\n')
    elif score < 0:
        print('【最终结果：你输了！】\n')
    else:
        print('【最终结果：平局！】\n')

# 返回单局战果和计分法所加分数。
def show_result(player_life,enemy_life):  # 注意：该函数要设定参数，才能判断单局战果。
    if player_life > 0 and enemy_life <= 0:
        result = '\n敌人死翘翘了，你赢了！'
        return 1,result  # 返回元组(1,'\n敌人死翘翘了，你赢了！')，类似角色属性的传递。
    elif player_life <= 0 and enemy_life > 0:        
        result = '\n悲催，敌人把你干掉了！'
        return -1,result
    else :
        result = '\n哎呀，你和敌人同归于尽了！'
        return 0,result

# （主函数）展开战斗流程
def main():
    show_role()  # 生成和展示角色信息
    order_role()  # 角色排序，选择出场顺序
    pk_role()  # 完成角色PK，并展示PK结果

# 启动程序（即调用主函数）
main()

V1.0：写出运行游戏的类

完整代码存在一些问题，需要再修改

import random
import time

# 创建一个类，可实例化成具体的游戏角色
class Role():
   def __init__(self, name = '【角色】'): #角色名称作为默认参数  
    self.name = name
    self.life = random.randint(100,150)
    self.attack = random.randint(30,50)

#创建3个子类，可实例化为3个不同的职业
class Knight(Role):
  def __init__(self,name = '【圣光骑士】'):
    #这里初始化的第二个参数是默认参数，
    #也就是当实例化的时候不输入这个第二个参数，第二个参数就默认为'【角色】'。
    Role.__init__(self,name)
    #这一句代码，可以在子类中使用父类的初始化函数。
    self.life = self.life*5
    self.attack = self.attack*3

  #职业克制关系
  def fight_buff(self,oppoent,str1,str2):
    if oppoent.name == '【暗影刺客】':
      self,attack = int (self.attack * 1.5)
      print('『%s』【圣光骑士】对 『%s』【暗影刺客】说：“让无尽光芒制裁你的堕落！”'%(str1,str2))

class Assassin(Role):
  def __init__(self,name='【暗影刺客】'):
    Role.__init__(self,name)
    self.life = self.life*3
    self.attack = self.attack*5

  #职业克制关系
  def fight_buff(self,oppoent,str1,str2):
    if oppoent.name == '【精灵弩手】':
      self,attack = int (self.attack * 1.5)
      print('『%s』【暗影刺客】对 『%s』【精灵弩手】说：“主动找死，就别怪我心狠手辣。”'%(str1,str2)) 

class Bowman(Role):
  def __init__(self,name='【圣光骑士】'):
    Role.__init__(self,name)
    self.life = self.life*4
    self.attack = self.attack*4

  #职业克制关系
  def fight_buff(self,oppoent,str1,str2):
    if oppoent.name == '【精灵弩手】':
      self,attack = int (self.attack * 1.5)
      print('『%s』【精灵弩手】对 『%s』【圣光骑士】说：“骑着倔驴又如何？你都碰不到我衣服。”'%(str1, str2)) 
    
class Game():

  #初始化函数
  def __init__(self):
    #初始化各变量
    self.players = []  #存玩家顺序
    self.enemies = []  #存敌人顺序
    self.score = 0   #比赛积分
    self.i = 0     #记轮次
    #执行各种游戏函数
    self.game_start()  # 欢迎语
    self.born_role()  # 随机生成6个角色
    self.show_role()  # 展示角色
    self.order_role()  # 排序并展示
    self.pk_role()  # 让双方 Pk 并展示结果
    self.show_result()  # 展示最终结局

  #欢迎语
  def game_start(self):
    print('------------ 欢迎来到“炼狱角斗场” ------------')
    print('在昔日的黄昏山脉，奥卢帝国的北境边界上，有传说中的“炼狱角斗场”。')
    print('鲜血与战斗是角斗士的归宿，金钱与荣耀是角斗士的信仰！')
    print('今日，只要【你的队伍】能取得胜利，你将获得一笔够花500年的财富。')
    time.sleep(2)
    print('将随机生成【你的队伍】和【敌人队伍】！')
    input('\n狭路相逢勇者胜，请按任意键继续。\n')

  #玩家和电脑随机各生成3个角色
  def born_role(self):
    for i in range(3):
      #实例对象可以像变量一样，被直接放到列表里。
      self.players.append(random.choice([Knight(),Assassin(),Bowman()]))
      self.enemies.append(random.choice([Knight(),Assassin(),Bowman()]))
  
  # 实例对象甚至这么用也是可以
  # for i in [Role(),Knight(),Assassin(),Bowman()]:
  #   print(i.name + '的血量是' + str(i.life) + '；攻击力是' + str(i.attack))


  # 生成和展示角色信息
  def show_role(self):
    print('----------------- 角色信息 -----------------')
    print('你的队伍：')
    for i in range(3):
      print( '『我方』%s 血量：%s  攻击：%s'%
      (self.players[i].name,self.players[i].life,self.players[i].attack))
    print('--------------------------------------------')

    print('敌人队伍：')
    for i in range(3):
      print('『敌方』%s 血量：%s  攻击：%s'%
      (self.enemies[i].name,self.enemies[i].life,self.enemies[i].attack))
    print('--------------------------------------------')
    input('请按回车键继续。\n')

  # 角色排序，选择出场顺序。
  def order_role(self):
    order_dict = {}
    for i in range(3):
      order = int(input('你想将 %s 放在第几个上场？(输入数字1~3)'% self.players[i].name))
      order_dict[order] = self.players[i]
    self.players = []
    for i in range(1,4):
      self.players.append(order_dict[i]) 
    print('\n你的队伍出场顺序是：%s、%s、%s'
    %(self.players[0].name,self.players[1].name,self.players[2].name))
    print('敌人队伍出场顺序是：%s、%s、%s'
    %(self.enemies[0].name,self.enemies[1].name,self.enemies[2].name))

  # 角色PK
  def pk_role(self):
    for i in range(3):
      print('\n----------------- 【第%s轮】 -----------------' % (i+1))
      # 每一局开战前加buff
      self.players[i].fight_buff(self.enemies[i],'我方','敌方')
      self.enemies[i].fight_buff(self.players[i],'敌方','我方')
      input('\n战斗双方准备完毕，请按回车键继续。')
      print('--------------------------------------------')

      while self.players[i].life >0 and self.enemies[i].life>0:
          self.enemies[i].life -= self.players[i].attack
          self.players[i].life -= self.enemies[i].attack
          print('我方%s 发起了攻击，敌方%s 剩余血量 %s'%
          (self.players[i].name,self.enemies[i].name,self.enemies[i].life))
          print('敌方%s 发起了攻击，我方%s 剩余血量 %s'%
          (self.enemies[i].name,self.players[i].name,self.players[i].life))
          print('--------------------------------------------')
          time.sleep(1)
      if self.players[i].life <= 0 and self.enemies[i].life> 0:
          print('\n很遗憾，我方%s 挂掉了！'% (self.players[i].name))
          self.score -= 1
      elif self.players[i].life >0 and self.enemies[i].life<= 0: 
          print('\n恭喜，我方%s 活下来了。'% (self.players[i].name))
          self.score += 1
      else:
          print('\n我的天，他们俩都死了啊！')

  # 展示最终结局
  def show_result(self):
    input('\n请按回车查看最终结果。\n')
    if self.score >0:
      print('【最终结果】\n你赢了，最终的财宝都归你了！')
    elif self.score == 0:
      print('【最终结果】\n你没有胜利，但也没有失败，在夜色中灰溜溜离开了奥卢帝国。')
    else:
      print('【最终结果】\n你输了。炼狱角斗场又多了几具枯骨。')
  
game = Game()
>>>
------------ 欢迎来到“炼狱角斗场” ------------
在昔日的黄昏山脉，奥卢帝国的北境边界上，有传说中的“炼狱角斗场”。
鲜血与战斗是角斗士的归宿，金钱与荣耀是角斗士的信仰！
今日，只要【你的队伍】能取得胜利，你将获得一笔够花500年的财富。
将随机生成【你的队伍】和【敌人队伍】！

狭路相逢勇者胜，请按任意键继续。

----------------- 角色信息 -----------------
你的队伍：
『我方』【圣光骑士】 血量：440  攻击：200
『我方』【暗影刺客】 血量：351  攻击：235
『我方』【圣光骑士】 血量：705  攻击：102
--------------------------------------------
敌人队伍：
『敌方』【圣光骑士】 血量：532  攻击：136
『敌方』【暗影刺客】 血量：444  攻击：150
『敌方』【圣光骑士】 血量：504  攻击：168
--------------------------------------------
请按回车键继续。

你想将 【圣光骑士】 放在第几个上场？(输入数字1~3)1
你想将 【暗影刺客】 放在第几个上场？(输入数字1~3)2
你想将 【圣光骑士】 放在第几个上场？(输入数字1~3)3

你的队伍出场顺序是：【圣光骑士】、【暗影刺客】、【圣光骑士】
敌人队伍出场顺序是：【圣光骑士】、【暗影刺客】、【圣光骑士】

----------------- 【第1轮】 -----------------

战斗双方准备完毕，请按回车键继续。
--------------------------------------------
我方【圣光骑士】 发起了攻击，敌方【圣光骑士】 剩余血量 332
敌方【圣光骑士】 发起了攻击，我方【圣光骑士】 剩余血量 304
--------------------------------------------
我方【圣光骑士】 发起了攻击，敌方【圣光骑士】 剩余血量 132
敌方【圣光骑士】 发起了攻击，我方【圣光骑士】 剩余血量 168
--------------------------------------------
我方【圣光骑士】 发起了攻击，敌方【圣光骑士】 剩余血量 -68
敌方【圣光骑士】 发起了攻击，我方【圣光骑士】 剩余血量 32
--------------------------------------------

恭喜，我方【圣光骑士】 活下来了。

----------------- 【第2轮】 -----------------

战斗双方准备完毕，请按回车键继续。
--------------------------------------------
我方【暗影刺客】 发起了攻击，敌方【暗影刺客】 剩余血量 209
敌方【暗影刺客】 发起了攻击，我方【暗影刺客】 剩余血量 201
--------------------------------------------
我方【暗影刺客】 发起了攻击，敌方【暗影刺客】 剩余血量 -26
敌方【暗影刺客】 发起了攻击，我方【暗影刺客】 剩余血量 51
--------------------------------------------

恭喜，我方【暗影刺客】 活下来了。

----------------- 【第3轮】 -----------------

战斗双方准备完毕，请按回车键继续。
--------------------------------------------
我方【圣光骑士】 发起了攻击，敌方【圣光骑士】 剩余血量 402
敌方【圣光骑士】 发起了攻击，我方【圣光骑士】 剩余血量 537
--------------------------------------------
我方【圣光骑士】 发起了攻击，敌方【圣光骑士】 剩余血量 300
敌方【圣光骑士】 发起了攻击，我方【圣光骑士】 剩余血量 369
--------------------------------------------
我方【圣光骑士】 发起了攻击，敌方【圣光骑士】 剩余血量 198
敌方【圣光骑士】 发起了攻击，我方【圣光骑士】 剩余血量 201
--------------------------------------------
我方【圣光骑士】 发起了攻击，敌方【圣光骑士】 剩余血量 96
敌方【圣光骑士】 发起了攻击，我方【圣光骑士】 剩余血量 33
--------------------------------------------
我方【圣光骑士】 发起了攻击，敌方【圣光骑士】 剩余血量 -6
敌方【圣光骑士】 发起了攻击，我方【圣光骑士】 剩余血量 -135
--------------------------------------------

我的天，他们俩都死了啊！

请按回车查看最终结果。

【最终结果】
你赢了，最终的财宝都归你了！

补充知识点：

class Animal():  #创建一个父类“动物”
    def __init__(self, name):
        self.name = name
        self.attack = 100  #动物攻击力100

class Cat(Animal):                      # 创建一个子类“猫”
    def __init__(self, name = '猫'):
        Animal.__init__(self, name)    # 完全继承动物的初始化函数，也就是攻击力还是100

    def fight_buff(self, opponent):   # fight_buff的意思是“战斗强化”，opponent的意思是“对手”
        if opponent.name == '老鼠':
            self.attack = int(self.attack * 1.5)
        else:
            self.attack = 100

class Rat(Animal):                    # 创建一个子类“老鼠”
    def __init__(self,name = '老鼠'):
        Animal.__init__(self,name)    # 完全继承动物的初始化函数，也就是攻击力还是100
    
class Monkey(Animal):                 # 创建一个子类“猴子”
    def __init__(self,name = '猴子'):
        Animal.__init__(self,name)    # 完全继承动物的初始化函数，也就是攻击力还是100

Tom = Cat()   #实例化一只叫做Tom的猫
Jerry = Rat()  # 实例化一只叫做Jerry的老鼠
Bobo = Monkey()   # 实例化一只叫做Bobo的猴子

print('猫的攻击力是：')
print(Tom.attack)

Tom.fight_buff(Jerry)
print('遇到老鼠，猫的攻击力是:')
print(Tom.attack)

Tom.fight_buff(Bobo)
print('遇到猴子，猫的攻击力是：')
print(Tom.attack)
>>>
猫的攻击力是：
100
遇到老鼠，猫的攻击力是:
150
遇到猴子，猫的攻击力是：
100