monsterinfo.h

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

//////////////////////////////////////////////////////////////////////////////
// Filename    : MonsterInfo.h
// Written By  : 辫己刮
// Description :
//////////////////////////////////////////////////////////////////////////////

#ifndef __MONSTERINFO_H__
#define __MONSTERINFO_H__

#include "Types.h"
#include "Exception.h"
#include "Assert.h"
#include "Creature.h"
#include "MonsterSummonInfo.h"
#include "MonsterInfoTypes.h"
#include "Treasure.h"
#include <list>
#include <vector>
#include <hash_map>

// 阁胶磐 胶橇扼捞飘 辆幅 弥措 箭磊
const int MAX_SPRITE_TYPE = 200;

//////////////////////////////////////////////////////////////////////////////
// 阁胶磐啊 扁撅且 荐 乐绰 利狼 弥措 俺荐, 肚绰 利狼 府胶飘俊 立辟窍绰 牢郸胶
//////////////////////////////////////////////////////////////////////////////
enum EnemyPriority 
{
	ENEMY_PRIMARY = 1 ,
	ENEMY_SECONDARY ,
	ENEMY_THIRD ,
	ENEMY_FOURTH ,
	ENEMY_FIFTH ,
	ENEMY_SIXTH ,
	ENEMY_SEVENTH ,
	ENEMY_EIGHTH ,
	ENEMY_MAX
};


//////////////////////////////////////////////////////////////////////////////
// 利捞 咯矾疙老 锭, 穿备甫 刚历 傍拜窍绰啊?
//////////////////////////////////////////////////////////////////////////////
enum AttackOrder 
{
	ATTACK_FIRST,          // 力老 刚历 锭赴 仇何磐 傍拜
	ATTACK_LAST,           // 力老 唱吝俊 锭赴 仇 何磐 傍拜
	ATTACK_WEAKEST,        // 力老 距茄 仇何磐 傍拜
	ATTACK_STRONGEST,      // 力老 碍茄 仇何磐 傍拜
	ATTACK_CLOSEST,        // 力老 啊鳖款 仇 何磐 傍拜
	ATTACK_FAREST,         // 力老 刚 仇 何磐 傍拜
	ATTACK_FIGHTER,        // 傈荤 刚历 傍拜
	ATTACK_PRIEST,         // 己流磊 刚历 傍拜
	ATTACK_GUNNER,         // 扒呈 刚历 傍拜
	ATTACK_MAX
};

const string AttackOrder2String[] = 
{
	"ATTACK_FIRST" ,
	"ATTACK_LAST" ,
	"ATTACK_WEAKEST" ,
	"ATTACK_STRONGEST" ,
	"ATTACK_CLOSEST" ,
	"ATTACK_FAREST" ,
	"ATTACK_FIGHTER" ,
	"ATTACK_PRIEST" ,
	"ATTACK_GUNNER" ,
	"ATTACK_BOMBER"
};


//////////////////////////////////////////////////////////////////////////////
// 阁胶磐 己氢 - 阁胶磐绰 PC甫 焊绊 绢痘霸 馆览窍绰啊?
//////////////////////////////////////////////////////////////////////////////
enum MAlignment 
{
    ALIGNMENT_FRIENDLY ,
    ALIGNMENT_NEUTRAL ,
    ALIGNMENT_AGGRESSIVE
};

const string MAlignment2String[] = 
{
	"ALIGNMENT_FRIENDLY" ,
    "ALIGNMENT_NEUTRAL" ,
    "ALIGNMENT_AGGRESSIVE"
};


//////////////////////////////////////////////////////////////////////////////
// AI Level - 阁胶磐绰 倔付唱 度度茄啊?
//////////////////////////////////////////////////////////////////////////////
enum AILevel 
{
	AI_VERY_LOW ,		//   1 - 50
	AI_LOW ,			//  51 - 100
	AI_MEDIUM ,			// 101 - 150
	AI_HIGH ,			// 151 - 200
	AI_VERY_HIGH 		// 201 - 250
};

//////////////////////////////////////////////////////////////////////////////
// Body Size - 阁胶磐狼 个烹 农扁
//////////////////////////////////////////////////////////////////////////////
enum BodySize
{
	BODYSIZE_SMALL = 0,
	BODYSIZE_MEDIUM,
	BODYSIZE_LARGE
};

