initallstat.cpp

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

		Assert( pRankBonus != NULL );

		int LuckBonus = pRankBonus->getPoint();

		m_Luck += LuckBonus;
	}

	// 傈里 焊呈胶 利侩
	if ( HPBonus > 0 )
	{
		m_HP[ATTR_MAX] = min( SLAYER_MAX_HP, m_HP[ATTR_MAX] + HPBonus );
	}

	if ( RaceWarHPBonus > 0 )
	{
		m_HP[ATTR_MAX] = min( SLAYER_MAX_HP, m_HP[ATTR_MAX] + RaceWarHPBonus );
	}

	// 己瘤胶懦 檬扁拳
	initCastleSkill();
//	cout << getName() << "狼 Luck : " << m_Luck << endl;

	// 泅犁 HP啊 MAX HP焊促 腹栏搁
	/*
	if ( m_HP[ATTR_CURRENT] > m_HP[ATTR_MAX] )
	{
		m_HP[ATTR_CURRENT] = m_HP[ATTR_MAX];
	}
	*/

	// 颇萍狼 农扁俊 蝶扼辑 瓷仿摹啊 函且 荐 乐促.

	/*
	// 颇萍 牢盔荐啊 逞绢坷瘤 臼篮 版快绰 促矫 拌魂茄促.
	if (numPartyMember == -1)
	{
		if (m_PartyID != 0)
		{
			LocalPartyManager* pLPM = getLocalPartyManager();
			Assert(pLPM != NULL);
	
			numPartyMember = pLPM->getAdjacentMemberSize(m_PartyID, this);
		}
	}

	if (numPartyMember > 1)
	{

		uint ToHitBonus      = 0;
		uint DefenseBonus    = 0;
		uint ProtectionBonus = 0;
		uint DamageBonus     = 0;

		switch (numPartyMember)
		{
			case 2: ToHitBonus +=  2; DefenseBonus += 1; ProtectionBonus += 1; DamageBonus += 1; break;
			case 3: ToHitBonus +=  4; DefenseBonus += 2; ProtectionBonus += 2; DamageBonus += 1; break;
			case 4: ToHitBonus +=  6; DefenseBonus += 3; ProtectionBonus += 3; DamageBonus += 2; break;
			case 5: ToHitBonus +=  8; DefenseBonus += 4; ProtectionBonus += 4; DamageBonus += 2; break;
			case 6: ToHitBonus += 10; DefenseBonus += 5; ProtectionBonus += 5; DamageBonus += 3; break;
			default: break; 
		}

		m_ToHit[ATTR_CURRENT]      += ToHitBonus;
		m_Defense[ATTR_CURRENT]    += DefenseBonus;
		m_Protection[ATTR_CURRENT] += ProtectionBonus;
		m_Damage[ATTR_CURRENT]     += DamageBonus;
		m_Damage[ATTR_MAX]         += DamageBonus;
	}
	*/

	/*
	printf("BareMINDamage:%d\n", m_Damage[ATTR_CURRENT]);
	printf("BareMAXDamage:%d\n", m_Damage[ATTR_MAX]);
	if (pWeapon != NULL)
	{
		printf("+WeaponMINDamage:%d\n", m_Damage[ATTR_CURRENT] + pWeapon->getMinDamage());
		printf("+WeaponMAXDamage:%d\n", m_Damage[ATTR_MAX] + pWeapon->getMaxDamage());
	}
	*/

	__END_CATCH
}

