treasure.cpp

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

		msg << "\t\t" << m_TreasureItemTypes[i]->toString() << "\n";
	}
	
	msg << "\n\t\t)";
	return msg.toString();

	__END_CATCH
}

/*XMLTree* TreasureItemClass::makeXMLTree() const
{
	XMLTree* ret = new XMLTree("ItemClass");
	ret->AddAttribute("Class", ItemClass2ShortString[m_ItemClass]);
	ret->AddAttribute("Ratio", m_Ratio);

	vector<TreasureItemType*>::const_iterator itr = m_TreasureItemTypes.begin();
	vector<TreasureItemType*>::const_iterator endItr = m_TreasureItemTypes.end();

	for ( ; itr != endItr ; ++itr )
	{
		ret->AddChild( (*itr)->makeXMLTree() );
	}

	return ret;
}*/

Item::ItemClass TreasureItemClass::getItemClassFromString(const string& text) 
	throw()
{
	__BEGIN_TRY

	for (int i=0; i<Item::ITEM_CLASS_MAX; i++)
	{
		if (strcasecmp(text.c_str(), ItemClass2ShortString[i].c_str()) == 0)
		{
			return (Item::ItemClass)i;
		}
	}

	StringStream msg;
	msg << "TreasureItemClass::getItemClassFromString() : Unknown String[" << text << "]";
	cerr << msg.toString() << endl;
	throw (msg.toString());

	__END_CATCH
}

//////////////////////////////////////////////////////////////////////////////
// class Treasure member methods
//////////////////////////////////////////////////////////////////////////////

Treasure::Treasure()
	throw()
{
	__BEGIN_TRY

	m_ItemRatio           = 0;
	m_OptionRatio         = 0;
	m_ItemClassTotalRatio = 0;

	__END_CATCH
}

Treasure::~Treasure()
	throw()
{
	__BEGIN_TRY

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

	m_TreasureItemClasses.clear();

	__END_CATCH
}

void Treasure::loadFromFile(ifstream& file) 
	throw()
{
	__BEGIN_TRY

	int ItemClassCount = 0;

	file.read((char*)&m_ItemRatio, sizeof(int));
	file.read((char*)&m_OptionRatio, sizeof(int));
	file.read((char*)&ItemClassCount, sizeof(int));

	for (int i=0; i<ItemClassCount; i++)
	{
		TreasureItemClass* pTIC = new TreasureItemClass;
		pTIC->loadFromFile(file);
		m_TreasureItemClasses.push_back(pTIC);
	}

	// 犬伏 钦拌甫 拌魂秦 敌促.
	m_ItemClassTotalRatio = 0;
	for (uint i=0; i<m_TreasureItemClasses.size(); i++)
	{
		TreasureItemClass* pTIC = m_TreasureItemClasses[i];
		m_ItemClassTotalRatio += pTIC->getRatio();
	}

	__END_CATCH
}