//////////////////////////////////////////////////////////////////////////////
// class MonsterInfo
//////////////////////////////////////////////////////////////////////////////

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

public:
	MonsterType_t getMonsterType() const { return m_MonsterType; }
	void setMonsterType(MonsterType_t spriteType) { m_MonsterType = spriteType; }

	SpriteType_t getSpriteType() const { return m_SpriteType; }
	void setSpriteType(SpriteType_t spriteType) { m_SpriteType = spriteType; }

	string getHName() const { return m_HName; }
	void setHName(const string & name) { m_HName = name; }

	string getEName() const { return m_EName; }
	void setEName(const string & name) { m_EName = name; }

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

	Attr_t getSTR() const { return m_STR; }
	void setSTR(Attr_t str) { m_STR = str; }

	Attr_t getDEX() const { return m_DEX; }
	void setDEX(Attr_t dex) { m_DEX = dex; }

	Attr_t getINT() const { return m_INT; }
	void setINT(Attr_t inte) { m_INT = inte; }

	uint getBodySize() const { return m_BodySize; }
	void setBodySize(uint size) { m_BodySize = size; }

	HP_t getHP() const { return m_HP; }
	void setHP(HP_t hp) { m_HP = hp; }

	Exp_t getExp() const { return m_Exp; }
	void setExp(Exp_t exp) { m_Exp = exp; }

	Color_t getMainColor() const { return m_MainColor; }
	void setMainColor(Color_t mainColor) { m_MainColor = mainColor; }

	Color_t getSubColor() const { return m_SubColor; }
	void setSubColor(Color_t subColor) { m_SubColor = subColor; }

	MAlignment getAlignment() const { return m_Alignment; }
	void setAlignment(MAlignment alignment) { m_Alignment = alignment; }

	AttackOrder getAttackOrder() const { return m_AttackOrder; }
	void setAttackOrder(AttackOrder attackOrder) { m_AttackOrder = attackOrder; }

	Moral_t getMoral() const { return m_Moral; }
	void setMoral(Moral_t moral) { m_Moral = moral; }

	Turn_t getDelay() const { return m_Delay; }
	void setDelay(Turn_t delay) { m_Delay = delay; }

	Turn_t getAttackDelay() const { return m_AttackDelay; }
	void setAttackDelay(Turn_t delay) { m_AttackDelay = delay; }

	Sight_t getSight() const { return m_Sight; }
	void setSight(Sight_t sight) { m_Sight = sight; }

	int getMeleeRange(void) const { return m_MeleeRange; }
	void setMeleeRange(int range) { m_MeleeRange = range; }

	int getMissileRange(void) const { return m_MissileRange; }
	void setMissileRange(int range) { m_MissileRange = range; }

	Creature::MoveMode getMoveMode() const { return m_MoveMode; }
	void setMoveMode(Creature::MoveMode moveMode) { m_MoveMode = moveMode; }
	void setMoveMode(const string & moveMode) throw(Error);

	uint getAIType(void) const { return m_AIType;}
	void setAIType(uint aitype) { m_AIType = aitype;}

	int getEnhanceHP(void) const { return m_EnhanceHP; }
	int getEnhanceToHit(void) const { return m_EnhanceToHit; }
	int getEnhanceDefense(void) const { return m_EnhanceDefense; }
	int getEnhanceProtection(void) const { return m_EnhanceProtection; }
	int getEnhanceMinDamage(void) const { return m_EnhanceMinDamage; }
	int getEnhanceMaxDamage(void) const { return m_EnhanceMaxDamage; }
	void parseEnhanceAttr(const string& enhance) throw();

	void parseSlayerTreasureString(const string& text) throw();
	TreasureList* getSlayerTreasureList(void) const { return m_pSlayerTreasureList; }
	TreasureList* getSlayerTreasureList(void) { return m_pSlayerTreasureList; }
	void setSlayerTreasureList(TreasureList* pTreasureList) throw();

	void parseVampireTreasureString(const string& text) throw();
	TreasureList* getVampireTreasureList(void) const { return m_pVampireTreasureList; }
	TreasureList* getVampireTreasureList(void) { return m_pVampireTreasureList; }
	void setVampireTreasureList(TreasureList* pTreasureList) throw();

	void parseOustersTreasureString(const string& text) throw();
	TreasureList* getOustersTreasureList(void) const { return m_pOustersTreasureList; }
	TreasureList* getOustersTreasureList(void) { return m_pOustersTreasureList; }
	void setOustersTreasureList(TreasureList* pTreasureList) throw();

	RegenType selectRegenType() const;
	int getRegenType(RegenType rt) const				{ return m_RegenType[rt]; }
	void setRegenType(RegenType rt, int percent);

	int  getUnburrowChance(void) const { return m_UnburrowChance;}
	void setUnburrowChance(uint uc) { m_UnburrowChance = uc;}	// 0~128

	int  isMaster(void) const { return m_bMaster;}
	void setMaster(bool bMaster=true) { m_bMaster = bMaster;}

	int  getClanType(void) const { return m_ClanType;}
	void setClanType(int clanType) { m_ClanType = clanType;}

	void setMonsterSummonInfo(const string& text);
	bool getMonsterSummonInfo(int step, SUMMON_INFO2& summonInfo) const;
	bool hasNextMonsterSummonInfo(int step) const;

	void setDefaultEffects(const string& text);
	const list<Effect::EffectClass>& getDefaultEffects() const { return m_DefaultEffects; }
	void addDefaultEffects(Creature* pCreature) const;

	bool isChief(void) const { return m_bChief; }
	void setChief(bool flag) { m_bChief = flag; }

	bool  isNormalRegen(void) const { return m_bNormalRegen;}
	void setNormalRegen(bool bNormalRegen=true) { m_bNormalRegen = bNormalRegen;}

	bool  hasTreasure(void) const { return m_bHasTreasure;}
	void setHasTreasure(bool bHasTreasure=true) { m_bHasTreasure = bHasTreasure;}

	int  getMonsterClass(void) const { return m_MonsterClass;}
	void setMonsterClass(int mClass) { m_MonsterClass = mClass;}

	int  getSkullType(void) const { return m_SkullType;}
	void setSkullType(int skullType) { m_SkullType = skullType;}

	string toString() const throw();

