monsterinfo.cpp

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

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

#include "MonsterInfoTypes.h"
#include "MonsterInfo.h"
#include "Treasure.h"
#include "DB.h"
#include "StringStream.h"
#include "Properties.h"
#include "MonsterSummonInfo.h"
#include "EffectObservingEye.h"
#include "EffectDetectInvisibility.h"
#include "SXml.h"
#include <fstream>
#include <stdio.h>
#include <functional>
#include <algorithm>

int DefaultClanID[CLAN_MAX] =
{
	0, //CLAN_NONE,							// 绢叼俊档 加窍瘤 臼绰 局代.. 0
	1, //CLAN_VAMPIRE_MONSTER,				// 栋倒捞 轨颇 阁胶磐 -_-;     1
	2, //CLAN_VAMPIRE_BATHORY_MONSTER,		// 官配府 家加 阁胶磐          2
	3, //CLAN_VAMPIRE_TEPEZ_MONSTER,			// 抛其令 家加 阁胶磐          3
	4, //CLAN_SLAYER_MONSTER,				// 浇饭捞绢 阁胶磐 - -;;       4
};

extern int DefaultClanID[CLAN_MAX];

//////////////////////////////////////////////////////////////////////////////
// global varible initialization
//////////////////////////////////////////////////////////////////////////////
MonsterInfoManager* g_pMonsterInfoManager = NULL;

//////////////////////////////////////////////////////////////////////////////
// functions
//////////////////////////////////////////////////////////////////////////////

void saveTreasure(const string& filename, TreasureList* pTreasureList)
{
	ofstream file(filename.c_str(), ios::out | ios::binary | ios::trunc);
	if (!file) return;

	const list<Treasure*>& TList = pTreasureList->getTreasures();
	int TreasureCount = TList.size();

	file.write(&TreasureCount, sizeof(int));

	list<Treasure*>::const_iterator itr = TList.begin();
	for (; itr != TList.end(); itr++)
	{
		Treasure* pTreasure = *itr;

		int ItemRatio           = pTreasure->m_ItemRatio;
		int OptionRatio         = pTreasure->m_OptionRatio;

		file.write(&ItemRatio, sizeof(int));
		file.write(&OptionRatio, sizeof(int));

		vector<TreasureItemClass*> TICs = pTreasure->m_TreasureItemClasses;
		int ItemClassCount = TICs.size();

		file.write(&ItemClassCount, sizeof(int));

		for (uint i=0; i<TICs.size(); i++)
		{
			TreasureItemClass* pTIC = TICs[i];

			int ItemClass          = (int)pTIC->m_ItemClass;
			int ItemClassRatio     = pTIC->m_Ratio;

			file.write(&ItemClass, sizeof(int));
			file.write(&ItemClassRatio, sizeof(int));

			vector<TreasureItemType*> TITs = pTIC->m_TreasureItemTypes;
			int ItemTypeCount = TITs.size();

			file.write(&ItemTypeCount, sizeof(int));

			for (uint j=0; j<TITs.size(); j++)
			{
				TreasureItemType* pTIT = TITs[j];

				int ItemType             = pTIT->m_ItemType;
				int ItemTypeRatio        = pTIT->m_Ratio;

				file.write(&ItemType, sizeof(int));
				file.write(&ItemTypeRatio, sizeof(int));

				vector<TreasureOptionType*> TOTs = pTIT->m_TreasureOptionTypes;
				int OptionTypeCount = TOTs.size();

				file.write(&OptionTypeCount, sizeof(int));

				for (uint k=0; k<TOTs.size(); k++)
				{
					TreasureOptionType* pTOT = TOTs[k];

					int OptionType  = pTOT->m_OptionType;
					int OptionRatio = pTOT->m_Ratio;

					file.write(&OptionType, sizeof(int));
					file.write(&OptionRatio, sizeof(int));
				}
			}
		}
	}
}

//////////////////////////////////////////////////////////////////////////////
// class MonsterInfo member methods
//////////////////////////////////////////////////////////////////////////////

