skillinfo.h

天之炼狱1服务器端源文件游戏服务端不完整

//////////////////////////////////////////////////////////////////////////////
// Filename    : SkillInfo.h
// Written By  : beowulf
// Description : 
//////////////////////////////////////////////////////////////////////////////

#ifndef __SKILL_INFO_H__
#define __SKILL_INFO_H__

#include "Exception.h"
#include "Types.h"
#include "Slayer.h"
#include <bitset>
#include <list>

class Ousters;

enum {
	SKILL_PROPERTY_TYPE_MELEE = 0,
	SKILL_PROPERTY_TYPE_MAGIC = 1,
	SKILL_PROPERTY_TYPE_PHYSIC = 2,

	SKILL_PROPERTY_TYPE_MAX
};


//////////////////////////////////////////////////////////////////////////////
// Class SkillInfo
//////////////////////////////////////////////////////////////////////////////

class SkillInfo 
{
public:
	SkillInfo();
	~SkillInfo();

public:
	uint getType() const { return m_Type; }
	void setType(uint type) { m_Type = type; }

	string getName() const { return m_Name ; }
	void setName(string name) { m_Name = name ; }

	uint getLevel() const { return m_Level; }
	void setLevel(uint level) { m_Level = level; }

	uint getMinDamage() const { return m_MinDamage; }
	void setMinDamage(uint mindam) { m_MinDamage = mindam ; }

	uint getMaxDamage() const { return m_MaxDamage; }
	void setMaxDamage(uint maxdam) { m_MaxDamage = maxdam; }

	uint getMinDelay() const { return m_MinDelay ; }
	void setMinDelay(uint mindelay) { m_MinDelay = mindelay; }

	uint getMaxDelay() const { return m_MaxDelay ; }
	void setMaxDelay(uint maxdelay) { m_MaxDelay = maxdelay; }

	uint getMinCastTime() const { return m_MinCastTime ; }
	void setMinCastTime(uint mincasttime) { m_MinCastTime = mincasttime ; }

	uint getMaxCastTime() const { return m_MaxCastTime ; }
	void setMaxCastTime(uint maxcasttime) { m_MaxCastTime = maxcasttime ; }

	int getMinDuration() const { return m_MinDuration ; }
	void setMinDuration(int minduration) { m_MinDuration = minduration ; }

	int getMaxDuration() const { return m_MaxDuration ; }
	void setMaxDuration(int maxduration) { m_MaxDuration = maxduration ; }

	uint getConsumeMP() const { return m_ConsumeMP; }
	void setConsumeMP(uint consumemp) { m_ConsumeMP = consumemp; }

	uint getRange() const { return m_MaxRange; }

	uint getMaxRange() const { return m_MaxRange ; }
	void setMaxRange(uint range) { m_MaxRange = range; }

	uint getMinRange() const { return m_MinRange ; }
	void setMinRange(uint range) { m_MinRange = range; }

	uint getTarget() const { return m_Target; }
	void setTarget(uint target) { m_Target = target ; }
	
	// 货肺款 滚怜阑 困秦.(钦媚柳 滚傈...)
	uint getSubSkill() const { return m_SubSkill; }
	void setSubSkill(uint subskill) { m_SubSkill = subskill; }

	uint getPoint() const { return m_Point ; }
	void setPoint(uint point) { m_Point = point; }
	
	BYTE getDomainType() const { return m_Domain; }
	void setDomainType(uint domain) { m_Domain = domain; }

	int getMagicDomain(void) const { return m_MagicDomain; }
	void setMagicDomain(int magic) { m_MagicDomain = magic; }

	int getElementalDomain(void) const { return m_ElementalDomain; }
	void setElementalDomain(int elemental) { m_ElementalDomain = elemental; }

	bool isMelee() const { return m_PropertyType.test(SKILL_PROPERTY_TYPE_MELEE); }
	void setMelee( bool bMelee )
	{
		( bMelee ? m_PropertyType.set( SKILL_PROPERTY_TYPE_MELEE )
		  		 : m_PropertyType.reset( SKILL_PROPERTY_TYPE_MELEE ) ); }

