battle.cpp

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

// Battle.cpp: implementation of the CBattle class.
//
//////////////////////////////////////////////////////////////////////

#include "..\stdafx.h"
#include "Battle.h"

#include "CItem.h"
#include "OP_Magic.h"
#include "Op_Battle.h"
#include "MenuServer.h"
#include "Npc_Pattern.h"
#include "AIManager.h"
#include "LogManager.h"

extern bool IsWar();
extern bool CanDestroyTarget(CHARLIST* pCaster,CHARLIST* pTarget);
extern void Send_CMD_SEALSTONE_STATUS(LPCHARLIST ch, int status);

///////////////////////////////////////////////////////////////////////////////
// Global Member
///////////////////////////////////////////////////////////////////////////////

static int RATE_BY_CLASS[5][4] = 
{ // 努贰胶狼 公扁喊 焊沥蔼
	{100, 100,  90,  90}, // 傈  荤 : 窜芭府, 吝芭府, 厘芭府(劝), 厘芭府(厚档)
	{ 90,  90, 100, 100}, // 档  利 : 窜芭府, 吝芭府, 厘芭府(劝), 厘芭府(厚档)
	{ 90,  90, 100, 100}, // 泵  荐 : 窜芭府, 吝芭府, 厘芭府(劝), 厘芭府(厚档)
	{ 90, 100,  90, 100}, // 付过荤 : 窜芭府, 吝芭府, 厘芭府(劝), 厘芭府(厚档)
	{ 90, 100,  90, 100}  // 己流磊 : 窜芭府, 吝芭府, 厘芭府(劝), 厘芭府(厚档)
};

///////////////////////////////////////////////////////////////////////////////
// Construction/Destruction
///////////////////////////////////////////////////////////////////////////////

CBattle::CBattle()
{
	m_nIndex = 0;
	m_idCaster = 0; 
	m_idTarget = 0;
	m_pCaster = NULL;
	m_pTarget = NULL;
	m_dwNow = 0; 
	m_nContinue = 0;
	m_nX = 0; 
	m_nY = 0;
}

CBattle::~CBattle() 
{
	
}

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

int CBattle::Relation(int nCaster, int nTarget) const
{ // 傈捧胶懦俊 狼茄 惑己 包拌
	const int nSrcHigh = Magic_Ref[nCaster].order_Type/10;
	const int nSrcLow = Magic_Ref[nCaster].order_Type%10;
	const int nDstHigh = Magic_Ref[nTarget].order_Type/10;
	const int nDstLow =  Magic_Ref[nTarget].order_Type%10;
	if (nSrcHigh == 0 || nDstHigh == 0)  return CSR_NORMAL;
	if (nSrcHigh == nDstHigh)  return (nSrcLow == nDstLow) ? CSR_EQUAL:CSR_CONFLICT;
	
	const int nDiff = abs(nSrcHigh < nDstHigh);
	
	if (nDiff < 2)
	{
		return (nSrcHigh < nDstHigh) ? CSR_PRIOR:CSR_POSTERIOR;
	}
	else
	{
		return (nSrcHigh < nDstHigh) ? CSR_POSTERIOR:CSR_PRIOR;
	}
	
	return CSR_NORMAL;
}

///////////////////////////////////////////////////////////////////////////////
// Protected Method
///////////////////////////////////////////////////////////////////////////////

void CBattle::SendBattleDamage(WORD idTarget, BYTE nKind, int nDamage)
{ //< CSD-021019
	memset(&m_packet, 0, sizeof(t_packet));
	m_packet.h.header.type = CMD_BATTLE_DAMAGE;
	m_packet.h.header.size = sizeof(t_battle_damage);
	m_packet.u.battle.battle_damage.idTarget = idTarget;
	m_packet.u.battle.battle_damage.nKind = nKind;
	m_packet.u.battle.battle_damage.nDamage = nDamage;
	SendPacket(idTarget);
} //> CSD-021019

void CBattle::SendPacket(WORD idTarget)
{ // Packet 傈价
	if (idTarget < 10000)
	{ // 措惑磊啊 PC扼搁
		::QueuePacket(connections, idTarget, &m_packet, 1);
		::CastMe2Other(idTarget, &m_packet);
	}
	else
	{ // 措惑磊啊 NPC扼搁
		::CastNPC2Other(idTarget - 10000, &m_packet);
	}
}

///////////////////////////////////////////////////////////////////////////////
// Construction/Destruction
///////////////////////////////////////////////////////////////////////////////

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