MonsterInfo::MonsterInfo()
	throw()
{
	__BEGIN_TRY

	m_MonsterType = 0;
	m_SpriteType = 0;
	m_HName = "";
	m_EName = "";
	m_Level = 0;
	m_STR = 0;
	m_DEX = 0;
	m_INT = 0;
	m_BodySize = BODYSIZE_SMALL;
	m_HP = 0;
	m_Exp = 0;
	m_MainColor = 0;
	m_SubColor = 0;
	m_Alignment = ALIGNMENT_FRIENDLY;
	m_AttackOrder = ATTACK_FIRST;
	m_Moral = 0;
	m_Delay = 0;
	m_AttackDelay = 0;
	m_Sight = 0;
	m_MoveMode = Creature::MOVE_MODE_WALKING;
	m_AIType = 0;

	m_EnhanceHP         = 0;
	m_EnhanceToHit      = 0;
	m_EnhanceDefense    = 0;
	m_EnhanceProtection = 0;
	m_EnhanceMinDamage     = 0;
	m_EnhanceMaxDamage     = 0;

	m_pSlayerTreasureList  = NULL;//new TreasureList;
	m_pVampireTreasureList = NULL;//new TreasureList;
	m_pOustersTreasureList = NULL;//new TreasureList;

	m_RegenType[REGENTYPE_HIDE] 	 = 128;
	m_RegenType[REGENTYPE_PORTAL] 	 = 0;
	m_RegenType[REGENTYPE_INVISIBLE] = 0;
	m_RegenType[REGENTYPE_BAT] 		 = 0;
	
	m_UnburrowChance = 128;
	m_bMaster = false;
	m_ClanType = CLAN_VAMPIRE_MONSTER;
	m_pMonsterSummonInfo = NULL;

	// 2002.10.16 by sigi
	m_bNormalRegen = true;

	__END_CATCH
}

MonsterInfo::~MonsterInfo()
	throw()
{
	__BEGIN_TRY

	// 捞芭绰 MonsterInfo俊辑 包府茄促.
	//SAFE_DELETE(m_pSlayerTreasureList);
	//SAFE_DELETE(m_pVampireTreasureList);

	m_pSlayerTreasureList = NULL;
	m_pVampireTreasureList = NULL;
	m_pOustersTreasureList = NULL;

	SAFE_DELETE(m_pMonsterSummonInfo);

	__END_CATCH
}

void MonsterInfo::setRegenType(RegenType rt, int percent)
{ 
	m_RegenType[rt] = percent;

	// REGENTYPE_NORMAL狼 犬伏阑 官层辑 100%肺 嘎免妨绊 沁瘤父
	// 喊 狼固啊 绝阑 淀 窍咯.. - -;  by sigi
}

//---------------------------------------------------------------------------
// select RegenType
//---------------------------------------------------------------------------
// Hide客 Portal狼 犬伏阑 刚历 眉农秦夯饶 笛 促 酒聪搁.. Normal捞促. by sigi
//---------------------------------------------------------------------------
RegenType MonsterInfo::selectRegenType() const
{
	// 加档 距埃 臭鳃妨绊
	// 100盒伏捞 酒聪绊 128盒伏捞促 - -;
	int dice = rand() & 0x0000007F; //rand()%100;

	int acc = 0;
	const int REGENTYPE_MAX_1 = REGENTYPE_MAX-1;
	for (int i=0; i<REGENTYPE_MAX_1; i++)
	{
		// 阿 犬伏喊肺 穿利矫难辑 肋~ 眉农
		acc += m_RegenType[i];
		if (dice < acc)
		{
			return (RegenType)i;
		}
	}

	return REGENTYPE_HIDE;
}

void MonsterInfo::setMoveMode(const string& moveMode)
	throw (Error)
{
	__BEGIN_TRY

	if (moveMode == "WALK") m_MoveMode = Creature::MOVE_MODE_WALKING;
	else if (moveMode == "FLY") m_MoveMode = Creature::MOVE_MODE_FLYING;
	else if (moveMode == "BURROW") m_MoveMode = Creature::MOVE_MODE_BURROWING;
	else throw Error("invalid move mode");

	__END_CATCH
}

