C++练习_实现RPG游戏角色创建

角色扮演游戏

要求

角色：名字，血量，攻击，防御。攻击方法，伤害=攻击-防御，血量为0则死亡不可再攻击

法师类：

• 添加法伤属性，此属性对伤害造成150%修正
• 增加魔法属性，攻击时消耗10点魔法保持150%法伤，若魔法不够则25%法伤

战士类：

• 添加减伤属性，此属性对伤害造成75%修正
• 增加怒气属性，怒气0-100对应减伤100-50。受到伤害则25%转换为怒气，向下调整

小偷类：

• 增加躲避几率30%, 攻击成功则积攒能量，能量等于5则2倍暴击

每个角色固定两个技能：
技能1：指向型技能
法师：消耗20点魔法造成200%伤害
战士：消耗一半怒气造成(200+怒气*2)%伤害
盗贼：消耗5点能量造成500%伤害

技能2：增益型技能
法师：消耗20点魔法回复40%血量
战士：消耗全部怒气转换为血量
盗贼：消耗5点能量造成500%伤害

对战接口，1对1,互殴至死

思路

1. 创建Role基类，包含血量，攻击，防御。 包含攻击方式接口，受击方式接口，攻击判断接口，组成一个attack()函数
2. 创建战士、法师、盗贼等派生类，各自具有不同派生属性，不同的攻击方式、受击方式、攻击判断
3. 在各角色内创建技能函数指针数组，根据输入的数字来决定使用何种攻击方式。
   使用类成员函数指针数组的方法：

//创建技能函数指针数组
void ( Mage::*skill[3])(double&)={&Mage::default_set, &Mage::battle_skill, &Mage::heal_skill};

//调用函数
(this->*skill[i])(damage);

4. 对战接口使用基类指针调用派生类对象，实现多态

具体代码：

/*
 * roleplay.cxx
 * 
 *  角色：名字，血量，攻击，防御。攻击方法，伤害=攻击-防御，血量为0则死亡不可再攻击
 * 
 * 法师类：添加法伤属性，此属性对伤害造成150%修正
 * 增加魔法属性，攻击时消耗10点魔法保持150%法伤，若魔法不够则25%法伤
 * 
 * 战士类：添加减伤属性，此属性对伤害造成75%修正
 * 增加怒气属性，怒气0-100对应减伤100-50。受到伤害则25%转换为怒气，向下调整
 * 
 * 小偷类：增加躲避几率30%, 攻击成功则积攒能量，能量等于5则2倍暴击
 * 
 * 每个角色固定两个技能：
 * 技能1：指向型技能
 * 	法师：消耗20点魔法造成300%伤害
 * 	战士：消耗一半怒气造成(200+怒气*2)%伤害
 * 	盗贼：消耗5点能量造成500%伤害
 * 
 * 技能2：增益型技能
 * 	法师：消耗20点魔法回复40%血量
 * 	战士：消耗全部怒气转换为血量
 *   	盗贼：消耗5点能量造成500%伤害
 * 
 * 对战接口，1对1
 */


#include <iostream>
#include <string>
#include <cstdlib>
using namespace std;

class Role
{
	protected:
		string name;
		
		double HP;
		double ATK;
		double DEF;
		
	public:
		Role() :name(""),HP(0),ATK(0),DEF(0){}
		
		Role(string na, double hp, double atk, double def)
			:name(na),HP(hp),ATK(atk),DEF(def)
		{}
		
		inline string getname()const{return name;}
		inline double getHP()const{return HP;}
		inline double getATK()const{return ATK;}
		inline double getDEF()const{return DEF;}
		
		inline void setHP(double hp){HP = hp>0? hp : 0 ;}
		inline void setATK(double atk){ATK= atk>0? atk : 0 ;}
		inline void setDEF(double def){DEF=def>0? def : 0 ;}
		
		//-------------------------------------------------------------------------
		bool if_dead(){
			return HP<=0;
		}
		
		virtual void setDamage(double& damage, int i)	//攻击方设置伤害
		{
			damage = this->ATK;
			return ;
		}
		