void Treasure::parseString(const string& text) 
	throw()
{
	__BEGIN_TRY

	////////////////////////////////////////////////////////////
	// (50,50)
	// BEGIN_ITEM_CLASS (SWORD, 50)
	// <(1,50)(STR+1,50)(STR+2,30)(STR+3,20)>
	// <(2,30)(STR+1,50)(STR+2,30)(STR+3,20)>
	// <(3,20)(STR+1,50)(STR+2,30)(STR+3,20)>
	// END_ITEM_CLASS
	// BEGIN_ITEM_CLASS (BLADE, 50)
	// <(1,50)(STR+1,50)(STR+2,30)(STR+3,20)>
	// <(2,30)(STR+1,50)(STR+2,30)(STR+3,20)>
	// <(3,20)(STR+1,50)(STR+2,30)(STR+3,20)>
	// END_ITEM_CLASS
	////////////////////////////////////////////////////////////
	
	// 刚历 酒捞袍 磊眉啊 唱棵 犬伏苞, 弊 酒捞袍俊 可记捞 嘿阑 犬伏阑 佬绢甸牢促.
	uint i = text.find_first_of('(');
	uint j = text.find_first_of(',');
	uint k = text.find_first_of(')');

	if (i == string::npos || j == string::npos || k == string::npos) 
	{
		cerr << "Treasure::parseString() : Error" << endl;
		throw ("Treasure::parseString() : Error");
	}

	//m_ItemRatio = atoi(trim(text.substr(i+1, j-i-1)).c_str()) * 150 / 100 ;
	m_ItemRatio = atoi(trim(text.substr(i+1, j-i-1)).c_str());

	// 焊惑阑 困茄 内靛
	//m_ItemRatio = (int)((float)atoi(trim(text.substr(i+1, j-i-1)).c_str()) * 1.5);
	
	//m_OptionRatio = atoi(trim(text.substr(j+1, k-j-1)).c_str()) * 150 / 100;
	m_OptionRatio = atoi(trim(text.substr(j+1, k-j-1)).c_str());

	// 酒捞袍 磊眉啊 唱棵 犬伏阑 佬绢甸看栏聪, 肋扼辰促.
	string newText = trim(text.substr(k+1, text.size()-k-1));

	string btoken = "BEGIN_ITEMCLASS";
	string etoken = "END_ITEMCLASS";
	uint   BTOKENSIZE = btoken.size();

	uint a = 0;
	uint b = 0;

	while (b < newText.size()-1)
	{
		////////////////////////////////////////////////////////////
		// BEGIN_ITEM_CLASS (SWORD, 50)
		// <(1,50,50) (STR+1,50)(STR+2,30)(STR+3,20)>
		// <(2,30,50) (STR+1,50)(STR+2,30)(STR+3,20)>
		// <(3,20,50) (STR+1,50)(STR+2,30)(STR+3,20)>
		// END_ITEM_CLASS
		// BEGIN_ITEM_CLASS (BLADE, 50)
		// <(1,50,50) (STR+1,50)(STR+2,30)(STR+3,20)>
		// <(2,30,50) (STR+1,50)(STR+2,30)(STR+3,20)>
		// <(3,20,50) (STR+1,50)(STR+2,30)(STR+3,20)>
		// END_ITEM_CLASS
		////////////////////////////////////////////////////////////
		a = newText.find(btoken, b);
		b = newText.find(etoken, a+1);
	
		if (a == string::npos || b == string::npos) break;

		string substring = trim(newText.substr(a+BTOKENSIZE, b-a-BTOKENSIZE));

		TreasureItemClass* pTIC = new TreasureItemClass;
		pTIC->parseString(substring);

		m_TreasureItemClasses.push_back(pTIC);

		substring.clear();
	}

	newText.clear();

	// 颇教捞 场车栏搁, 傈眉 犬伏阑 拌魂茄促.
	m_ItemClassTotalRatio = 0;
	for (uint i=0; i<m_TreasureItemClasses.size(); i++)
	{
		TreasureItemClass* pTIC = m_TreasureItemClasses[i];
		m_ItemClassTotalRatio += pTIC->getRatio();
	}
	
	__END_CATCH
}

bool Treasure::getRandomItem(ITEM_TEMPLATE* pTemplate)
	throw()
{
	__BEGIN_TRY

	
	// 飘饭廉府胶飘俊 酒捞袍捞 绝绰 版快老 波促..酒付档...积鳖磊~.
	if ( 0 == m_ItemClassTotalRatio )
		return false;

	// 刚历 酒捞袍捞 唱棵瘤 救 唱棵瘤俊 措茄 犬伏眉农甫 矫青茄促.
	int ItemRatio = rand()%TREASURE_RATIO_MODULUS;

	//cout << "Item犬伏眉农: " << ItemRatio << " " << m_ItemRatio << endl
	//	 << "荐沥犬伏"       << ItemRatio << " " << g_pVariableManager->getItemProbRatio()/100 << endl;

	//cout << "Item犬伏 眉农 : " << ItemRatio << " < " << m_ItemRatio << endl;

	// 酒捞袍捞 唱坷扁肺 搬沥登菌促搁...
	double EventMultiplier = 0.0;
	if(g_pVariableManager->getEventActivate() == 1)
		EventMultiplier = g_pVariableManager->getItemProbRatio()/100;
	else
		EventMultiplier = 1;

	if (ItemRatio < m_ItemRatio * EventMultiplier)
	{
		int OptionRatio = rand()%TREASURE_RATIO_MODULUS;

		if (OptionRatio < m_OptionRatio)
		{
			pTemplate->bCreateOption = true;
		}
		else
		{
			pTemplate->bCreateOption = false;
		}

		//cout << "可记 犬伏 眉农 : " << OptionRatio << " < " << m_OptionRatio << endl;

		int itemClassRatio = rand()%m_ItemClassTotalRatio;
		int ratioSum       = 0;
		int preRatioSum	   = 0;

		//cout << "酒捞袍 努贰胶 犬伏 : " << itemClassRatio << " / " << m_ItemClassTotalRatio << endl;

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

			preRatioSum = ratioSum;
			ratioSum += pTIC->getRatio();

			if ( itemClassRatio > preRatioSum && itemClassRatio < ratioSum)
			{
				pTemplate->ItemClass = pTIC->getItemClass();
				if (pTIC->getRandomItem(pTemplate))
					return true;
				else
					return false;
			}
		}
	}

	return false;

	__END_CATCH
}

