initallstat.cpp

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

			m_ConsumeMPRatio = PlusPoint;
			break;
		}
		case OPTION_MAGIC_DAMAGE:
		{
			m_MagicBonusDamage = PlusPoint;
			break;
		}
		case OPTION_PHYSIC_DAMAGE:
		{
			m_PhysicBonusDamage = PlusPoint;
			break;
		}
		case OPTION_GAMBLE_PRICE:
		{
			m_GamblePriceRatio = PlusPoint;
			break;
		}
		case OPTION_POTION_PRICE:
		{
			m_PotionPriceRatio = PlusPoint;
			break;
		}

		default:
			break;
	}

}

void Slayer::computeOptionStat(OptionType_t optionType) throw()
{
	__BEGIN_TRY

	OptionInfo*   pOptionInfo   = g_pOptionInfoManager->getOptionInfo(optionType);
	computeOptionClassStat( pOptionInfo->getClass(), pOptionInfo->getPlusPoint() );
//	OptionClass   OClass        = pOptionInfo->getClass();

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

		case OPTION_ALL_ATTR:
			m_STR[ATTR_CURRENT] += pOptionInfo->getPlusPoint();
			m_STR[ATTR_MAX]     += pOptionInfo->getPlusPoint();

			m_DEX[ATTR_CURRENT] += pOptionInfo->getPlusPoint();
			m_DEX[ATTR_MAX]     += pOptionInfo->getPlusPoint();

			m_INT[ATTR_CURRENT] += pOptionInfo->getPlusPoint();
			m_INT[ATTR_MAX]     += pOptionInfo->getPlusPoint();

			computeStatOffset();
			break;

		case OPTION_ALL_RES:
			m_Resist[MAGIC_DOMAIN_POISON] += pOptionInfo->getPlusPoint();
			m_Resist[MAGIC_DOMAIN_ACID] += pOptionInfo->getPlusPoint();
			m_Resist[MAGIC_DOMAIN_CURSE] += pOptionInfo->getPlusPoint();
			m_Resist[MAGIC_DOMAIN_BLOOD] += pOptionInfo->getPlusPoint();
			break;

		case OPTION_LUCK:
			m_Luck += pOptionInfo->getPlusPoint();
		break;

		case OPTION_STR_TO_DEX:
		{
			int trans = getPercentValue( m_STR[ATTR_BASIC], pOptionInfo->getPlusPoint() );
			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], pOptionInfo->getPlusPoint() );
			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], pOptionInfo->getPlusPoint() );
			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], pOptionInfo->getPlusPoint() );
			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], pOptionInfo->getPlusPoint() );
			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], pOptionInfo->getPlusPoint() );
			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:
		{
			m_ConsumeMPRatio = pOptionInfo->getPlusPoint();
			break;
		}
		case OPTION_MAGIC_DAMAGE:
		{
			m_MagicBonusDamage = pOptionInfo->getPlusPoint();
			break;
		}
		case OPTION_PHYSIC_DAMAGE:
		{
			m_PhysicBonusDamage = pOptionInfo->getPlusPoint();
			break;
		}
		case OPTION_GAMBLE_PRICE:
		{
			m_GamblePriceRatio = pOptionInfo->getPlusPoint();
			break;
		}
		case OPTION_POTION_PRICE:
		{
			m_PotionPriceRatio = pOptionInfo->getPlusPoint();
			break;
		}

		default:
			break;
	}*/

	__END_CATCH
}