	bool isMagic() const { return m_PropertyType.test(SKILL_PROPERTY_TYPE_MAGIC); }
	void setMagic( bool bMagic ) 
	{
		( bMagic ? m_PropertyType.set( SKILL_PROPERTY_TYPE_MAGIC )
				 : m_PropertyType.reset( SKILL_PROPERTY_TYPE_MAGIC ) );
	}

	bool isPhysic() const { return m_PropertyType.test( SKILL_PROPERTY_TYPE_PHYSIC ); }
	void setPhysic( bool bPhysic )
	{ 
		( bPhysic ? m_PropertyType.set( SKILL_PROPERTY_TYPE_PHYSIC )
		  		  : m_PropertyType.reset( SKILL_PROPERTY_TYPE_PHYSIC ) );
	}

	// 硅快扁 困秦 鞘夸茄 胶懦 器牢飘
	int getSkillPoint() const { return m_SkillPoint; }
	void setSkillPoint( int skillPoint ) { m_SkillPoint = skillPoint; }

	// 胶懦 饭骇 诀 器牢飘
	int getLevelUpPoint() const { return m_LevelUpPoint; }
	void setLevelUpPoint( int levelUpPoint ) { m_LevelUpPoint = levelUpPoint; }

	// 捞傈俊 硅况具 且 胶懦甸
	void addRequireSkill( SkillType_t skillType ) { m_RequireSkills.push_back( skillType ); }
	list<SkillType_t>& getRequireSkills() { return m_RequireSkills; }

	////////////////////////////////////////////////////////////////////////////
	// 矫傈窍扁 困秦 鞘夸茄 炼扒甸. 酒快胶磐胶侩 
	////////////////////////////////////////////////////////////////////////////
	Elemental_t getRequireFire() const { return m_RequireFire; }
	Elemental_t getRequireWater() const { return m_RequireWater; }
	Elemental_t getRequireEarth() const { return m_RequireEarth; }
	Elemental_t getRequireWind() const { return m_RequireWind; }
	Elemental_t getRequireSum() const { return m_RequireSum; }

	ElementalType getRequireWristletElemental() const { return m_RequireWristletElemental; }
	ElementalType getRequireStone1Elemental() const { return m_RequireStone1Elemental; }
	ElementalType getRequireStone2Elemental() const { return m_RequireStone2Elemental; }
	ElementalType getRequireStone3Elemental() const { return m_RequireStone3Elemental; }
	ElementalType getRequireStone4Elemental() const { return m_RequireStone4Elemental; }

	void setRequireFire( Elemental_t require ) { m_RequireFire = require; }
	void setRequireWater( Elemental_t require ) { m_RequireWater = require; }
	void setRequireEarth( Elemental_t require ) { m_RequireEarth = require; }
	void setRequireWind( Elemental_t require ) { m_RequireWind = require; }
	void setRequireSum( Elemental_t require ) { m_RequireSum = require; }

	void setRequireWristletElemental( ElementalType require ) { m_RequireWristletElemental = require; }
	void setRequireStone1Elemental( ElementalType require ) { m_RequireStone1Elemental = require; }
	void setRequireStone2Elemental( ElementalType require ) { m_RequireStone2Elemental = require; }
	void setRequireStone3Elemental( ElementalType require ) { m_RequireStone3Elemental = require; }
	void setRequireStone4Elemental( ElementalType require ) { m_RequireStone4Elemental = require; }

	void setRequireSkill( const string& requireSkill );
	void setCondition( const string& condition );

	// toString
	string toString() const ;

private:
	uint   m_Type;        // Type
	string m_Name;        // Name
	uint   m_Level;       // m_Level
	uint   m_MinDamage;   // 弥家 单固瘤
	uint   m_MaxDamage;   // 弥措 单固瘤
	uint   m_MinDelay;    // 弥家 掉饭捞 
	uint   m_MaxDelay;    // 弥措 掉饭捞
	uint   m_MinCastTime; // 某胶泼 鸥烙.. 檬窜困
	uint   m_MaxCastTime; // 弥措 某胶泼 鸥烙

	// 弥家 瘤加矫埃
	// 弥措 弥家啊 备喊绝捞 弊成 瘤加矫埃父 乐绰 巴篮 弥家 瘤加矫埃俊辑 佬绢坷搁 等促.
	// 瘤加矫埃捞 0牢 巴篮 Instant, -1 篮 Long阑 狼固茄促.
	int m_MinDuration;