int CStrike::CalcAttack(BYTE nType) const
{
	const int nCaster = m_pCaster->GetActiveCombat();
	const int nTarget = m_pTarget->GetActiveCombat();
	const int nResult = Relation(nCaster, nTarget);
	
	int nPercent = 0;
	
	if (!m_pTarget->IsIgnorePhysicalAttack())
	{
		// 傈捧胶懦俊 狼茄 傍拜仿 焊沥
		switch (nCaster)
		{ //< CSD-021127
		case THUNDER_BLOW:
		case THUNDER_STRIKE:
		case BLOOD_WILL:
		case FLEET_MISSILE:
			{ 
				nPercent += m_pCaster->CorrectCombatAttack(nCaster, nResult);
				break;
			}
		case SWORD_N_ROSES:
		case MULTIPLE_FIRE:
		case ICING_BLAST:
		case DOUBLE_ATTACK:
			{
				nPercent -= (100 - m_pCaster->CorrectCombatAttack(nCaster, nResult));
				break;
			}
		case CHERROY_SHADE:
			{ // 鸥拜 措惑磊绰 龙捍狼 瓤苞
				if (!IsCurseEnable(m_pTarget))
				{
					break;
				}
				
				if (m_pTarget->IsCurseAvoid(Magic_Ref[nCaster].magic_Type))
				{
					break;
				}
				
				if (m_pTarget->IsCurseDefense(Magic_Ref[nCaster].magic_Type))
				{
					break;
				}
				
				const int nTemp = m_pTarget->HungryMax*m_pCaster->GetCombatValue(CHERROY_SHADE)/100;
				m_pTarget->DecHungry(nTemp);
				m_pTarget->SendCharInfoBasic(SP, m_pTarget->Hungry);
				break;
			}
		case DARK_BLADE:
			{ // 鸥拜 措惑磊绰 加档历窍狼 瓤苞
				if (!IsCurseEnable(m_pTarget))
				{
					break;
				}
				
				if (m_pTarget->IsCurseAvoid(Magic_Ref[nCaster].magic_Type))
				{
					break;
				}
				
				if (m_pTarget->IsCurseDefense(Magic_Ref[nCaster].magic_Type))
				{
					break;
				}
				
				const int nTemp = m_pCaster->CorrectCombatAttack(nCaster, nResult);
				WORD wRemain = GetContinueTime(nCaster);
				m_pTarget->speedDown.SetState(m_dwNow + wRemain, nTemp);
				m_pTarget->ApplyCurse(2, CON_SLOW, m_dwNow + wRemain);
				::SendCharacterCondition(m_pTarget, 0);
				break;
			}
		case HORN_OF_ICEBERG:
			{ // 鸥拜 措惑磊绰 倔覆狼 瓤苞
				if (!IsCurseEnable(m_pTarget))
				{
					break;
				}
				
				if (m_pTarget->IsCurseAvoid(Magic_Ref[nCaster].magic_Type))
				{
					break;
				}
				
				if (m_pTarget->IsCurseDefense(Magic_Ref[nCaster].magic_Type))
				{
					break;
				}
				
				WORD wRemain = m_pCaster->CorrectCombatAttack(nCaster, nResult);
				m_pTarget->dwAttackDelay = m_dwNow + wRemain;
				m_pTarget->ApplyCurse(6, CON_FROZEN, m_dwNow + wRemain);
				::SendCharacterCondition(m_pTarget, 0);
				break;
			}
		} //> CSD-021127
		// 付过俊 狼茄 傍拜仿 焊沥
		switch (nType)
		{	//< CSD-030723
		case WR_SHORT:  nPercent += m_pCaster->GetShortAttack();  break;
		case WR_MIDDLE: nPercent += m_pCaster->GetMiddleAttack(); break;
		case WR_LONG1:
		case WR_LONG2:  nPercent += m_pCaster->GetLongAttack();   break;
		}	//> CSD-030723
	}
	
	return m_pCaster->CalcPhysicalStrikingPower(nPercent, 0);
}

int CStrike::CalcDefense(int nAttack) const
{
	int nPercent = 0;
	// 规绢仿 拌魂
	return m_pTarget->CalcPhysicalDefensivePower(nAttack, nPercent);
}