private:
	MonsterType_t      m_MonsterType;               // 阁胶磐 鸥涝
	SpriteType_t       m_SpriteType;                // 荤侩 胶橇扼捞飘 鸥涝
	string             m_HName;                     // 阁胶磐 茄臂 捞抚
	string             m_EName;                     // 阁胶磐 康巩 捞抚
	Level_t            m_Level;                     // 阁胶磐 饭骇
	Attr_t             m_STR;                       // 扁夯 STR
	Attr_t             m_DEX;                       // 扁夯 DEX
	Attr_t             m_INT;                       // 扁夯 INT
	uint               m_BodySize;                  // 阁胶磐狼 农扁
	HP_t               m_HP;                        // 积疙仿
	Exp_t              m_Exp;                       // 磷看阑 锭 PC 轨颇捞绢啊 罐绰 版氰摹 (not used)
	Color_t            m_MainColor;                 // Main Color (not used)
	Color_t            m_SubColor;                  // Sub Color (not used)
	MAlignment         m_Alignment;                 // 己氢
	AttackOrder        m_AttackOrder;               // 傍拜 鉴辑俊 包访等 己氢
	Moral_t            m_Moral;                     // 荤扁
	Turn_t             m_Delay;                     // 促澜 青困甫 窍扁 鳖瘤狼 掉饭捞 矫埃.
	Turn_t             m_AttackDelay;               // 促澜 傍拜阑 窍扁 鳖瘤狼 掉饭捞 矫埃.
	Sight_t            m_Sight;                     // 矫具
	int                m_MeleeRange;                // 立辟傈 荤沥芭府
	int                m_MissileRange;              // 固荤老 荤沥芭府
	Creature::MoveMode m_MoveMode;                  // 捞悼 葛靛
	uint               m_AIType;                    // 牢傍瘤瓷 鸥涝
	int                m_EnhanceHP;                 // 眉仿 碍拳 硅荐
	int                m_EnhanceToHit;              // ToHit 碍拳 硅荐
	int                m_EnhanceDefense;            // 叼奇胶 碍拳 硅荐
	int                m_EnhanceProtection;         // 橇肺咆记 碍拳 硅荐
	int                m_EnhanceMinDamage;             // 单固瘤 碍拳 硅荐
	int                m_EnhanceMaxDamage;             // 单固瘤 碍拳 硅荐
	TreasureList*      m_pSlayerTreasureList;       // 浇饭捞绢甫 困茄 焊拱狼 府胶飘
	TreasureList*      m_pVampireTreasureList;      // 轨颇捞绢甫 困茄 焊拱狼 府胶飘
	TreasureList*      m_pOustersTreasureList;      // 酒快胶磐令甫 困茄 焊拱狼 府胶飘
	int   		       m_RegenType[REGENTYPE_MAX];	// 阿 积己规过狼 犬伏
	int                m_UnburrowChance;            // 积己等 饶俊 顶困肺 唱棵 犬伏
	bool               m_bMaster;                   // 轨颇捞绢 付胶磐牢啊?
	int                m_ClanType;                    // 绢蠢 clan俊 加窍绰 阁胶磐牢啊?
	MonsterSummonInfo* m_pMonsterSummonInfo;	    // 阁胶磐 家券 沥焊
	list<Effect::EffectClass> m_DefaultEffects;		// 阁胶磐俊霸 扁夯利栏肺 嘿绢乐绰 捞棋飘
	bool				m_bNormalRegen;		// 府哩 矫俊 急琶登绰 阁胶磐 鸥蕾牢啊?
	bool				m_bHasTreasure;		// Treasure.bin 拳老捞 鞘夸茄啊?
	bool				m_bChief;			// 摹橇 阁胶磐牢啊?

	int					m_MonsterClass;		// 阁胶磐狼 努贰胶
	ItemType_t			m_SkullType;		// 阁胶磐狼 秦榜 鸥涝
};


