charlist.h

国内著名网络游戏dragon的服务端完整源码 内附完整数据库结构

#ifndef _DRAGON_CHARLIST_
#define _DRAGON_CHARLIST_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

///////////////////////////////////////////////////////////////////////////////
// 某腐磐俊 包茄 努贰胶
template<class T1, class T2, class T3> 
class TCharList : public T1, public T2, public T3
{ 
public:
	void CorrectRiseFall(BYTE nType, int nX, int nY, int& rDamage);
	void CorrectStrikeRange(int nDistance, int& rDamage);
	void CorrectMagicRange(int nDistance, int& rDamage);
	void CorrectCombatRange(int nDistance, int& rDamage);
	
	int CalcAttackSuccessRate(int nStatic = 0, int nDynamic = 0);
	int CalcMagicSuccessRate(int nDefence = 0);
	int CalcPhysicalStrikingPower(int nPercent = 0, int nAdd = 0);
	int CalcPhysicalDefensivePower(int nAttack, int nPercent = 0);
	int CalcMagicStrikingPower(int nHD, int nPercent = 0, int nAdd = 0);
	int CalcMagicDefensivePower(BYTE nType, int nAttack, int nPercent = 0);
	int CalcMagicCastReady(BYTE nMagic);
	int CalcMagicPeriod(BYTE nType, int nContinue);
	int CalcResistPeriod(BYTE nType, int nContinue);
	int CalcMovePower();
	
	bool IsStrikePiercing() const;       // CSD-021024
	bool IsMagicPiercing() const;        // CSD-021024
	bool IsCurseAvoid(BYTE nType) const; // CSD-021024
	
	int GetExtPoisonByItem() const;//酒捞袍俊 狼秦 歹秦瘤绰 付过规绢仿
	int GetExtCurseByItem() const;
	int GetExtHolyByItem() const;
	int GetExtFireByItem() const;
	int GetExtIceByItem() const;
	int GetExtElectByItem() const;
	
protected:  
	int GetExtPoison() const;//弥辆 付过规绢仿狼 钦( GetBasicResist(RT_XXX) + GetExtPoisonByItem())
	int GetExtCurse() const;
	int GetExtHoly() const;
	int GetExtFire() const;
	int GetExtIce() const;
	int GetExtElect() const;
};

///////////////////////////////////////////////////////////////////////////////
// Public Method
///////////////////////////////////////////////////////////////////////////////

template<class T1, class T2, class T3> 
void TCharList<T1, T2, T3>::CorrectRiseFall(BYTE nType, int nX, int nY, int& rDamage)
{	// 臭撤捞俊 蝶弗 焊沥
	const BYTE nRiseFall = GetRiseFall(nX, nY);	
	const int nTemp = rDamage*0.2; // 臭撤捞俊 蝶扼 20% 单固瘤 瞒捞
	
	switch (nType)
	{
    case 0: // 绊->历, 历->绊, 鞍篮 臭捞 葛电 傍拜捞 啊瓷茄 版快
		{
			if (nRiseFall == 1)  rDamage += nTemp; 
			if (nRiseFall == 2)  rDamage -= nTemp;
			break;
		}
    case 2: // 绊->历客 鞍篮 臭捞父 傍拜捞 啊瓷茄 版快
		{
			if (nRiseFall == 1)  rDamage += nTemp; 
			break;
		}
    case 3: // 历->绊客 鞍篮 臭捞父 傍拜捞 啊瓷茄 版快
		{
			if (nRiseFall == 2)  rDamage -= nTemp;
			break;
		}
	}
}

template<class T1, class T2, class T3> 
void TCharList<T1, T2, T3>::CorrectStrikeRange(int nDistance, int& rDamage)
{	// 拱府利 傍拜狼 芭府俊 蝶弗 焊沥
	int nPlus = RareEM.GetStaticRareDistant(StaticRare);
	
	if (nPlus > 0)
	{
		int nMin = 0, nMid = 0, nMax = 0;
		
		switch (GetWeaponKind())
		{
		case IK_HURL:      nMin = 3; nMid = 6;  nMax = 8;  break;
		case IK_SHORT_BOW:
		case IK_DUAL_BOW://030102 lsw Dual BOW
		case IK_TWO_ARROW:
		case IK_DUAL_ARROW://030102 lsw Arrow
		case IK_LONG_BOW:  nMin = 4; nMid = 8; nMax = 12; break;
		default:           return;
		}
		
		if (nDistance < nMin)  nPlus = 0;
		else if (nDistance < nMid)	 nPlus = (nPlus>>1);
		// 单固瘤 焊沥
		rDamage = rDamage*(100 + nPlus)/100;
	}
}