int CStrike::CalcDamage(BYTE nType, int nDamage) const
{
	const int nCaster = m_pCaster->GetActiveCombat();
	const int nTarget = m_pTarget->GetPassiveCombat();
	const int nResult = Relation(nCaster, nTarget);
	
	int nPlus = 0, nMinus = 0;
	
	if (!m_pCaster->IsStrikePiercing())
	{	// 傈捧胶懦俊 狼茄 单固瘤 焊沥
		switch (nCaster)
		{
		case LIGHTNING_SHOCK:
			{
				if (m_pCaster->CorrectCombatAttack(nCaster, nResult) > rand()%101)
				{
					return nDamage;
				}
				
				break;
			}
		case CONVERTING_ARMOR:
			{
				nMinus += m_pCaster->CorrectCombatAttack(nCaster, nResult);
				break;
			}
		}
		
		switch (nTarget)
		{
		case LIGHTNING_SHIELD:
		case ICE_SHIELD:
			{
				nPlus += m_pTarget->CorrectCombatDefense(nTarget, nResult);
				break;
			}
		}
		
		switch (m_pTarget->GetActiveCombat())
		{
		case STONE_ARMOR:
			{				
				if (m_pTarget->IsCount())
				{
					const int nCount = m_pTarget->DecCombatCount();
					m_pTarget->SendCharInfoBasic(BP, nCount);//020704 lsw
					return 0;
				}
				else
				{	//< CSD-TW-030623 : 傈捧胶懦 檬扁拳
					m_pTarget->InitActiveCombat();
					m_pTarget->ClearActiveState();
					// 包访 Packet 傈价  
					t_packet packet;
					packet.h.header.type = CMD_COMBAT_INIT;
					packet.h.header.size = sizeof(t_combat_init);
					packet.u.combat.combat_init.idMaster = m_idTarget;
					packet.u.combat.combat_init.nType = ACTIVE_COMBAT;
					::QueuePacket(connections, m_idTarget, &packet, 1);
				}	//> CSD-TW-030623
				
				break;
			}
		}
		// 付过俊 狼茄 单固瘤 焊沥
		switch (nType)
		{	//< CSD-030723
		case WR_SHORT:  m_pTarget->CorrectShortDamage(nDamage, nPlus, nMinus);  break;
		case WR_MIDDLE: m_pTarget->CorrectMiddleDamage(nDamage, nPlus, nMinus); break;
		case WR_LONG1:
		case WR_LONG2:  m_pTarget->CorrectLongDamage(nDamage, nPlus, nMinus);   break;
		}	//> CSD-030723
	}
	
	return nDamage;
}

bool CStrike::IsCurseEnable(CHARLIST* pTarget) const
{	//< CSD-021216
	if (pTarget->IsNpc())
	{
		switch (pTarget->Race)
		{
		case DUMMY:
		case HUMAN:
		case GUARD:
		case ORC_DUMMY:
		case SEALSTONE:
		case GUARDSTONE: return false;
			//case CASTLEGATEWAY: 固搬沥
			//case WARARMS: 固搬沥5
		}
	}
	
	return (pTarget->IsPerfect()) ? false:true;
}	//> CSD-021216

///////////////////////////////////////////////////////////////////////////////
// Construction/Destruction
///////////////////////////////////////////////////////////////////////////////

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

void CMagic::InitMagicResult(int nType)
{	//< CSD-TW-030606 : Packet 檬扁拳
	memset(&m_packet, 0, sizeof(t_packet));
	m_packet.h.header.type = nType;
	
	switch (nType)
	{
    case CMD_MAGIC_RESULT: 
		{
			m_packet.h.header.size = sizeof(t_server_magic_result);
			break;
		}
    case CMD_MAGIC_RESULT_T: 
		{
			m_packet.h.header.size = sizeof(t_server_magic_result_t); 
			break;
		}
    case CMD_MAGIC_RESULT_H: 
		{
			m_packet.h.header.size = sizeof(t_server_magic_result_h); 
			break;
		}
    case CMD_MAGIC_RESULT_M:
		{
			m_packet.h.header.size = sizeof(t_server_magic_result_m); 
			break;
		}
	}
	
	m_nType = nType;
}	//> CSD-TW-030606

