C++ 奥特曼打怪兽之类的应用（系列3）

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

1. 怪兽分为四种类型(定义四个类)：

普通型怪兽（NMonster）：攻击力是等级2倍，生命是10倍，金钱经验是10倍

攻击型怪兽（AMonster）：攻击力是等级4倍，生命是5倍，金钱经验是10倍

防御型怪兽（DMonster）：攻击力是等级1倍，生命是20倍，金钱经验是10倍

肉鸡型怪兽（SMonster）：攻击力是等级1倍，生命是10倍，金钱经验是20倍

2. 定义一个守护神类（Angel），该类定义怪兽或奥特曼的守护神，为怪兽或奥特曼提供帮助。守护神等级为所守护对象的等级（例如守护神a1守护等级为3的攻击型怪兽am1，则a1的等级也为3），攻击是等级的一半，无生命。怪兽的守护神金钱和经验都为等级的5倍。奥特曼的守护神金钱和经验为0，等级随守护对象升级而升级。

3. 为四个怪兽类和奥特曼类添加守护神对象成员，使它们都成为复合类。

4. 当奥特曼战胜怪兽后，将获得怪兽及其守护神的经验金钱。

5. 修改奥特曼类和怪兽类相关成员函数，实现守护神类与它们的关系，具体如下：

奥特曼，守护神为它攻击攻击型怪兽时，加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
#include 
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
把般配打在公屏上