void Slayer::addModifyInfo(const SLAYER_RECORD& prev, ModifyInfo& pkt) const
	throw()
{
	__BEGIN_TRY

	if (prev.pSTR[ATTR_CURRENT] != m_STR[ATTR_CURRENT]) pkt.addShortData(MODIFY_CURRENT_STR, m_STR[ATTR_CURRENT]);
	if (prev.pSTR[ATTR_MAX    ] != m_STR[ATTR_MAX    ]) pkt.addShortData(MODIFY_MAX_STR,     m_STR[ATTR_MAX]);
	if (prev.pSTR[ATTR_BASIC  ] != m_STR[ATTR_BASIC  ]) pkt.addShortData(MODIFY_BASIC_STR,   m_STR[ATTR_BASIC]);

	if (prev.pDEX[ATTR_CURRENT] != m_DEX[ATTR_CURRENT]) pkt.addShortData(MODIFY_CURRENT_DEX, m_DEX[ATTR_CURRENT]);
	if (prev.pDEX[ATTR_MAX    ] != m_DEX[ATTR_MAX    ]) pkt.addShortData(MODIFY_MAX_DEX,     m_DEX[ATTR_MAX]);
	if (prev.pDEX[ATTR_BASIC  ] != m_DEX[ATTR_BASIC  ]) pkt.addShortData(MODIFY_BASIC_DEX,   m_DEX[ATTR_BASIC]);

	if (prev.pINT[ATTR_CURRENT] != m_INT[ATTR_CURRENT]) pkt.addShortData(MODIFY_CURRENT_INT, m_INT[ATTR_CURRENT]);
	if (prev.pINT[ATTR_MAX    ] != m_INT[ATTR_MAX    ]) pkt.addShortData(MODIFY_MAX_INT,     m_INT[ATTR_MAX]);
	if (prev.pINT[ATTR_BASIC  ] != m_INT[ATTR_BASIC  ]) pkt.addShortData(MODIFY_BASIC_INT,   m_INT[ATTR_BASIC]);

	if (prev.pHP[ATTR_CURRENT] != m_HP[ATTR_CURRENT]) pkt.addShortData(MODIFY_CURRENT_HP, m_HP[ATTR_CURRENT]);
	if (prev.pHP[ATTR_MAX    ] != m_HP[ATTR_MAX    ]) pkt.addShortData(MODIFY_MAX_HP,     m_HP[ATTR_MAX]);

	if (prev.pMP[ATTR_CURRENT] != m_MP[ATTR_CURRENT]) pkt.addShortData(MODIFY_CURRENT_MP, m_MP[ATTR_CURRENT]);
	if (prev.pMP[ATTR_MAX    ] != m_MP[ATTR_MAX    ]) pkt.addShortData(MODIFY_MAX_MP,     m_MP[ATTR_MAX]);

	if (prev.pDamage[ATTR_CURRENT] != m_Damage[ATTR_CURRENT]) pkt.addShortData(MODIFY_MIN_DAMAGE, m_Damage[ATTR_CURRENT]);
	if (prev.pDamage[ATTR_MAX    ] != m_Damage[ATTR_MAX    ]) pkt.addShortData(MODIFY_MAX_DAMAGE, m_Damage[ATTR_MAX]);

	if (prev.Defense     != m_Defense[ATTR_CURRENT])     pkt.addShortData(MODIFY_DEFENSE,      m_Defense[ATTR_CURRENT]);
	if (prev.Protection  != m_Protection[ATTR_CURRENT])  pkt.addShortData(MODIFY_PROTECTION,   m_Protection[ATTR_CURRENT]);
	if (prev.ToHit       != m_ToHit[ATTR_CURRENT])       pkt.addShortData(MODIFY_TOHIT,        m_ToHit[ATTR_CURRENT]);
	if (prev.AttackSpeed != m_AttackSpeed[ATTR_CURRENT]) pkt.addShortData(MODIFY_ATTACK_SPEED, m_AttackSpeed[ATTR_CURRENT]);

	// by sigi. 2002.9.10
	if (prev.Rank != getRank())
	{
		pkt.addShortData(MODIFY_RANK, getRank());
		pkt.addLongData(MODIFY_RANK_EXP, getRankGoalExp());
	}

	__END_CATCH
}

void Slayer::sendModifyInfo(const SLAYER_RECORD& prev) const
	throw()
{
	__BEGIN_TRY

	GCModifyInformation gcModifyInformation;
	addModifyInfo(prev, gcModifyInformation);
	m_pPlayer->sendPacket(&gcModifyInformation);

	__END_CATCH
}

void Slayer::initAllStatAndSend()
{
	SLAYER_RECORD prev;
	getSlayerRecord(prev);
	initAllStat();
	sendModifyInfo(prev);
}

//////////////////////////////////////////////////////////////////////////////
// 
// 轨颇捞绢
//
//////////////////////////////////////////////////////////////////////////////