void CMagic::SendMagicResult()
{	//< CSD-TW-030606 : 措惑磊俊霸 Packet 焊郴扁
	const int nMagic = m_pCaster->GetMagic();
	WORD idTarget = 0;
	
	switch (m_nType)
	{
    case CMD_MAGIC_RESULT:
		{
			idTarget = m_packet.u.magic.server_magic_result.idTarget;
			::SaveBallancing(m_pCaster, m_pTarget, nMagic, 0, 0, 0, 0, 0);
			break;
		}
    case CMD_MAGIC_RESULT_T: 
		{
			idTarget = m_packet.u.magic.server_magic_result_t.idTarget;
			::SaveBallancing(m_pCaster, m_pTarget, nMagic, 0, 0, 0, 0, 0);
			break;
		}
    case CMD_MAGIC_RESULT_H: 
		{
			idTarget = m_packet.u.magic.server_magic_result_h.idTarget;
			const int nLife = m_packet.u.magic.server_magic_result_h.nLife;
			::SaveBallancing(m_pCaster, m_pTarget, nMagic, nLife, 0, 0, 0, 0);
			break;
		}
    case CMD_MAGIC_RESULT_M:
		{
			idTarget = m_packet.u.magic.server_magic_result_m.idTarget;
			const int nLife = m_packet.u.magic.server_magic_result_m.nLife;
			const int nMana = m_packet.u.magic.server_magic_result_m.nMana;
			::SaveBallancing(m_pCaster, m_pTarget, nMagic, nLife, nMana, 0, 0, 0);
			break;
		}  
	}
	
	CBattle::SendPacket(idTarget);
}	//> CSD-TW-030606

///////////////////////////////////////////////////////////////////////////////
// Protected Method
///////////////////////////////////////////////////////////////////////////////

int CMagic::CalcPeriod() const
{
	const int nContinue = GetContinueTime(m_nIndex);
	const int nType = GetMagicType(m_nIndex);
	const int nResist = GetResistType(m_nIndex);
	// 绊蜡 蜡瘤 矫埃 拌魂
	int nPlus = 0, nMinus = 0;
	
	if ( m_nContinue > 0)
	{
		nPlus = m_nContinue;
		nMinus = m_pTarget->CalcResistPeriod(nResist, nPlus);
	}
	else
	{  
		nPlus = m_pCaster->CalcMagicPeriod(nType, nContinue);
		nMinus = m_pTarget->CalcResistPeriod(nResist, nPlus);
	}
	
	return nPlus - nMinus;
}
int CMagic::CalcMaintain() const
{// 030521 kyo
	return GetContinueTime(m_nIndex);
}


int CMagic::CalcHitDice() const
{
	const int nHD = GetMagicDamage(m_nIndex);
	const int nGap = m_pCaster->GetLevel() - m_pTarget->GetLevel(); // CSD-030806
	return nHD + nGap/10*nHD/20;
}

int CMagic::CalcAttack(int nBase) const
{
	const int nCaster = m_pCaster->GetActiveCombat();
	const int nTarget = m_pTarget->GetActiveCombat();
	const int nResult = Relation(nCaster, nTarget);
	
	int nPercent = 0, nAdd = 0;
	
	if (!m_pTarget->IsIgnoreMagicAmplify())
	{ // 付过俊 狼茄 傍拜仿 焊沥
		nPercent += m_pCaster->GetMagicAmplify();
	}
	
	return m_pCaster->CalcMagicStrikingPower(nBase, nPercent, nAdd);
}

int CMagic::CalcDefense(int nAttack) const
{
	int nResist = RESIST_IGNORE, nPercent = 0;
	
	if (!m_pCaster->IsIgnoreMagicResist() || m_pTarget->IsNpc()) 
	{ //< CSD-021128
		nResist = Magic_Ref[m_nIndex].nResist;
	} //> CSD-021128
	// 规绢仿 拌魂
	return m_pTarget->CalcMagicDefensivePower(nResist, nAttack, nPercent);
}

int CMagic::CalcDamage(BYTE nType, int nDamage) const
{ 
	const int nCaster = m_pCaster->GetActiveCombat();
	const int nTarget = m_pTarget->GetPassiveCombat();
	const int nResult = Relation(nCaster, nTarget);
	
	int nPlus = 0, nMinus = 0;
	
	if (!m_pCaster->IsMagicPiercing())
	{ //< CSD-021024
		switch (nTarget)
		{
		case LIGHTNING_SHIELD:
			{
				if (nType == RESIST_ELECT)
				{
					nPlus += m_pTarget->CorrectCombatDefense(nTarget, nResult);
				}
				
				break;
			}
		case ICE_SHIELD:
			{
				if (nType == RESIST_ICE)
				{
					nPlus += m_pTarget->CorrectCombatDefense(nTarget, nResult);
				}
				
				break;
			}
		}
		
		switch (nType)
		{
		case RESIST_FIRE:  m_pTarget->CorrectFireDamage(nDamage, nPlus, nMinus);  break;
		case RESIST_ICE:   m_pTarget->CorrectIceDamage(nDamage, nPlus, nMinus);   break;
		case RESIST_ELECT: m_pTarget->CorrectElectDamage(nDamage, nPlus, nMinus); break;
		case RESIST_HOLY:  m_pTarget->CorrectHolyDamage(nDamage, nPlus, nMinus);  break;
		}
	} //> CSD-021024