void MonsterInfo::parseEnhanceAttr(const string& enhance) 
	throw()
{
	m_EnhanceHP         = 0;
	m_EnhanceToHit      = 0;
	m_EnhanceDefense    = 0;
	m_EnhanceProtection = 0;
	m_EnhanceMinDamage     = 0;
	m_EnhanceMaxDamage     = 0;

	if (enhance.size() < 1) return;

	uint a = 0 , b = 0 , c = 0;

	while (c < enhance.size() - 1)
	{
		///////////////////////////////////////////////////////
		// (HP,1)(DAMAGE,1)...
		// a  b ca
		///////////////////////////////////////////////////////
		a = enhance.find_first_of('(',c);
		b = enhance.find_first_of(',',a+1);
		c = enhance.find_first_of(')',b+1);

		if (a > b || b > c) break;

		string part  = enhance.substr(a+1, b-a-1);
		int    value = atoi(enhance.substr(b+1, c-b-1).c_str());

		if (part == "HP")              m_EnhanceHP         = value;
		else if (part == "DEFENSE")    m_EnhanceDefense    = value;
		else if (part == "PROTECTION") m_EnhanceProtection = value;
		else if (part == "TOHIT")      m_EnhanceToHit      = value;
		else if (part == "DAMAGE")     m_EnhanceMinDamage = m_EnhanceMaxDamage = value;
		else if (part == "MINDAMAGE")     m_EnhanceMinDamage     = value;
		else if (part == "MAXDAMAGE")     m_EnhanceMaxDamage     = value;
	}
}

void MonsterInfo::parseSlayerTreasureString(const string& text)
	throw()
{
	__BEGIN_TRY

	string newtext = trim(text);
	/*
	if (newtext.size() < 10)
	{
		cerr << "MonsterInfo::parseSlayerTreasureString() : Too short treasure string" << endl;
		throw ("MonsterInfo::parseSlayerTreasureString() : Too short treasure string");
	}
	*/

	m_pSlayerTreasureList->parseString(newtext);

	__END_CATCH
}

void MonsterInfo::setSlayerTreasureList(TreasureList* pTreasureList)
	throw()
{
	__BEGIN_TRY

	Assert(pTreasureList != NULL);
	//SAFE_DELETE(m_pSlayerTreasureList);
	m_pSlayerTreasureList = pTreasureList;

	__END_CATCH
}

void MonsterInfo::parseVampireTreasureString(const string& text)
	throw()
{
	__BEGIN_TRY

	string newtext = trim(text);
	/*
	if (newtext.size() < 10)
	{
		cerr << "MonsterInfo::parseVampireTreasureString() : Too short treasure string" << endl;
		throw ("MonsterInfo::parseVampireTreasureString() : Too short treasure string");
	}
	*/

	m_pVampireTreasureList->parseString(newtext);

	__END_CATCH
}

void MonsterInfo::setVampireTreasureList(TreasureList* pTreasureList)
	throw()
{
	__BEGIN_TRY

	Assert(pTreasureList != NULL);
	//SAFE_DELETE(m_pVampireTreasureList);
	m_pVampireTreasureList = pTreasureList;

	__END_CATCH
}

void MonsterInfo::parseOustersTreasureString(const string& text)
	throw()
{
	__BEGIN_TRY

	string newtext = trim(text);

	m_pOustersTreasureList->parseString(newtext);

	__END_CATCH
}

void MonsterInfo::setOustersTreasureList(TreasureList* pTreasureList)
	throw()
{
	__BEGIN_TRY

	Assert(pTreasureList != NULL);

	m_pOustersTreasureList = pTreasureList;

	__END_CATCH
}

void MonsterInfo::setMonsterSummonInfo(const string& text)
{
	SAFE_DELETE(m_pMonsterSummonInfo);

	if (text.size() > 0)
	{
		m_pMonsterSummonInfo = new MonsterSummonInfo;

		m_pMonsterSummonInfo->parseString( text );

//		cout << "[SummonInfo] " 
//			<< getHName().c_str() << " : " 
//			<< m_pMonsterSummonInfo->toString().c_str() 
//			<< endl;
	}
}

bool MonsterInfo::getMonsterSummonInfo(int step, SUMMON_INFO2& summonInfo) const
{
	if (m_pMonsterSummonInfo==NULL)
	{
		summonInfo.pMonsters = NULL;
		return false;
	}

	summonInfo.pMonsters = (MonsterCollection*)m_pMonsterSummonInfo->getRandomMonsterCollection(step);

	return true;
}