	// 弥措 瘤加矫埃
	int m_MaxDuration;

	// MP 家厚樊
	uint m_ConsumeMP;

	// 弥措 弥家 荤沥芭府, 矫具???
	uint m_MaxRange;
	uint m_MinRange;

	// 疙吝矫懦 荐 乐绰 鸥百狼 MoveType
	// 0x01 : burrowing
	// 0x02 : walking
	// 0x04 : flying
	uint m_Target;
	
	// 钦媚柳 滚怜阑 困秦..
	uint m_SubSkill;
	uint m_Point;

	BYTE m_Domain;

	// 付过狼 拌凯. 刀, 魂, 历林 殿殿
	int m_MagicDomain;

	// 沥飞 拌凯
	int m_ElementalDomain;

	// 鞘夸茄 胶懦 器牢飘
	int m_SkillPoint;
	int m_LevelUpPoint;

	// 捞傈俊 硅况具且 胶懦甸
	list<SkillType_t> m_RequireSkills;

	// 矫傈窍扁 困秦 鞘夸茄 炼扒甸
	// 酒快胶磐胶 侩
	Elemental_t m_RequireFire;
	Elemental_t m_RequireWater;
	Elemental_t m_RequireEarth;
	Elemental_t m_RequireWind;
	Elemental_t m_RequireSum;

	ElementalType m_RequireWristletElemental;
	ElementalType m_RequireStone1Elemental;
	ElementalType m_RequireStone2Elemental;
	ElementalType m_RequireStone3Elemental;
	ElementalType m_RequireStone4Elemental;

	bitset<SKILL_PROPERTY_TYPE_MAX> m_PropertyType;
};

//////////////////////////////////////////////////////////////////////////////
// Class SkillInfoManager
//////////////////////////////////////////////////////////////////////////////

class SkillInfoManager 
{
public:
	SkillInfoManager() throw();
	~SkillInfoManager() throw();

public:

	// initialize Manager
	void init() throw(Error);

	// void load() throw();
	void load() throw(Error);
	
	// Save to DB
	void save() throw(Error);

	// get SkillInfo
	SkillInfo* getSkillInfo(SkillType_t SkillType) const throw(NoSuchElementException, OutOfBoundException, Error);

	// add SkillInfo
	void addSkillInfo(SkillInfo* pSkillInfo) throw(DuplicatedException, Error);

	// get SkillType by LearnLevel
	// 泅犁狼 档皋牢 饭骇俊辑 硅匡 荐 乐绰 扁贱狼 鸥涝篮 绢恫 巴牢瘤 茫绰促.
	// 档皋牢狼 饭骇肺 舅 荐 乐瘤贩.
	SkillType_t getSkillTypeByLevel(SkillDomainType_t SkillDomain, Level_t Level) throw(OutOfBoundException);

	// 档皋牢狼 饭骇肺 弊 饭骇篮 绢恫 殿鞭俊 秦寸窍绰瘤 酒绰 窃荐.
	SkillGrade getGradeByDomainLevel(Level_t Level) throw(OutOfBoundException);

	// 泅犁 殿鞭俊辑 扁贱捞 绢蠢沥档 饭骇鳖瘤 棵扼哎 荐 乐绰瘤 舅酒 夯促.
	Level_t getLimitLevelByDomainGrade(SkillGrade Grade) throw(OutOfBoundException);

	// 泅犁 INT俊辑 MP 皑家樊阑 惶酒郴扁 困茄 窃荐.
	MP_t getdecreaseConsumeMP(Attr_t INT) { return m_decreaseConsumeMP[INT]; }

	// toString for Debug
	string toString() const throw();

private:
	uint         m_SkillCount;
	SkillInfo**  m_SkillInfoList;
	SkillType_t  m_SkillLevelMap[SKILL_DOMAIN_MAX][SLAYER_MAX_DOMAIN_LEVEL+1];
	SkillGrade   m_DomainGradeMap[SLAYER_MAX_DOMAIN_LEVEL+1];
	Level_t      m_LimitLevelMap[SKILL_GRADE_MAX + 1];
	MP_t         m_decreaseConsumeMP[300+1];
		
};

// Global Variable Definition
extern SkillInfoManager* g_pSkillInfoManager;

#endif	// __SKILL_INFO_MANAGER_H__