bool Treasure::getRandomItem(ITEM_TEMPLATE* pTemplate, int nPercent)
	throw()
{
	__BEGIN_TRY

	// 刚历 酒捞袍捞 唱棵瘤 救 唱棵瘤俊 措茄 犬伏眉农甫 矫青茄促.
	int ItemRatio = rand()%TREASURE_RATIO_MODULUS;

	// 酒捞袍 犬伏俊 荐沥摹 措涝
	int ModifyItemRatio = getPercentValue( m_ItemRatio, nPercent );

//	cout << "Item value : " << ItemRatio << endl;
//	cout << "Bonus Ratio : " << nPercent << endl;
//	cout << "Item Ratio : " << ModifyItemRatio << endl;

	if (ItemRatio < ModifyItemRatio )
	{
		int OptionRatio = rand()%TREASURE_RATIO_MODULUS;

		if (OptionRatio < m_OptionRatio)
		{
			pTemplate->bCreateOption = true;
		}
		else
		{
			pTemplate->bCreateOption = false;
		}

		//cout << "可记 犬伏 眉农 : " << OptionRatio << " < " << m_OptionRatio << endl;

		if ( m_ItemClassTotalRatio == 0 )
			return false;

		int itemClassRatio = rand()%m_ItemClassTotalRatio;
		int ratioSum       = 0;
		int preRatioSum	   = 0;

		//cout << "酒捞袍 努贰胶 犬伏 : " << itemClassRatio << " / " << m_ItemClassTotalRatio << endl;

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

			preRatioSum = ratioSum;
			ratioSum += pTIC->getRatio();

			if ( itemClassRatio > preRatioSum && itemClassRatio < ratioSum)
			{
				pTemplate->ItemClass = pTIC->getItemClass();
				if (pTIC->getRandomItem(pTemplate))
					return true;
				else
					return false;
			}
		}
	}

	return false;

	__END_CATCH
}

string Treasure::toString(void) const
	throw()
{
	__BEGIN_TRY

	StringStream msg;
	msg << "\tTreasure\n\t("
		<< "\n\t\tItemRatio:" << m_ItemRatio
		<< "\n\t\tOptionRatio:" << m_ItemRatio << "\n";

	for (uint i=0; i<m_TreasureItemClasses.size(); i++)
	{
		msg << "\t" << m_TreasureItemClasses[i]->toString() << "\n";
	}

	msg	<< "\n\t)";
	return msg.toString();

	__END_CATCH
}

/*XMLTree* Treasure::makeXMLTree() const
{
	XMLTree* ret = new XMLTree("Treasure");
	ret->AddAttribute("Ratio", m_ItemRatio);
	ret->AddAttribute("OptionRatio", m_OptionRatio);

	vector<TreasureItemClass*>::const_iterator itr = m_TreasureItemClasses.begin();
	vector<TreasureItemClass*>::const_iterator endItr = m_TreasureItemClasses.end();

	for ( ; itr != endItr ; ++itr )
	{
		ret->AddChild( (*itr)->makeXMLTree() );
	}

	return ret;
}*/

//////////////////////////////////////////////////////////////////////////////
// class TreasureList member methods
//////////////////////////////////////////////////////////////////////////////

TreasureList::TreasureList()
	throw()
{
	__BEGIN_TRY
	__END_CATCH
}

TreasureList::~TreasureList()
	throw()
{
	__BEGIN_TRY
	__END_CATCH
}

void TreasureList::loadFromFile(ifstream& file) 
	throw()
{
	__BEGIN_TRY

	
	// 扁粮俊 乐带吧 瘤况霖促.
	list<Treasure*>::iterator itr = m_Treasures.begin();
	for (; itr!=m_Treasures.end(); itr++)
	{
		Treasure* pTreasure = *itr;
		SAFE_DELETE(pTreasure);
	}
	m_Treasures.clear();


	// 促矫 肺爹
	int TreasureCount = 0;
	file.read((char*)&TreasureCount, sizeof(int));

	for (int i=0; i<TreasureCount; i++)
	{
		Treasure* pTreasure = new Treasure;
		pTreasure->loadFromFile(file);
		addTreasure(pTreasure);
	}

	__END_CATCH
}

