面向对象基础

***面向对象：

1.把类封装好
2.处理类与类之间的关系

属性/方法的访问方式：
对象.属性/方法

self 关键字的用法：
作为方法的第一形参：
表示的当前类的一个对象，哪个对象调用，这个self表示的就是谁

访问当前类的属性：
访问当前类的方法：***

import random
import time
# 技能类
class Skill:
    def __init__(self,sk_name,sk_damage):
        # 技能名
        self.skill_name = sk_name
        # 技能伤害值
        self.skill_damage = sk_damage
class Hero_Dark:#黑暗主角
    def __init__(self,name,hp,damage,q,r):#初始化名字，生命值，伤害值，技能键q，r
        self.name = name
        self.hp = hp
        self.damage = damage
        self.skillQ = q
        self.skillR = r
    def attack(self,light_hero):    #攻击（光明主角）
        n = random.randint(1,2)
        if n == 1:
            self.attack_common(light_hero)      #普通伤害（光明主角）
        else:
            self.attack_skill(light_hero)       #技能伤害（光明主角）
    # 普通伤害
    def attack_common(self,light_hero):
        real_damage = self.damage + random.randint(5,20)    #现在伤害=随机伤害（5到20）
        light_hero.hp -= real_damage
        print(f'{self.name}普通攻击{light_hero.name}，{light_hero.name}损失生命值{real_damage},剩余生命值{light_hero.hp}')
    # 技能伤害
    def attack_skill(self, light_hero):
        n = random.randint(1,2)
        if n == 1:
            light_hero.hp -= self.skillQ.skill_damage
            print(f'{self.name}释放技能\033[1;34m{self.skillQ.skill_name}\033[0m，{light_hero.name}损失生命值{self.skillQ.skill_damage},剩余生命值{light_hero.hp}')
        else:
            light_hero.hp -= self.skillR.skill_damage
            print(
                f'{self.name}释放技能\033[1;32m{self.skillR.skill_name}\033[0m，{light_hero.name}损失生命值{self.skillR.skill_damage},剩余生命值{light_hero.hp}')

class Hero_Light:
    def __init__(self, name, hp, damage,r):
        self.name = name
        self.hp = hp
        self.damage = damage
        self.skillR=r
    def attack(self, dark_hero):
        n = random.randint(1,1)
        if n == 1:
            self.attack_common(dark_hero)
    # 普通伤害
    def attack_common(self, dark_hero):
        real_damage = random.randint(1,25)+self.damage
        dark_hero.hp -= real_damage
        print(f'{self.name}普通攻击{dark_hero.name}，{dark_hero.name}损失生命值{real_damage},剩余生命值{dark_hero.hp}')
    # 技能伤害
    def attack_skill(self,dark_hero):
        n = random.randint(1,1)
        if n==1:
            hero_dark.hp -= self.skillR.skill_damage
            print(f'{self.name}释放技能\033[1;38m{self.skillR.skill_name}\033[0m，{dark_hero}损失生命值{self.skillR.skill_damage},剩余生命值{dark_hero.hp}')
sk_Q = Skill('偷天换日',99)
sk_R = Skill('偷梁换柱',120)
# 创建对象
hero_dark = Hero_Dark('小怪兽',1000,20,sk_Q,sk_R)
hero_light = Hero_Light('奥特曼',850,30,sk_R)
# 持续性的互相伤害
count = 1

# print("\033[1;32m 字体颜色：深黄色\033[0m")
while True:
    print(f'第{count}回合')
    hero_light.attack(hero_dark)
    if hero_dark.hp <= 0:
        print(f'{hero_dark.name}输了')
        break
    hero_dark.attack(hero_light)
    if hero_light.hp <= 0:
        print(f'{hero_light.name}输了')
        break
    time.sleep(0.25)
    count += 1