C++奥特曼打怪兽系列

简介: C++奥特曼打怪兽系列

题目描述

在前面实验的基础上,根据题目要求进行修改,实现打斗过程。

怪兽分为四种类型(定义四个类):

普通型怪兽(NMonster):攻击力是等级2倍,生命是10倍,金钱经验是10倍

攻击型怪兽(AMonster):攻击力是等级4倍,生命是5倍,金钱经验是10倍

防御型怪兽(DMonster):攻击力是等级1倍,生命是20倍,金钱经验是10倍

肉鸡型怪兽(SMonster):攻击力是等级1倍,生命是10倍,金钱经验是20倍

定义一个守护神类(Angel),该类定义怪兽或奥特曼的守护神,为怪兽或奥特曼提供帮助。守护神等级为所守护对象的等级(例如守护神a1守护等级为3的攻击型怪兽am1,则a1的等级也为3),攻击是等级的一半,无生命。怪兽的守护神金钱和经验都为等级的5倍。奥特曼的守护神金钱和经验为0,等级随守护对象升级而升级。
为四个怪兽类和奥特曼类添加守护神对象成员,使它们都成为复合类。
当奥特曼战胜怪兽后,将获得怪兽及其守护神的经验金钱。
修改奥特曼类和怪兽类相关成员函数,实现守护神类与它们的关系,具体如下:

奥特曼,守护神为它攻击攻击型怪兽时,加1点攻击力,而在它攻击防御型怪兽时,加2点攻击力,在获得肉鸡型怪兽的金钱和经验时,翻倍(获得怪兽的经验和金钱翻倍)。

普通型怪兽和肉鸡型怪兽,无守护神。

攻击型怪兽,守护神为它在攻击奥特曼时,也打一次,使奥特曼除了受到怪兽攻击,还将将受到守护神攻击力的伤害。

防御型怪兽,守护神为它受到奥特曼攻击时,将生命损失减半。


outman(奥特曼类对象)这个热血骚年总是叫嚷“一个打十个”,叫的老天爷都不耐烦了。这次outman傻眼了,是一个打4个。现在让我们来为outman欢呼吧,围观吧(记得带上板凳瓜子和鸡蛋,不好看的话就扔扔)。

请在main函数中实现如下架构