template<class T1, class T2, class T3> 
void TCharList<T1, T2, T3>::CorrectMagicRange(int nDistance, int& rDamage)
{	// 傍拜 付过狼 芭府俊 蝶弗 焊沥
	switch (nDistance/6)
	{
    case 0:  rDamage = rDamage;        break;
    case 1:  rDamage = rDamage*90/100; break;
    default: rDamage = rDamage*85/100; break;
	}
}

template<class T1, class T2, class T3> 
void TCharList<T1, T2, T3>::CorrectCombatRange(int nDistance, int& rDamage)
{	// 傈捧胶懦狼 芭府俊 蝶弗 焊沥
	switch (nDistance/6)
	{
    case 0:  rDamage = rDamage;        break;
    case 1:  rDamage = rDamage*85/100; break;
    default: rDamage = rDamage*80/100; break;
	}
}

template<class T1, class T2, class T3> 
int TCharList<T1, T2, T3>::CalcAttackSuccessRate(int nStatic, int nDynamic)
{	// 拱府利 傍拜捞 己傍且 犬伏 拌魂
	if (dwDontMiss > 0)  return 100;
	// 扁瓷 酒捞袍 惑尖
	const int nForceValue = RareEM.GetDynamicRareValue(FITEM_STROKE, DynamicRare);
	
	if (nDynamic <= 0 && nForceValue > 0)
	{
		return nForceValue;
	}
	
	const int nItem = item_Hit_Rate + RareEM.GetStaticRareAccurate(StaticRare);
	const int nDex = __min(GetAbility(DEX)/60, 5);
	const int nAttack = nDex + nItem + ((GetActiveCombat()) ? 85:75);
	const int nDefence = __max(nStatic, nDynamic);
	// 己傍伏 拌魂
	int nResult = nAttack - nDefence;
	if (nResult < 0)    nResult = 0;
	if (nResult > 100)  nResult = 100;
	return nResult;
}

template<class T1, class T2, class T3> 
int TCharList<T1, T2, T3>::CalcMagicSuccessRate(int nDefence)
{	//< CSD-030306 : 付过捞 己傍且 犬伏 拌魂
	if (dwDontMiss > 0)  return 100;
	
	const int nInt = GetAbility(INT_);
	const int nWis = GetAbility(WIS);
	const int nWsPs = GetAbility(WSPS);
	int nAttack = (nInt + nWis + nWsPs)*0.3 + 80;
	if (nAttack < 0)    nAttack = 0;
	if (nAttack > 100)  nAttack = 100;
	// 己傍伏 拌魂
	int nResult = nAttack - nDefence;
	if (nResult < 0)    nResult = 0;
	if (nResult > 100)  nResult = 100;
	return nResult;
}	//> CSD-030306

template<class T1, class T2, class T3>
int TCharList<T1, T2, T3>::CalcPhysicalStrikingPower(int nPercent, int nAdd)
{	// 拱府利 傍拜仿 拌魂
	if (IsNpc())		
	{	// NPC牢 版快绰 单捞喉俊辑 流立 曼炼
		const int nTemp = GetNpcAttack();
		return (nTemp*(rand()%3 + 9))/10;
	} 
	
	const int nWeapon =	CalcWeaponHit()*GetWeaponSkill(); // 公扁 傍拜仿 拌魂
	const int nBase = (GetLevel()<<2) + (nWeapon>>3) + Str/5 + 20 + rand()%20; // CSD-030806 : 扁夯 傍拜仿 拌魂
	const int nActive = GetActiveCombat();
	const int nPassive = GetPassiveCombat();
	const int nCritial = CalcCriticalHit(nActive, nPassive); // 农府萍漠 洒飘俊 狼茄 焊沥
	const int nVigor = RareEM.GetStaticRareVigor(StaticRare); // 厚芭 酒捞袍 加己俊 狼茄 焊沥
	const int nSum = 100 + nPercent + nCritial + nVigor; // 焊沥蔼甸狼 钦(窜困 %)
	const int nPlus = RareEM.GetStaticRarePower(StaticRare) +
					  RareEM.GetDynamicRareValue(FITEM_POWER_UP, DynamicRare) +
					  RareEM.GetStaticRareHighPower(StaticRare);
	const int nPower = nAdd + ((GetWeaponSkill()*nPlus)>>3);
	// 惑荐俊 狼茄 焊沥
	return (nBase*nSum/100 + nPower)*1.4;
}