//////////////////////////////////////////////////////////////////////////////
// STR, DEX, INT狼 版快
// CURRENT = 扁夯 荐摹 + 酒捞袍 荐摹 + 付过 荐摹
// MAX     = 扁夯 荐摹 + 酒捞袍 荐摹
// BASIC   = 扁夯 荐摹
//
// HP, MP狼 版快
// CURRENT = 泅犁 荐摹
// MAX     = 泅犁 钙胶
// BASIC   = 酒捞袍俊 狼茄 函拳 荐摹
//
// Defense, Protection, ToHit狼 版快
// CURRENT = 泅犁 荐摹
// MAX     = 酒捞袍俊 狼茄 函拳 荐摹
//
// Damage狼 版快
// CURRENT = Min 单固瘤
// MAX     = Max 单固瘤
// BASIC   = 酒捞袍俊 狼茄 函拳 荐摹
//////////////////////////////////////////////////////////////////////////////
void Slayer::computeStatOffset(void) throw()
{
	__BEGIN_TRY

	Creature::CreatureClass CClass = getCreatureClass();
	BASIC_ATTR              cur_attr;

	cur_attr.nSTR    = m_STR[ATTR_CURRENT];
	cur_attr.nDEX    = m_DEX[ATTR_CURRENT];
	cur_attr.nINT    = m_INT[ATTR_CURRENT];
	cur_attr.pWeapon = m_pWearItem[WEAR_RIGHTHAND];

	for (int i=0; i<SKILL_DOMAIN_MAX; i++)
		cur_attr.pDomainLevel[i] = m_SkillDomainLevels[i];

	// 技肺况柳 STR, DEX, INT肺 货肺 拌魂阑 茄 促澜
	// 酒捞袍 肚绰 付过 荐摹甫 歹茄促.
	m_HP[ATTR_MAX] = computeHP(CClass, &cur_attr);
	m_HP[ATTR_MAX] += m_HP[ATTR_BASIC]; 

	m_MP[ATTR_MAX] = computeMP(CClass, &cur_attr);
	m_MP[ATTR_MAX] += m_MP[ATTR_BASIC]; 

	m_ToHit[ATTR_CURRENT] = computeToHit(CClass, &cur_attr);
	m_ToHit[ATTR_CURRENT] += m_ToHit[ATTR_MAX];

	m_Defense[ATTR_CURRENT] = computeDefense(CClass, &cur_attr);
	m_Defense[ATTR_CURRENT] += m_Defense[ATTR_MAX];

	m_Protection[ATTR_CURRENT] = computeProtection(CClass, &cur_attr);
	m_Protection[ATTR_CURRENT] += m_Protection[ATTR_MAX];

	m_Damage[ATTR_CURRENT] = computeMinDamage(CClass, &cur_attr);
	m_Damage[ATTR_MAX]     = computeMaxDamage(CClass, &cur_attr);

	m_Damage[ATTR_CURRENT] += m_Damage[ATTR_BASIC];
	m_Damage[ATTR_MAX] += m_Damage[ATTR_BASIC];

	m_AttackSpeed[ATTR_CURRENT] = computeAttackSpeed(CClass, &cur_attr);
	m_AttackSpeed[ATTR_CURRENT] += m_AttackSpeed[ATTR_MAX];

	m_CriticalRatio[ATTR_CURRENT] = computeCriticalRatio(CClass, &cur_attr);
	m_CriticalRatio[ATTR_CURRENT] += m_CriticalRatio[ATTR_MAX];

	__END_CATCH
}

void Slayer::computeItemStat(Item* pItem) throw()
{
	__BEGIN_TRY

	if (isSlayerWeapon(pItem->getItemClass()))
	{
		// 公扁扼搁 公扁啊 啊瘤绰 加档 颇扼固磐甫 歹茄促.
		ItemInfo* pItemInfo = g_pItemInfoManager->getItemInfo(pItem->getItemClass(), pItem->getItemType());
		m_AttackSpeed[ATTR_CURRENT] += pItemInfo->getSpeed();
		m_AttackSpeed[ATTR_MAX]     += pItemInfo->getSpeed();
	}

	m_Protection[ATTR_CURRENT] += pItem->getProtectionBonus();
	m_Protection[ATTR_MAX]     += pItem->getProtectionBonus();

	m_Defense[ATTR_CURRENT] += pItem->getDefenseBonus();
	m_Defense[ATTR_MAX]     += pItem->getDefenseBonus();

	m_ToHit[ATTR_CURRENT]   += pItem->getToHitBonus();
	m_ToHit[ATTR_MAX]       += pItem->getToHitBonus();

	m_MP[ATTR_MAX]          += pItem->getMPBonus();
	m_MP[ATTR_BASIC]        += pItem->getMPBonus();

	m_Luck					+= pItem->getLuck();

	// 何啊利牢 可记甸
	const list<OptionType_t>& optionType = pItem->getOptionTypeList();
	list<OptionType_t>::const_iterator itr;
	for (itr=optionType.begin(); itr!=optionType.end(); itr++)
	{
		computeOptionStat( *itr );
	}

	// Item 磊眉狼 defaultOption阑 利侩矫挪促.
	const list<OptionType_t>& defaultOptions = pItem->getDefaultOptions();
	list<OptionType_t>::const_iterator iOptions;

	for (iOptions=defaultOptions.begin(); iOptions!=defaultOptions.end(); iOptions++)
	{
		computeOptionStat( *iOptions );
	}


	__END_CATCH
}

