【python】奥特曼打小怪兽文字游戏

设计基本思路：

1. 设置一个抽象类($Fighter$)，用来初始化奥特曼与小怪兽的基本属性($name，hp$);同时设置一个抽象类方法($attack$)，奥特曼与小怪兽对象皆可重载该方法设置自己的攻击方法；设置一个$alive$函数用于判断对象的$hp$
2. 设置一个奥特曼类，继承自$Fighter$类，调用父类的初始化方法初始化奥特曼的$name$与$hp$属性，同时设置自己的属性$mp$(魔法值)；重载$attack$方法对小怪兽造成随机伤害(普通攻击)；依靠$mp$设置究极必杀技($huge$_ $attack$)以及魔法群体伤害($magic$_ $attack$)；设定普通攻击之后自动恢复一定的魔法值($resume$)
3. 设置一个小怪兽类，继承自$Fighter$类，调用父类的初始化方法初始化小怪兽的$name$与$hp$属性；重载$attack$方法对奥特曼造成随机伤害
4. 当某一方阵亡则退出游戏：奥特曼使用$alive$判断是否存活，设置方法($is$_ $any$_ $alive$)判断全体小怪兽是否存活
5. 每回合攻击选择一只存活的小怪兽：设置方法($select$_ $alive$ _$one$)用于选择存活的小怪兽
6. 每回合结束显示奥特曼与小怪兽的信息：设置方法($display$ _$info$)显示信息
7. 主体设置：(1)定义奥特曼与小怪兽对象，进行游戏；(2)首先选择一个活着的小怪兽并产生一个随机值，当随机值处于某个范围内，奥特曼采用普通攻击($attack$)攻击小怪兽；(3)随机值处于某个范围并且魔法值足够则触发魔法伤害，对全体小怪兽造成伤害，否则使用魔法失败；(4)随机值处于另一个范围且魔法值足够触发究极必杀技，否则使用普通攻击；(5)若选定的小怪兽攻击之后依然存活则回击奥特曼；(6)回合结束显示奥特曼与小怪兽信息；(7)当某一方阵亡则退出游戏，宣布某一方游戏胜利

实现：

1.需要使用抽象类与抽象方法，从$abc$模块导入$ABCMeta$以及$abstractmethod$包；需要使用随机值，从$random$模块导入$randint$以及$randrange$包

from abc import ABCMeta, abstractmethod
from random import randint, randrange

2.定义抽象类$Fighter$

class Fighter(object, metaclass=ABCMeta):
    """战斗者"""

    #通过__slots__魔法限定对象可以绑定的成员变量
    __slots__ = ('_name', '_hp')

    def __init__(self, name, hp):
        """初始化方法
        :param name: 名字
        :param hp: 生命值
        """

        self._name = name
        self._hp = hp

	#使用property装饰器定义getter以及setter方法
    @property
    def name(self):
        return self._name

    @property
    def hp(self):
        return self._hp

    @hp.setter
    def hp(self, hp):
        self._hp = hp if hp >= 0 else 0

    @property
    def alive(self):
        return self._hp > 0

	#抽象类方法
    @abstractmethod
    def attack(self, other):
        """攻击
        :param other: 被攻击的对象
        """
        pass

3.定义奥特曼($Ultraman$)类，继承自$Fighter$类