void TreasureList::parseString(const string& text) 
	throw()
{
	__BEGIN_TRY

	////////////////////////////////////////////////////////////
	// BEGIN_TREASURE (50)
	//   BEGIN_ITEM_CLASS (SWORD, 50)
	//     <(1,50,50) (STR+1,50)(STR+2,30)(STR+3,20)>
	//     <(2,30,50) (STR+1,50)(STR+2,30)(STR+3,20)>
	//     <(3,20,50) (STR+1,50)(STR+2,30)(STR+3,20)>
	//   END_ITEM_CLASS
	//   BEGIN_ITEM_CLASS (BLADE, 50)
	//     <(2,50,50) (STR+1,50)(STR+2,30)(STR+3,20)>
	//     <(3,30,50) (STR+1,50)(STR+2,30)(STR+3,20)>
	//     <(4,20,50) (STR+1,50)(STR+2,30)(STR+3,20)>
	//   END_ITEM_CLASS
	// END_TREASURE
	////////////////////////////////////////////////////////////
	
	string bToken = "BEGIN_TREASURE";
	string eToken = "END_TREASURE";
	uint   BTOKENSIZE = bToken.size();

	uint a = 0;
	uint b = 0;

	int count = 0;

	while (b < text.size())
	{
		a = text.find(bToken, b);
		b = text.find(eToken, a+1);

		if (a == string::npos || b == string::npos) break;

		string substring = trim(text.substr(a+BTOKENSIZE, b-a-BTOKENSIZE));

		//cout << "TreasureList SubString:\n" << substring << endl << endl;

		Treasure* pTreasure = new Treasure;
		pTreasure->parseString(substring);
		addTreasure(pTreasure);

		count += 1;

		substring.clear();
	}

	__END_CATCH
}

void TreasureList::addTreasure(Treasure* pTreasure)
	throw()
{
	__BEGIN_TRY

	Assert(pTreasure != NULL);
	m_Treasures.push_back(pTreasure);

	__END_CATCH
}

string TreasureList::toString(void) const 
	throw()
{
	__BEGIN_TRY

	StringStream msg;
	msg << "TreasureList\n(\n";

	list<Treasure*>::const_iterator itr = m_Treasures.begin();
	for (; itr != m_Treasures.end(); itr++)
	{
		msg << (*itr)->toString() << "\n";
	}

	msg << "\n)";
	return msg.toString();

	__END_CATCH
}

/*XMLTree* TreasureList::makeXMLTree() const
{
	XMLTree* ret = new XMLTree("TreasureList");

	list<Treasure*>::const_iterator itr = m_Treasures.begin();
	list<Treasure*>::const_iterator endItr = m_Treasures.end();

	for ( ; itr != endItr ; ++itr )
	{
		ret->AddChild( (*itr)->makeXMLTree() );
	}

	return ret;
}*/

TreasureLists::TreasureLists()
{
}

TreasureLists::~TreasureLists()
{
	clear();
}

void 
TreasureLists::clear()
{
	hash_map<string, TreasureList*>::iterator itr = m_TreasureLists.begin();
	for (; itr!=m_TreasureLists.end(); itr++)
	{
		TreasureList* pTreasureList = itr->second;
		SAFE_DELETE(pTreasureList);
	}
	m_TreasureLists.clear();
}

TreasureList*   
TreasureLists::getTreasure(const string& filename) const
{
	hash_map<string, TreasureList*>::const_iterator itr = m_TreasureLists.find( filename );

	if (itr!=m_TreasureLists.end())
	{
		return itr->second;
	}

	return NULL;
}

void            
TreasureLists::addTreasure(const string& filename, TreasureList* pTreasureList)
{
	hash_map<string, TreasureList*>::const_iterator itr = m_TreasureLists.find( filename );

	if (itr!=m_TreasureLists.end())
	{
		TreasureList* pTreasureList = itr->second;
		SAFE_DELETE(pTreasureList);
	}

	m_TreasureLists[filename] = pTreasureList;
}

TreasureList*            
TreasureLists::loadTreasure(const string& filename)
{
	TreasureList* pTreasureList = new TreasureList;
	ifstream file(filename.c_str(), ios::in | ios::nocreate | ios::binary);

	if (!file)
	{
		StringStream msg;
		msg << "Cannot open " << filename << " to read.";
		cerr << msg.toString() << endl;
		throw (msg.toString());
	}

	pTreasureList->loadFromFile(file);
	file.close();

	addTreasure(filename, pTreasureList);

//	cout << "Generating XML File.. " << endl;
//	XMLTree* pXML = pTreasureList->makeXMLTree();
//	pXML->SaveToFile( (filename+".xml").c_str() );

	return pTreasureList;
}