void Vampire::initCastleSkill() throw()
{
	__BEGIN_TRY

	removeAllCastleSkill();

	if ( !getZone()->isHolyLand() ) return;

	list<CastleInfo*> pCastleInfoList = g_pCastleInfoManager->getGuildCastleInfos( getGuildID() );
	if ( pCastleInfoList.empty() ) return;

	list<CastleInfo*>::iterator itr = pCastleInfoList.begin();

	for ( ; itr != pCastleInfoList.end() ; itr++ )
	{
		SkillType_t CastleSkillType = g_pCastleInfoManager->getCastleSkillType( (*itr)->getZoneID(), getGuildID() );
		if ( CastleSkillType == SKILL_MAX ) 
			continue;

		SkillInfo* pSkillInfo = g_pSkillInfoManager->getSkillInfo(CastleSkillType);
		Assert( pSkillInfo != NULL );

		Turn_t Delay = pSkillInfo->getMaxDelay();

		VampireCastleSkillSlot* pCastleSkillSlot = new VampireCastleSkillSlot();

		pCastleSkillSlot->setName( m_Name );
		pCastleSkillSlot->setSkillType( CastleSkillType );
		pCastleSkillSlot->setInterval(Delay);
		pCastleSkillSlot->setRunTime();

		addSkill( pCastleSkillSlot );
	}

	__END_CATCH
}

void Vampire::initAllStat(int numPartyMember)
	throw()
{
	__BEGIN_TRY

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

	m_Resist[MAGIC_DOMAIN_NO_DOMAIN] = 0;
	m_Resist[MAGIC_DOMAIN_POISON]    = 50;
	m_Resist[MAGIC_DOMAIN_ACID]      = 0;
	m_Resist[MAGIC_DOMAIN_CURSE]     = 0;
	m_Resist[MAGIC_DOMAIN_BLOOD]     = 0;

	// BloodBible 包访 焊呈胶 荐摹甸 檬扁拳
	m_ConsumeMPRatio	= 0;
	m_GamblePriceRatio	= 0;
	m_PotionPriceRatio	= 0;
	m_MagicBonusDamage	= 0;
	m_PhysicBonusDamage	= 0;

	//////////////////////////////////////////////////////////////////////////////
	// 力老 刚历 扁夯 瓷仿摹甫 檬扁拳矫虐绊, 
	// 扁夯 瓷仿摹俊 康氢阑 林绰 捞棋飘甫 八荤茄促.
	//////////////////////////////////////////////////////////////////////////////
	m_STR[ATTR_CURRENT] = m_STR[ATTR_MAX] = m_STR[ATTR_BASIC];
	m_DEX[ATTR_CURRENT] = m_DEX[ATTR_MAX] = m_DEX[ATTR_BASIC];
	m_INT[ATTR_CURRENT] = m_INT[ATTR_MAX] = m_INT[ATTR_BASIC];

	//////////////////////////////////////////////////////////////////////////////
	// 瓷仿摹 拌魂阑 困茄 颇扼固磐甸阑 檬扁拳茄促.
	//////////////////////////////////////////////////////////////////////////////
	attr.nSTR    = m_STR[ATTR_CURRENT];
	attr.nDEX    = m_DEX[ATTR_CURRENT];
	attr.nINT    = m_INT[ATTR_CURRENT];
	attr.pWeapon = NULL;
	attr.nLevel  = m_Level;
	
	m_HPStealRatio  = 0;
	m_HPStealAmount = 0;
	m_HPRegen       = 0;
	m_Luck			= 0;
	m_HPRegenBonus	= 0;

	////////////////////////////////////////////////////////////
	// 何啊利牢 瓷仿摹甸阑 促矫 拌魂茄促.
	////////////////////////////////////////////////////////////
	m_HP[ATTR_MAX]                = computeHP(CClass, &attr);
	m_HP[ATTR_BASIC]              = 0;
	m_ToHit[ATTR_CURRENT]         = computeToHit(CClass, &attr);
	m_ToHit[ATTR_MAX]             = 0;
	m_Defense[ATTR_CURRENT]       = computeDefense(CClass, &attr);
	m_Defense[ATTR_MAX]           = 0;
	m_Protection[ATTR