class Ultraman(Fighter):
    """奥特曼"""

    __slots__ = ('_name', '_hp', '_mp')

    def __init__(self, name, hp, mp):
        """初始化方法

        :param name: 名字
        :param hp: 生命值
        :param mp: 魔法值
        """

        super().__init__(name, hp)
        self._mp = mp

	#普通攻击
    def attack(self, other):
        other.hp -= randint(15, 25)

    def huge_attack(self, other):
        """究极必杀技（打掉对方至少50点或四分之三的血)

        :param other: 被攻击的对象

        :return: 使用成功返回True否则返回False
        """

        #放出大招，消耗50点魔法值造成伤害；魔法值不够则采用普通攻击
        if self._mp >= 50:
            self._mp -= 50
            injury = other.hp * 3 // 4
            injury = injury if injury >= 50 else 50
            other.hp -= injury
            return True
        else:
            self.attack(other)
            return False

    def magic_attack(self, others):
        """魔法攻击

        :param others: 被攻击的群体
        :return: 使用魔法成功返回True否则返回False
        """

        #释放魔法攻击，消耗20魔法点；魔法值不够则使用魔法失败
        if self._mp >= 20:
            self._mp -= 20
            for temp in others:
                if temp.alive:
                    temp.hp -= randint(10, 15)
            return True
        else:
            return False

    def resume(self):
        """恢复魔法值"""
        incr_point = randint(1, 10)
        self._mp += incr_point
        return incr_point

    #显示奥特曼个人信息
    def __str__(self):
        return '～～～%s奥特曼～～～\n' % self._name + \
            '生命值: %d\n' % self._hp + \
            '魔法值: %d\n' % self._mp

4.定义小怪兽($Monster$)类，继承自$Fighter$类

class Monster(Fighter):
    """小怪兽"""

    __slots__ = ('_name', '_hp')

    def attack(self, other):
        other.hp -= randint(10, 20)

    #显示小怪兽个人信息
    def __str__(self):
        return '～～～%s小怪兽～～～\n' % self._name + \
            '生命值: %d\n' % self._hp

5.判断全体小怪兽是否存活

def is_any_alive(monsters):
    """判断有没有小怪兽是活着的"""
    for monster in monsters:
        if monster.alive > 0:
            return True
    return False

6.选择一只活着的小怪兽

def select_alive_one(monsters):
    """选中一只活着的小怪兽"""
    monsters_len = len(monsters)
    while True:
        index = randrange(monsters_len)
        monster = monsters[index]
        if monster.alive > 0:
            return monster

7.显示奥特曼和小怪兽的信息

def display_info(ultraman, monsters):
    """显示奥特曼和小怪兽的信息"""
    print(ultraman)
    for monster in monsters:
        print(monster, end='')

8.主体逻辑

def main():
    u = Ultraman('花花', 1000, 120)
    m1 = Monster('狄仁杰', 250)
    m2 = Monster('李元芳', 500)
    m3 = Monster('王大锤', 750)
    ms = [m1, m2, m3]
    fight_round = 1
    while u.alive and is_any_alive(ms):
        print('=======第%02d回合======' % fight_round)
        m = select_alive_one(ms)
        skill = randint(1, 10)
        if skill <= 6:
            print('%s使用普通攻击打了%s.' % (u.name, m.name))
            u.attack(m)
            print('%s的魔法值恢复了%d点.' % (u.name, u.resume()))
        elif skill <= 9:  # 30%的概率使用魔法攻击(可能因魔法值不足而失败)
            if u.magic_attack(ms):
                print('%s使用了魔法攻击.' % u.name)
            else:
                print('%s使用魔法失败.' % u.name)
        else:  # 10%的概率使用究极必杀技(如果魔法值不足则使用普通攻击)
            if u.huge_attack(m):
                print('%s使用究极必杀技虐了%s.' % (u.name, m.name))
            else:
                print('%s使用普通攻击打了%s.' % (u.name, m.name))
                print('%s的魔法值恢复了%d点.' % (u.name, u.resume()))
        if m.alive > 0:  # 如果选中的小怪兽没有死就回击奥特曼
            print('%s回击了%s.' % (m.name, u.name))
            m.attack(u)
        display_info(u, ms)  # 每个回合结束后显示奥特曼和小怪兽的信息
        fight_round += 1
    print('\n========战斗结束!========\n')
    if u.alive > 0:
        print('%s奥特曼胜利!\n' % u.name)
    else:
        print('小怪兽胜利!\n')


if __name__ == '__main__':
    main()

测试：