文档章节

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

o
 osc_h4tvmq2d
发布于 07/01 16:09
字数 2307
阅读 44
收藏 0

精选30+云产品,助力企业轻松上云!>>>

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

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

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

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

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

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

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

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

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

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

奥特曼,守护神为它攻击攻击型怪兽时,加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
把般配打在公屏上
在这里插入图片描述


o
粉丝 0
博文 58
码字总数 0
作品 0
私信 提问
加载中
请先登录后再评论。
C++ 奥特曼打怪兽之类的应用(系列3)

题目描述 在前面实验的基础上,根据题目要求进行修改,实现打斗过程。 怪兽分为四种类型(定义四个类): 普通型怪兽(NMonster):攻击力是等级2倍,生命是10倍,金钱经验是10倍 攻击型怪兽(...

box_怪
06/30
0
0
C++ 奥特曼打怪兽之类的实现(系列2)

题目描述 在实验《类定义》的基础,改进并实现游戏中的两个类:奥特曼类和怪兽类。使得两个类更加接近实际要求。 奥特曼说明如下: 为每个属性设置get方法,注意奥特曼所有属性都需要 初始化...

box_怪
06/30
0
0
C++ 奥特曼打怪兽之类的实现(系列2)

题目描述 在实验《类定义》的基础,改进并实现游戏中的两个类:奥特曼类和怪兽类。使得两个类更加接近实际要求。 奥特曼说明如下: 为每个属性设置get方法,注意奥特曼所有属性都需要 初始化...

osc_eqcu0796
07/01
4
0
C++ 奥特曼打怪兽之类的实现(系列2)

  题目描述   在实验《类定义》的基础,改进并实现游戏中的两个类:奥特曼类和怪兽类。使得两个类更加接近实际要求。   奥特曼说明如下:   为每个属性设置get方法,注意奥特曼所有属...

开源仔
06/30
7
0
游戏开发视频教程_基于MFC设计的MINI快跑游戏

基于MFC设计的MINI快跑游戏(游戏开发、MFC精讲、线程与进程通信) 课程分类:游戏开发 适合人群:初级 课时数量:36课时 用到技术:MFC涉及项目:MINI快跑游戏 咨询QQ:1840215592 游戏开发视...

mianhuatang
2014/12/19
48
0

没有更多内容

加载失败,请刷新页面

加载更多

测试工程师需要了解的shell变量知识

顾老师安全测试新课,报名地址: http://www.hbz100.com/pc/course/courseInfo.do?courseId=182320200226121405459。疫情期间,您在注意身体安全的同时,关注身体安全了吗?500元工作几天的薪...

啄木鸟顾老师
04/15
13
0
前端面试开源项目清单(github仓库,个人网站都有)

 复习前端面试的知识,是为了巩固前端的基础知识,最重要的还是平时的积累! ” 开源项目 https://github.com/InterviewMap/CS-Interview-Knowledge-Map 建立最好的面试地图。目前的内容包...

Fe-frank
05/11
12
0
【Flutter 专题】33 自定义 View 之 Canvas (一)

和尚最近在学习自定义 View,刚了解了一下 Paint 画笔的神奇之处,现在学习一下 Canvas 画布的神秘之处。Flutter 提供了众多的绘制方法,和尚接触不深,尽量都尝试一下。 Canvas 画布 drawCo...

阿策
2019/02/26
15
0
程序员,有需求做需求,有bug改bug,有什么好生气的呢?

对哦,我有什么好生气的呢! 本文分享自微信公众号 - WriteSimpleDemo(this_is_a_wechat)。 如有侵权,请联系 support@oschina.cn 删除。 本文参与“OSC源创计划”,欢迎正在阅读的你也加入...

PedroQin
2019/10/25
8
0
[从0到1搭建ABP微服务] - 搭建授权服务

一、简介 授权中心是微服务架构中最为核心重要的环节,不仅为web、app等客户端提供身份授权服务,还对其他微服务提供身份认证服务。ABP微服务架构中使用identityServer4框架进行身份管理,并...

osc_g91p39eg
25分钟前
14
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部