while (t--)  //每个实例就是奥特曼与个怪兽的战斗
    {
         //输入奥特曼等级值,利用等级值,声明一个奥特曼对象并初始化。
         //输出奥特曼状态,调用display方法,每行输出一个
         //输入个怪兽的等级,依次为普通型怪兽、肉鸡型怪兽、防御型怪兽、攻击型怪兽,保存在数组mgrad[4]中
         //创建种类型怪兽对象并利用等级值mgrad初始化。
         //输出每个怪兽的状态,调用display方法,每行输出一个
         //设置战斗标志flag为true,与每个怪兽的战斗结果winflag1=0,winflag2=0,winflag3=0,winflag4=0。
         //启动战斗循环,具体如下:
             while(flag) //4个怪兽群殴奥特曼
             {  
                  //奥特曼攻击每个怪兽1次
                  if (如果怪兽i没死)  //如果怪兽i没死,怪兽i攻击奥特曼,注意:只要没死的怪兽,都攻击奥特曼次。
                  {  
                      //怪兽i反击1次
                      if (奥特曼不逃跑)     //如果奥特曼不逃跑,用奥特曼生命来判断
                      //奥特曼回血,在方法中判断是否需要加血
                      else
                      {   //奥特曼逃跑,设置逃跑标志eflag为true,并输出"lose"并回车
                          //输出奥特曼状态,调用display方法                           
                          //设置flag为false,停止战斗
                      }
                  }
                  else if(怪兽是这一轮死的)//如果怪兽这一轮死了
                  {  
                      //奥特曼胜利,并输出"win"并回车
                      //奥特曼升级
                      //输出奥特曼状态,调用display方法
                      //设置打赢标记winflagi为true
                  }
                  if(所有怪兽都死了){//所有怪兽都死了,用个打赢标记判断
                      //结束战斗,设置flag为false,并输出“win all”
                  }
             }//end of while flag

输入

第1行输入t表示有t个测试实例

对于每个测试实例,首行先输入奥特曼等级

接着4行依次输入普通型、肉鸡型、防御型、攻击型怪兽的等级

输出

输出奥特曼和每个怪兽的战斗结果,具体要求参考程序框架

样例输入

2
5
3
3
3
3
5
10
10
10
10

样例输出

rank=5 hp=50 damage=15 exp=0 money=50
rank=3 hp=30 damage=6 exp=30 money=30
rank=3 hp=30 damage=3 exp=60 money=60
rank=3 hp=60 damage=3 exp=30 money=30
rank=3 hp=15 damage=12 exp=30 money=30
win
rank=5 hp=45 damage=15 exp=45 money=95
win
rank=6 hp=60 damage=18 exp=25 money=125
win
rank=8 hp=80 damage=24 exp=15 money=245
win
rank=8 hp=76 damage=24 exp=60 money=290
win all
rank=5 hp=50 damage=15 exp=0 money=50
rank=10 hp=100 damage=20 exp=100 money=100
rank=10 hp=100 damage=10 exp=200 money=200
rank=10 hp=200 damage=10 exp=100 money=100
rank=10 hp=50 damage=40 exp=100 money=100
lose
rank=5 hp=8 damage=15 exp=0 money=0
#include <iostream>
#include<cstdlib>
using namespace std;
// dcs守护神
class Angle {
private:
    int rank, money, exp, damage;
public:
    Angle() {};
    void angle_monster(int r) {
        rank = r; damage = rank / 2; exp = rank*5; money = rank*5;
    }
    int getmoney() { return money; }
    int getexp() { return exp; }
    int getdamage() { return damage; }
};
//奥特曼类的界面
class Ultraman {
private:
    int rank, exp, hp, damage, money;
    Angle angle_outman;
public:
    Ultraman() {};
    Ultraman(int a);
    ~Ultraman();
    int getHp() { return hp; };
    int getexp() { return exp; };
    int getdamage() { return damage; };
    int getmoney() { return money; };
    int getrank() { return rank; };
    void display();
    void escape();
    int attack();
    void attacked(int dam);
    void restore();
    void win(int ex, int m);
    void allwin();
    void upgrade();
};
// .......
//怪兽类的界面
class Monster {
public://考虑到后面要用继承,所以把所有属性设为public
    int rank, hp, damage, money, exp;
    Monster() {};
    Monster(int b);
    int fightback() { return damage; };
    void attacked(int dam);
    void display();
    int getHp() { return hp; };
    int getMoney() { return money; };
    int getExp() { return exp; };
};
// .......
//这里开始写类的实现代码
//奥特曼类的实现
Ultraman::Ultraman(int a) {
    rank = a; hp = rank * 10; damage = rank * 3; money = rank * 10; exp = 0;
}
Ultraman::~Ultraman() {
}
void Ultraman::display() {
    cout << "rank=" << rank << " hp=" << hp << " damage=" << damage << " exp=" << exp << " money=" << money << endl;
};
void Ultraman::escape() {
    money = 0;
    cout << "lose" << endl;
};
int Ultraman::attack() {
    //返回伤害值
    return damage;
};
void Ultraman::attacked(int dam) {
    hp -= dam / 2;
};
void Ultraman::restore() {
    while (hp < (rank * 10)) {
        if (money >= 10) {
            hp++; money -= 10;
        }
        else break;
    }
};
void Ultraman::win(int ex, int m) {
    exp += ex, money += m;
    cout << "win" << endl;
};
void Ultraman::allwin() {
    cout << "win all" << endl;
}
void Ultraman::upgrade() {
    while (exp >= (rank * 10)) {
        exp -= (rank * 10); rank++; hp = rank * 10; damage = rank * 3;
    }
};
//怪兽类的实现
Monster::Monster(int b) {
    rank = b; hp = rank * 20; damage = rank * 2; money = rank * 10; exp = rank * 10;
}
void Monster::attacked(int dam) {
    hp -= dam;
}
void Monster::display() {
    cout << "rank=" << rank << " hp=" << hp << " damage=" << damage << " exp=" << exp << " money=" << money << endl;
 }
class NMonster :public Monster {
public:
    NMonster(int b) {
        rank = b; hp = rank * 10; damage = rank * 2; money = rank * 10; exp = rank * 10;
    }
};
class AMonster :public Monster {
public:
    Angle angle;
    AMonster(int b) {
        rank = b; hp = rank * 5; 
        angle.angle_monster(rank);
        damage = rank * 4;
        money = rank * 10; exp = rank * 10;
    }
};
class DMonster :public Monster {   
public:
    Angle angle;
    DMonster(int b) {
        rank = b; hp = rank * 20; damage = rank; 
        angle.angle_monster(rank);
        money = rank * 10 ; exp = rank * 10 ;
    }
};
class SMonster :public Monster {
public:
    SMonster(int b) {
        rank = b; hp = rank * 10; damage = rank ; money = rank * 20; exp = rank * 20;
    }
};
//下面是测试主程序
int main()
{
    int t; cin >> t;
    while (t--) {
        int f[4] = { 0 }; for (int m = 0; m < 4; m++) { f[m] = 1; }
        int* ip = new int[5];
        for (int i = 0; i < 5; i++) cin >> ip[i];
        Ultraman u(ip[0]);   NMonster oa(ip[1]); SMonster ob(ip[2]);   DMonster oc(ip[3]); AMonster od(ip[4]);
        delete []ip;
        u.display();    oa.display();    ob.display();    oc.display();   od.display();
        bool flag = true;
        int tem = 0;
        while (flag) {
            int damage = u.getdamage();
            if(f[0]==1) oa.attacked(damage);
            if(f[1]==1) ob.attacked(damage); 
            if(f[2]==1) oc.attacked((damage+2)/2); 
            if(f[3]==1) od.attacked(damage+1);
            if (oa.getHp() > 0) {
                u.attacked(oa.fightback());
                if ((u.getHp() > 10) && (u.getHp() < u.getrank() * 5)) {
                    u.restore();
                }
                else if (u.getHp() <= 10) {
                    u.escape(); u.display(); flag = false;
                }
            }
            else if ((oa.getHp() <= 0) &&(f[0]==1)) {
                u.win(oa.getExp(), oa.getMoney()); u.upgrade(); u.display(); tem++; f[0] = 0;
            }
            if (ob.getHp() > 0) {
                u.attacked(ob.fightback());
                if ((u.getHp() > 10) && (u.getHp() < u.getrank() * 5)) {
                    u.restore();
                }
                else if (u.getHp() <= 10) {
                    u.escape(); u.display(); break;
                }
            }
            else if ((ob.getHp() <= 0)&&(f[1]==1)) {
                u.win((ob.getExp() * 2), (ob.getMoney() * 2)); u.upgrade(); u.display(); tem++; f[1] = 0;
            }
             if (oc.getHp() > 0) {
                u.attacked(oc.fightback());
                if ((u.getHp() > 10) && (u.getHp() < u.getrank() * 5)) {
                    u.restore();
                }
                else if (u.getHp() <= 10) {
                    u.escape(); u.display();break;
                }
            }
            else if ((oc.getHp() <= 0)&&(f[2]==1)) {
                 u.win(oc.getExp()+oc.angle.getexp(), oc.getMoney()+oc.angle.getmoney()); u.upgrade(); u.display(); tem++; f[2] = 0;
            }
             if (od.getHp() > 0) {
                 u.attacked(od.fightback() + od.angle.getdamage());
                 if ((u.getHp() > 10) && (u.getHp() < u.getrank() * 5)) {
                     u.restore();
                 }
                 else if (u.getHp() <= 10) {
                     u.escape(); u.display(); break;
                 }
             }
             else if ((od.getHp() <= 0)&&(f[3]==1)) {
                 u.win((od.getExp() + od.angle.getexp()), (od.getMoney() + od.angle.getmoney()));    u.upgrade();   u.display();     tem++; f[3] = 0;
             }
             if (tem == 4) {
                 flag = false;  tem = 0;
                 u.allwin();
            }
        }
    }
    return 0;
}
相关文章
|
机器学习/深度学习 Python
乌鸦喝水之谜
乌鸦喝水之谜
139 0
|
消息中间件
【中秋特辑】嫦娥妹妹,你别着急~
今天为大家带来一个小故事,是关于嫦娥和吴刚的爱情故事,想知道吴刚是怎样将情愫传递给嫦娥的吗?让我们一起一探究竟吧~
230 0
【中秋特辑】嫦娥妹妹,你别着急~
|
消息中间件
【中秋特辑】嫦娥妹妹,你别着急~
今天为大家带来一个小故事,是关于嫦娥和吴刚的爱情故事,想知道吴刚是怎样将情愫传递给嫦娥的吗?让我们一起一探究竟吧~
【中秋特辑】嫦娥妹妹,你别着急~
如何在公共场合收拾熊孩子
首先,我要反驳一种流行的错误观点,就是认为孩子还小,还没有规则意识,所以孩子熊就让他们熊。这是错误的。3岁的孩子已经可以明白,承诺和合作的意义了,已经可以发展出合作精神了。
1161 0