//////////////////////////////////////////////////////////////////////////////
// class MonsterInfoManager
//////////////////////////////////////////////////////////////////////////////

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

public:
	// initialize
	void init() throw(Error);

	// load to database
	void load() throw(Error);
	void reload(MonsterType_t monsterType) throw(Error);

	// add monster info with monster type
	void addMonsterInfo(MonsterType_t monsterType, MonsterInfo* pMonsterInfo) throw(DuplicatedException, OutOfBoundException, Error);

	// get monster info with monster type
	const MonsterInfo* getMonsterInfo(MonsterType_t monsterType) const throw(NoSuchElementException, OutOfBoundException, Error);

	// 烙狼狼 胶橇扼捞飘 鸥涝阑 啊柳 阁胶磐狼 鸥涝 府胶飘甫 啊廉柯促.
	// (咯矾 阁胶磐啊 窍唱狼 胶橇扼捞飘 鸥涝阑 啊龙 荐 乐扁 锭巩俊) 
	const vector<MonsterType_t>& getMonsterTypeBySprite(SpriteType_t spriteType) const throw (NoSuchElementException, OutOfBoundException, Error);

	SpriteType_t getSpriteTypeByName(const string& monsterName) const throw (NoSuchElementException, Error);
	MonsterType_t getChiefMonsterTypeByName(const string& monsterName) const throw (NoSuchElementException, Error);
	vector<MonsterType_t>& getMonsterTypesByMonsterClass(int MonsterClass) { return m_MonsterClassMap[MonsterClass]; }

	uint	getMaxMonsterType() const	{ return m_MaxMonsterType; }
	MonsterType_t	getRandomMonsterByClass( int minClass, int maxClass );

	// get debug string
	string toString() const throw();

protected :
	void	clearTreasures();

private:
	uint                  m_MaxMonsterType;      // size of MonsterInfo* array
	MonsterInfo**         m_MonsterInfos;          // array of monster info
	vector<MonsterType_t> m_MonsterSpriteSet[MAX_SPRITE_TYPE]; // array of MonsterType by SpriteType
	hash_map<string, SpriteType_t> m_MonsterSpriteTypes; 	// 捞抚栏肺 SpriteType_t茫扁
	hash_map<string, MonsterType_t> m_ChiefMonster; 	// Chief 阁胶磐 沥焊 啊瘤绊 乐扁
	hash_map<int, vector<SpriteType_t> > m_MonsterClassMap; // 阁胶磐 努贰胶肺 阁胶磐 鸥涝 茫扁

	TreasureLists 			m_SlayerTreasureLists;       // 浇饭捞绢甫 困茄 焊拱狼 府胶飘
	TreasureLists    		m_VampireTreasureLists;      // 轨颇捞绢甫 困茄 焊拱狼 府胶飘
	TreasureLists    		m_OustersTreasureLists;      // 酒快胶磐令甫 困茄 焊拱狼 府胶飘
};

// global variable declaration
extern MonsterInfoManager* g_pMonsterInfoManager;

#endif