template<class T1, class T2, class T3> 
int TCharList<T1, T2, T3>::CalcPhysicalDefensivePower(int nAttack, int nPercent)
{	// 拱府利 规绢仿 拌魂
	if (IsNpc())
	{
		const int nAc = __min(GetNpcDefence(), 100);
		return nAttack*nAc/100;
	}
	
	const int nAc = Ac +
					RareEM.GetStaticRareHardest(StaticRare) +
					RareEM.GetStaticRareHighShield(StaticRare) +
					RareEM.GetDynamicRareValue(FITEM_HEAVY_ARMOR, DynamicRare);
	const int nParrying = (!IsShield()) ? 0:Skill[TACTICS_Parrying]/25;
	const int nBase = __min(nAc, 282); // 弥措 235/250 厚啦肺 拌魂
	const int nSum = 100 + nPercent;               // 眠啊 规绢仿(%)
	const int nMax = nAttack*0.95;                 // 弥措 规绢仿
	return __min((nAttack*nBase/300)*nSum/100, nMax);
}

template<class T1, class T2, class T3> 
int TCharList<T1, T2, T3>::CalcMagicStrikingPower(int nHD, int nPercent, int nAdd)
{	// 傍拜拌凯 付过 傍拜仿 拌魂
	if (IsNpc())
	{
		return GetNpcMagic() + nHD;
	}
	
	int nTactics = 0, nAbility = 0;
	
	switch (Spell)
	{
    case WIZARD_SPELL:
		{	// 付过荤扼搁
			const int nItem = RareEM.GetStaticRareMagic_vigor(StaticRare) + 
							  RareEM.GetDynamicRareValue(FITEM_SPELL_UP, DynamicRare)+
							  RareEM.GetStaticRareHighMagic(StaticRare);//027030 lsw
			nTactics = (Skill[TACTICS_Magery] + 1)*(nHD + nItem);
			nAbility = GetAbility(INT_);
			break;
		}
    case PRIEST_SPELL:
		{	// 己流磊扼搁
			const int nItem = RareEM.GetStaticRareNature_vigor(StaticRare) + 
						      RareEM.GetDynamicRareValue(FITEM_SPELL_UP, DynamicRare)+
							  RareEM.GetStaticRareHighNature(StaticRare);//027030 lsw
			nTactics = (Skill[TACTICS_Orison] + 1)*(nHD + nItem);
			nAbility = GetAbility(WIS);
			break;
		}
	}
	
	const int nBase = (GetLevel()<<2) + (nTactics>>3) + (nAbility/5) + 30 + rand()%10; // CSD-030806
	const int nSum = 100 + nPercent; // 焊沥蔼甸狼 钦(窜困 %)
	const int nPlus = nAdd;
	return (nBase*nSum/100 + nPlus)*1.4;
}

template<class T1, class T2, class T3> 
int TCharList<T1, T2, T3>::CalcMagicDefensivePower(BYTE nType, int nAttack, int nPercent)
{	// 傍拜拌凯 付过 骸绢仿 拌魂
	if (IsNpc())
	{
		const int nAc = __min(GetNpcDefence(nType), 100);
		return nAttack*nAc/100;
	}
	
	int nResist = RareEM.GetDynamicRareValue(FITEM_RESIST_UP, DynamicRare);
	
	switch (nType)
	{
    case RESIST_FIRE:   nResist += GetExtFire();  break;
    case RESIST_ICE:    nResist += GetExtIce();   break;
    case RESIST_ELECT:  nResist += GetExtElect(); break;
    case RESIST_HOLY:   nResist += GetExtHoly();  break;
    case RESIST_IGNORE: nResist = 0;              break;
	}
	
	const int nMax = nAttack*0.95;           // 弥措 规绢仿
	const int nAc = Ac*5/6;                  // 弥辆 AC
	const int nEndu = (GetAbility(ENDU)>>2); // 弥辆 ENDU
	// 弥措 235/250 厚啦肺 拌魂
	const int nBase = __min(nResist + nAc + nEndu, 235);
	const int nSum = 100 + nPercent; // 眠啊 规绢仿(%)
	return __min((nAttack*nBase/250)*nSum/100, nMax);
}

template<class T1, class T2, class T3>
int TCharList<T1, T2, T3>::CalcMagicCastReady(BYTE nMagic)
{	// 付过 矫傈矫埃 拌魂
	const int nMinus = RareEM.GetStaticRareWise(StaticRare) + 
		RareEM.GetDynamicRareValue(FITEM_SLIGHT, DynamicRare); 
	const int nReady = GetCastReady(nMagic)*(100 - nMinus)/100;
	
	switch (Spell)
	{
    case WIZARD_SPELL: 
		{ // 付过荤牢 版快
			const int nTime = nReady*(750 - GetAbility(INT_))/650;