题目描述
在前面实验的基础上，根据题目要求进行修改，实现打斗过程。
- 怪兽分为四种类型(定义四个类)：
普通型怪兽（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 <cstring>
using namespace std;
class Angel {
private:
int rank; // 等级
int damage; //攻击力
int exp; //经验
int money; //钱
public:
Angel(int,int,int);
};
class Ultraman {
private:
int rank; // 等级
int hp; //生命值
int damage; //攻击力
int exp; //经验
int money; //钱
public:
Ultraman(int);
void display(); //展示实力
void escape(); //逃跑
void attacked(int); //被攻击
void restore(); //补血
void win(int,int); //胜利
void upgrade(); //升级
int get_rank();
int get_hp();
int get_damage();
int get_exp();
int get_money();
};
class Monster {
protected:
int rank; // 等级
int hp; //生命值
int damage; //攻击力
int exp; //经验
int money; //钱
public:
void attacked(int); //被攻击
int get_rank();
int get_hp();
int get_damage();
int get_exp();
int get_money();
void display();
};
class NMonster:public Monster {
public:
NMonster(int);
};
class AMonster:public Monster {
private:
Angel A_Angel;
public:
AMonster(int);
};
class DMonster:public Monster {
private:
Angel D_Angel;
public:
DMonster(int);
};
class SMonster:public Monster {
public:
SMonster(int);
};
Angel::Angel(int a,int m=0,int e=0) {
rank=a;
damage=a/2;
exp=e;
money=m;
}
NMonster::NMonster(int a) {
rank=a;
damage=2*a;
hp=a*10;
exp=a*10;
money=10*a;
}
AMonster::AMonster(int a):A_Angel(a,a*5,a*5) {
rank=a;
damage=4*a;
hp=a*5;
exp=a*10;
money=10*a;
}
DMonster::DMonster(int a):D_Angel(a,a*5,a*5) {
rank=a;
damage=1*a;
hp=a*20;
exp=a*10;
money=10*a;
}
SMonster::SMonster(int a) {
rank=a;
damage=1*a;
hp=a*10;
exp=a*20;
money=20*a;
}
Ultraman::Ultraman(int a) {
rank=a;
hp=10*a;
exp=0;
damage=3*a;
money=10*a;
}
int Ultraman::get_rank() {
return rank;
}
int Ultraman::get_hp() {
return hp;
}
int Ultraman::get_damage() {
return damage;
}
int Ultraman::get_exp() {
return exp;
}
int Ultraman::get_money() {
return money;
}
//当生命不超过10点时，奥特曼将逃跑，逃跑将损失所有金钱
void Ultraman::escape() {
money=0;
cout<<"lose"<<endl;
}
void Ultraman::win(int _exp,int _money) {
cout<<"win"<<endl;
exp+=_exp;
money+=_money;
upgrade();
}
void Ultraman::attacked(int monster_damage) {
hp-=monster_damage/2;
}
void Ultraman::upgrade() {
while(exp>=10*rank) {
exp-=10*rank;
rank++;
hp=rank*10;
damage=rank*3;
}
}
void Ultraman::restore() {
while(hp<5*rank&&money>=10) {
hp++;
money-=10;
}
}
void Ultraman::display() {
cout<<"rank="<<rank;
cout<<" hp="<<hp;
cout<<" damage="<<damage;
cout<<" exp="<<exp;
cout<<" money="<<money<<endl;
}
int Monster::get_rank() {
return rank;
}
int Monster::get_hp() {
return hp;
}
int Monster::get_damage() {
return damage;
}
int Monster::get_exp() {
return exp;
}
int Monster::get_money() {
return money;
}
void Monster::attacked(int ultraman_damage) {
hp-=ultraman_damage;
}
void Monster::display() {
cout<<"rank="<<rank;
cout<<" hp="<<hp;
cout<<" damage="<<damage;
cout<<" exp="<<exp;
cout<<" money="<<money<<endl;
}
int main() {
int lev,t,mgrad[4];
bool flag,winflag1,winflag2,winflag3,winflag4;
int i=0,j=0,k=0,l=0; //判断怪兽是否本回合死亡
cin>>t;
while(t--) {
cin>>lev;
Ultraman Tiga(lev);
Tiga.display();
for(int x=0; x<4; x++) {
cin>>mgrad[x];
}
NMonster n1(mgrad[0]);
SMonster rookie(mgrad[1]);
DMonster d1(mgrad[2]);
AMonster a1(mgrad[3]);
n1.display();
rookie.display();
d1.display();
a1.display();
flag=1;
winflag1=0;
winflag2=0;
winflag3=0;
winflag4=0;
while(flag) {
n1.attacked(Tiga.get_damage());
rookie.attacked(Tiga.get_damage());
d1.attacked((Tiga.get_damage()+2)/2); //守护神为它攻击攻击型怪兽时，加1点攻击力
a1.attacked(Tiga.get_damage()+1); //攻击防御型怪兽时，加2点攻击力,但防御型怪兽，守护神为它受到奥特曼攻击时，将生命损失减半。
if(n1.get_hp()>0) { //与普通怪兽的战斗
Tiga.attacked(n1.get_damage());
if(Tiga.get_hp()>10) {
if(Tiga.get_hp()<Tiga.get_rank()*5) {
Tiga.restore();
}
} else {
Tiga.escape();
Tiga.display();
flag=false;
}
} else if(i==0) {
Tiga.win(n1.get_exp(),n1.get_money());
Tiga.display();
i=1; //让下一次循环不会重复获得这只怪兽的经验和金币
winflag1=1;
}
if(rookie.get_hp()>0) { //与肉鸡怪兽战斗
Tiga.attacked(rookie.get_damage());
if(Tiga.get_hp()>10) {
if(Tiga.get_hp()<Tiga.get_rank()*5) {
Tiga.restore();
}
} else {
Tiga.escape();
Tiga.display();
flag=false;
}
} else if(j==0) {
Tiga.win(rookie.get_exp()*2,rookie.get_money()*2); //双倍金币经验
Tiga.display();
j=1; //让下一次循环不会重复获得这只怪兽的经验和金币
winflag2=1;
}
if(d1.get_hp()>0) { //与防御怪兽战斗
Tiga.attacked(d1.get_damage());
if(Tiga.get_hp()>10) {
if(Tiga.get_hp()<Tiga.get_rank()*5) {
Tiga.restore();
}
} else {
Tiga.escape();
Tiga.display();
flag=false;
}
} else if(k==0) {
Tiga.win(d1.get_exp()+d1.get_rank()*5,d1.get_money()+d1.get_rank()*5);//奥特曼还会获得怪兽守护神的exp和money
Tiga.display();
k=1; //让下一次循环不会重复获得这只怪兽的经验和金币
winflag3=1;
}
if(a1.get_hp()>0) { //与攻击怪兽战斗
Tiga.attacked((a1.get_damage()+a1.get_rank()/2)); // 奥特曼除了受到怪兽攻击，还将将受到攻击性怪兽的守护神攻击力的伤害。
if(Tiga.get_hp()>10) {
if(Tiga.get_hp()<Tiga.get_rank()*5) {
Tiga.restore();
}
} else {
Tiga.escape();
Tiga.display();
flag=false;
}
} else if(l==0) {
Tiga.win(a1.get_exp()+a1.get_rank()*5,a1.get_money()+a1.get_rank()*5); //奥特曼还会获得怪兽守护神的exp和money
Tiga.display();
l=1; //让下一次循环不会重复获得这只怪兽的经验和金币
winflag4=1;
}
if(winflag1&&winflag2&&winflag3&&winflag4) {
flag=false;
cout<<"win all"<<endl;
}
}
}
}
夹带私活
shout out to Rookie
把般配打在公屏上