void Slayer::computeOptionStat(Item* pItem) throw()
{
	__BEGIN_TRY

	// Option Type阑 罐酒柯促.
//	OptionType_t  OptionType    = pItem->getOptionType();
//	computeOptionStat( OptionType );

	// 何啊利牢 可记甸
	const list<OptionType_t>& optionType = pItem->getOptionTypeList();
	list<OptionType_t>::const_iterator itr;
	for (itr=optionType.begin(); itr!=optionType.end(); itr++)
	{
		computeOptionStat( *itr );
	}

	// Item 磊眉狼 defaultOption阑 利侩矫挪促.
	const list<OptionType_t>& defaultOptions = pItem->getDefaultOptions();
	list<OptionType_t>::const_iterator iOptions;

	for (iOptions=defaultOptions.begin(); iOptions!=defaultOptions.end(); iOptions++)
	{
		computeOptionStat( *iOptions );
	}



	__END_CATCH
}

void Slayer::computeOptionClassStat( OptionClass OClass, int PlusPoint )
{
	switch (OClass) 
	{
		case OPTION_STR:
			m_STR[ATTR_CURRENT] += PlusPoint;
			m_STR[ATTR_MAX]     += PlusPoint;
			computeStatOffset();
			break;
		case OPTION_DEX:
			m_DEX[ATTR_CURRENT] += PlusPoint;
			m_DEX[ATTR_MAX]     += PlusPoint;
			computeStatOffset();
			break;
		case OPTION_INT:
			m_INT[ATTR_CURRENT] += PlusPoint;
			m_INT[ATTR_MAX]     += PlusPoint;
			computeStatOffset();
			break;
		case OPTION_HP:
			m_HP[ATTR_MAX]   += PlusPoint;
			m_HP[ATTR_BASIC] += PlusPoint;
			break;
		case OPTION_MP:
			m_MP[ATTR_MAX]   += PlusPoint;
			m_MP[ATTR_BASIC] += PlusPoint;
			break;
		case OPTION_HP_STEAL:
			m_HPStealAmount += PlusPoint;
			break;
		case OPTION_MP_STEAL:
			m_MPStealAmount += PlusPoint;
			break;
		case OPTION_HP_REGEN:
			m_HPRegen += PlusPoint;
			break;
		case OPTION_MP_REGEN:
			m_MPRegen += PlusPoint;
			break;
		case OPTION_TOHIT:
			m_ToHit[ATTR_CURRENT] += PlusPoint;
			m_ToHit[ATTR_MAX]     += PlusPoint;
			break;
		case OPTION_DEFENSE:
			m_Defense[ATTR_CURRENT] += PlusPoint;
			m_Defense[ATTR_MAX]     += PlusPoint;
			break;
		case OPTION_DAMAGE:
			m_Damage[ATTR_CURRENT] += PlusPoint;
			m_Damage[ATTR_MAX]     += PlusPoint;
			m_Damage[ATTR_BASIC]   += PlusPoint;
			break;
		case OPTION_PROTECTION:
			m_Protection[ATTR_CURRENT] += PlusPoint;
			m_Protection[ATTR_MAX]     += PlusPoint;
			break;
		case OPTION_ATTACK_SPEED:
			m_AttackSpeed[ATTR_CURRENT] += PlusPoint;
			m_AttackSpeed[ATTR_MAX]     += PlusPoint;
			break;
		case OPTION_POISON:
			m_Resist[MAGIC_DOMAIN_POISON] += PlusPoint;
			break;
		case OPTION_ACID:
			m_Resist[MAGIC_DOMAIN_ACID] += PlusPoint;
			break;
		case OPTION_CURSE:
			m_Resist[MAGIC_DOMAIN_CURSE] += PlusPoint;
			break;
		case OPTION_BLOOD:
			m_Resist[MAGIC_DOMAIN_BLOOD] += PlusPoint;
			break;
		case OPTION_VISION:
			break;
		case OPTION_CRITICAL_HIT:
			m_CriticalRatio[ATTR_CURRENT] += PlusPoint;
			m_CriticalRatio[ATTR_MAX]     += PlusPoint;
			break;

		case OPTION_ALL_ATTR:
			m_STR[ATTR_CURRENT] += PlusPoint;
			m_STR[ATTR_MAX]     += PlusPoint;

			m_DEX[ATTR_CURRENT] += PlusPoint;
			m_DEX[ATTR_MAX]     += PlusPoint;

			m_INT[ATTR_CURRENT] += PlusPoint;
			m_INT[ATTR_MAX]     += PlusPoint;

			computeStatOffset();
			break;

		case OPTION_ALL_RES:
			m_Resist[MAGIC_DOMAIN_POISON] += PlusPoint;
			m_Resist[MAGIC_DOMAIN_ACID] += PlusPoint;
			m_Resist[MAGIC_DOMAIN_CURSE] += PlusPoint;
			m_Resist[MAGIC_DOMAIN_BLOOD] += PlusPoint;
			break;

		case OPTION_LUCK:
			m_Luck += PlusPoint;
		break;

		case OPTION_STR_TO_DEX:
		{
			int trans = getPercentValue( m_STR[ATTR_BASIC], PlusPoint );
			m_STR[ATTR_CURRENT]	-= trans;
			m_STR[ATTR_MAX]		-= trans;
			m_DEX[ATTR_CURRENT]	+= trans;
			m_DEX[ATTR_MAX]		+= trans;

			computeStatOffset();
			break;
		}

		case OPTION_STR_TO_INT:
		{
			int trans = getPercentValue( m_STR[ATTR_BASIC], PlusPoint );
			m_STR[ATTR_CURRENT]	-= trans;
			m_STR[ATTR_MAX]		-= trans;
			m_INT[ATTR_CURRENT] += trans;
			m_INT[ATTR_MAX]		+= trans;

			computeStatOffset();
			break;
		}

		case OPTION_DEX_TO_STR:
		{
			int trans = getPercentValue( m_DEX[ATTR_BASIC], PlusPoint );
			m_DEX[ATTR_CURRENT]	-= trans;
			m_DEX[ATTR_MAX]		-= trans;
			m_STR[ATTR_CURRENT] += trans;
			m_STR[ATTR_MAX]		+= trans;

			computeStatOffset();
			break;
		}

		case OPTION_DEX_TO_INT:
		{
			int trans = getPercentValue( m_DEX[ATTR_BASIC], PlusPoint );
			m_DEX[ATTR_CURRENT]	-= trans;
			m_DEX[ATTR_MAX]		-= trans;
			m_INT[ATTR_CURRENT] += trans;
			m_INT[ATTR_MAX]		+= trans;

			computeStatOffset();
			break;
		}

		case OPTION_INT_TO_STR:
		{
			int trans = getPercentValue( m_INT[ATTR_BASIC], PlusPoint );
			m_INT[ATTR_CURRENT]	-= trans;
			m_INT[ATTR_MAX]		-= trans;
			m_STR[ATTR_CURRENT] += trans;
			m_STR[ATTR_MAX]		+= trans;

			computeStatOffset();
			break;
		}

		case OPTION_INT_TO_DEX:
		{
			int trans = getPercentValue( m_INT[ATTR_BASIC], PlusPoint );
			m_INT[ATTR_CURRENT]	-= trans;
			m_INT[ATTR_MAX]		-= trans;
			m_DEX[ATTR_CURRENT] += trans;
			m_DEX[ATTR_MAX]		+= trans;

			computeStatOffset();
			break;
		}
		case OPTION_CONSUME_MP:
		{