		virtual void getHurt(double& damage)	//挨打方设置伤害
		{
			damage -= this->DEF;
			return;
		}
		
		virtual void deal(double& damage)
		{
			return;
		}
		
		
		 double attack( Role& role, int i=0){
			double damage=0;
			
			setDamage(damage,i);
			role.getHurt(damage);
			deal(damage);
			
			if( damage>=role.getHP() ) role.setHP(0);
			else if(damage<0) return -1;
			else role.setHP(role.getHP()-damage);
			
			return damage;
		}
		
};

class Mage :  public Role
{
	private:
		double spell; //魔法加成
		int MP; //魔力槽
		
	public:
		Mage() :Role() {}
	
		Mage(string na, double hp=100, double atk=20, double def=5, double sp=150, int mp=100)
			:Role(na, hp, atk, def),spell(sp),MP(mp)
		{}
	
		 
		 void default_set(double& damage)
		{
			if(MP<=0) spell = 25;	//当魔力消耗完则魔法加成25%
			 damage = ((this->spell / 100)+1)*this->ATK ;
			if(MP>0)MP -= 10;	//每次攻击消耗10点魔力
			//cout<<"MP: "<<MP<<" damage: "<<damage<<endl;
			return ;
		}
		 void battle_skill(double& damage)
		{
			damage=100;
			//cout<<"MP: "<<MP<<" damage: "<<damage<<endl;
			return ;
		}
		 void heal_skill(double& damage)
		{
			HP= HP+20>100? HP : HP+20;
			return ;
		}
		void ( Mage::*skill[3])(double&)={&Mage::default_set, &Mage::battle_skill, &Mage::heal_skill};

		void setDamage(double& damage,int i)
		{
			(this->*skill[i])(damage);
			return ;
		}
};

class Worrior :  public Role
{
	private:
		double redu; //减伤
		int AP;	//怒气
	public:
		Worrior() :Role() {}
	
		Worrior(string na, double hp=100, double atk=20, double def=10, double re=0)
			:Role(na, hp, atk, def),redu(re),AP(0)
		{}
		
		 void getHurt(double& damage)
		{
			if(AP<100)AP += damage*0.25; else AP = 100;
			redu += AP/2;
			if(redu>90)redu=90;
			damage *= (1 - redu/100) ;
			damage -= this->DEF;
		}
};

class Thief :  public Role
{
	private:
		int miss_rate;
		int energe;
	public:
		Thief() :Role() {}
	
		Thief(string na, double hp=100, double atk=20, double def=10, int miss=30)
			:Role(na, hp, atk, def),miss_rate(miss),energe(0)
		{}
		
		 void setDamage(double& damage, int i)
		{
			damage = this->ATK;
			if(energe==5){
				damage += this->ATK;
				energe=0;
			}
			return ;
		}
		 void getHurt(double& damage)
		{
			if( rand()%100 < miss_rate ){damage=0;return;}
			damage -= this->DEF;
		}
		 void deal(double& damage)
		{
			if(damage>1)if(energe<5)energe+=1;
			cout<<"energe: "<<energe<<" ";
			return;
		}
};

void fight_res(Role& role1, Role& role2,int skill=0)
{
	cout<<"fight start!\n";
	while(1){
		
		double damage = role1.attack(role2,skill);
		cout<< role1.getname() <<" hurt "<< role2.getname();
		cout<<" by "<< damage <<" points blood \n";
		cout<< role2.getname() <<" left "<< role2.getHP() <<endl;
		
		if(damage<0) {
			cout<<"cannot win!\n";
			break;
		}
		
		if(role1.if_dead()){
			cout<< role1.getname() <<" is dead.\n";
			break;
		}
		if(role2.if_dead()){
			cout<< role2.getname() <<" is dead.\n";
			break;
		}
	}
}

int main(int argc, char **argv)
{
	Mage mage("mage");
	Worrior wor("wor");
	Thief thief1("thief1");
	Thief thief2("thief2");
	
	Role& role1 = mage;
	Role& role2 = wor;
	
	fight_res(role1,role2,1);
	return 0;
}