battlemanager.cpp

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

	case TACTICS_Archery: // 厘芭府 公扁
	case TACTICS_Hurl:
		{ 
			return;
		}
    case TACTICS_Whirl:   // 吝芭府 公扁
    case TACTICS_Pierce:
    case TACTICS_Magery:
    case TACTICS_Orison:    
		{ 
			GetBattle(nBattle)->SetIndex(WR_MIDDLE);
			break;
		}
    default:              //	窜芭府 公扁  
		{ 
			GetBattle(nBattle)->SetIndex(WR_SHORT);
			break;
		}
	}
	
	GetBattle(nBattle)->SetCurrentTime(g_curr_time);
	GetBattle(nBattle)->SetBothID(idCaster, idTarget);
	GetBattle(nBattle)->SetBothPtr(pCaster, pTarget);
	// 傍拜 冉荐 汲沥
	int nCount = 1;
	
	switch (nCombat)
	{
    case SWORD_N_ROSES: nCount = pCaster->GetCombatLevel(nCombat); break;
    case DOUBLE_ATTACK: nCount = 2;                                break;
	}
	
	for (int i = 0; i < nCount; ++i)
	{
		GetBattle(nBattle)->Execute();
	}
}	//> CSD-030723

void CBattleManager::RecvNpcThrow(t_npc_throw* pPacket)
{
	const WORD idCaster = pPacket->idCaster;
	const WORD idTarget = pPacket->idTarget;
	CHARLIST* pCaster = ::GetCharListPtr(idCaster);
	CHARLIST* pTarget = ::GetCharListPtr(idTarget);
	if (pCaster == NULL || pTarget == NULL)  return;
	if (!FilterNpcAttack(pCaster, pTarget))  return;
	// Packet 傈价
	memset(&m_packet, 0, sizeof(t_packet));
	m_packet.h.header.type = CMD_THROW_ATTACK;
	m_packet.h.header.size = sizeof(t_server_throw_attack);
	m_packet.u.strike.server_throw_attack.idCaster = idCaster;
	m_packet.u.strike.server_throw_attack.idTarget = idTarget;
	m_packet.u.strike.server_throw_attack.nX = pTarget->Tox;
	m_packet.u.strike.server_throw_attack.nY = pTarget->Toy;
	::CastNPC2Other(idCaster - 10000, &m_packet);
}

void CBattleManager::RecvThrowAttack(WORD idCaster, t_client_throw_attack* pPacket)
{	//< CSD-TW-030606
	const WORD idTarget = pPacket->idTarget;
	CHARLIST* pCaster = ::GetCharListPtr(idCaster);
	CHARLIST* pTarget = ::GetCharListPtr(idTarget);
	if (pCaster == NULL || pTarget == NULL)     return;
	// 傍拜 啊瓷咯何 八荤
	if (g_block_attack)                         return;
	if (!IsBattle(pCaster))                     return;
	if (!IsBattle(pCaster, pTarget))            return;
	if (!pCaster->CheckAttack(2, g_curr_time))  return;
	
	const int nCombat = pCaster->GetActiveCombat();
	ClearCombat(nCombat, idCaster);
	if (!FilterAttack(pCaster, pTarget))        return;
	// 泅惑裹牢瘤 咯何 汲沥
	pTarget->SetWanted(pPacket->bWanted);
	// CSD-030806
	g_pLogManager->SaveThrowAttack(pCaster, pTarget);

	switch (pCaster->GetTacticsKind())
	{	
	case TACTICS_Archery: // 劝筋扁
		{
			if (!pCaster->IsArrow())
			{
				pCaster->Message(MK_SHORTAGE, 0, 31);
				return;
			}
		}
	case TACTICS_Hurl: // 厚八 带瘤扁
		{ 
			memset(&m_packet, 0, sizeof(t_packet));
			m_packet.h.header.type = CMD_THROW_ATTACK;
			m_packet.h.header.size = sizeof(t_server_throw_attack);
			m_packet.u.strike.server_throw_attack.idCaster = idCaster;
			m_packet.u.strike.server_throw_attack.idTarget = idTarget;
			m_packet.u.strike.server_throw_attack.nX = pTarget->Tox;
			m_packet.u.strike.server_throw_attack.nY = pTarget->Toy;
			m_packet.u.strike.server_throw_attack.nCombat = pCaster->GetActiveCombat();
			::QueuePacket(connections, idCaster, &m_packet, 1);
			::CastMe2Other(idCaster, &m_packet);
			break;
		}
	}
}	//> CSD-TW-030606

void CBattleManager::RecvThrowResult(WORD idCaster, t_client_throw_result* pPacket)
{	//< CSD-030723
	const WORD idTarget = pPacket->idTarget; // 付过阑 荤侩茄 措惑磊
	CHARLIST* pCaster = ::GetCharListPtr(idCaster);
	CHARLIST* pTarget = ::GetCharListPtr(idTarget);
	if (pCaster == NULL || pTarget == NULL)  return;  
	if (!FilterThrow(pCaster, pTarget))      return;

	// 泅惑裹牢瘤 咯何 汲沥
	pTarget->SetWanted(pPacket->bWanted);
	// 历林加己 汲沥
	AutoCurse(idCaster, idTarget);
	
	const int nBattle = 0; 
	
	switch (pCaster->GetTacticsKind())
	{	
	case TACTICS_Archery: 
		{ 
			GetBattle(nBattle)->SetIndex(WR_LONG1);
			break; 
		}
	case TACTICS_Hurl:    
		{ 
			if (pCaster->GetWeaponKind() == IK_THROW_EVENT)
			{	// 传轿框
				GetBattle(nBattle)->SetIndex(WR_LONG3);
			}
			else
			{	// 厚八 带瘤扁
				GetBattle(nBattle)->SetIndex(WR_LONG2);
			}
			
			break;
		}
	default:
		{
			return;
		}
	}  
	
	GetBattle(nBattle)->SetCurrentTime(g_curr_time);
	GetBattle(nBattle)->SetBothID(idCaster, idTarget);
	GetBattle(nBattle)->SetBothPtr(pCaster, pTarget);
	GetBattle(nBattle)->Execute();
}	//> CSD-030723

void CBattleManager::RecvEffectResult(WORD idCaster, t_client_effect_result* pPacket)
{	//< CSD-031007
	const WORD wdEffect = pPacket->wdEffect;
	const WORD idTarget = pPacket->idTarget;
	CHARLIST* pCaster = ::GetCharListPtr(idCaster);
	CHARLIST* pTarget = ::GetCharListPtr(idTarget);
	if (pCaster == NULL || pTarget == NULL)  return;
	// 辑肺 傍拜 啊瓷咯何 八荤
	if (!IsBattle())
	{
		return;
	}

	if (!IsBattle(pCaster))
	{
		return;
	}

	if (!IsBattle(pCaster, pTarget))
	{
		return;
	}

	if (!FilterAttack(pCaster, pTarget))
	{
		return;
	}
	
	pTarget->SetWanted(pPacket->bWanted); // 泅惑裹牢瘤 咯何 汲沥
	
	const int nBattle = 0;
	const int nX = pPacket->nX;           // 傈捧胶懦捞 惯积等 困摹狼 X谅钎
	const int nY = pPacket->nY;           // 傈捧胶懦捞 惯积等 困摹狼 Y谅钎
	GetBattle(nBattle)->SetIndex(WR_EFFECT);
	GetBattle(nBattle)->SetBothID(idCaster, idTarget);
	GetBattle(nBattle)->SetBothPtr(pCaster, pTarget);
	GetBattle(nBattle)->SetCurrentTime(g_curr_time);
	GetBattle(nBattle)->SetContinueTime(0);
	GetBattle(nBattle)->SetPosition(nX>>5, nY>>5);
	GetBattle(nBattle)->Execute();
}	//< CSD-031007

void CBattleManager::RecvMagicLearn(WORD idMaster, k_client_learn_magic* pPacket)
{
	CHARLIST* pMaster = ::GetCharListPtr(idMaster);
	if (pMaster == NULL)  return;
	
	const int nMagic = pPacket->num;
	
	switch (pMaster->Spell)
	{
    case WIZARD_SPELL:
		{
			if (!IsEnableClass(nMagic, pMaster))  
			{
				return;
			}
			
			if (pMaster->Ws[nMagic])
			{
				::SendServerResult(CM_LEARN_MAGIC, 2, idMaster);
				return;
			}
			
			break;
		}
    case PRIEST_SPELL:
		{
			if (!IsEnableClass(nMagic + 150, pMaster))  
			{
				return;
			}
			
			if (pMaster->Ps[nMagic] != 0)	
			{
				::SendServerResult(CM_LEARN_MAGIC, 2, idMaster);
				return;
			}
			
			break;
		}
	}
	
	switch (::CanLearnMagic(nMagic, pMaster))
	{
	case 1:	 
		{
			::SendLearnMagicOk(nMagic, idMaster);	
			break;
		}
    case 3:	 
		{
			::SendServerResult(CM_LEARN_MAGIC, 3, idMaster);	
			return;
		}
    case 4:	 
		{
			::SendServerResult(CM_LEARN_MAGIC, 4, idMaster);	
			return;
		}
	default:	
		{
			return;
		}
	}
	
	switch (pMaster->Spell)
	{
    case WIZARD_SPELL:
		{
			::SubtractMoney(Magic_Ref[nMagic].Price, pMaster);
			pMaster->Ws[nMagic] = true;
			break;
		}
    case PRIEST_SPELL:
		{
			pMaster->Ps[nMagic] = true;
			break;
		}
	}
}

void CBattleManager::RecvNpcMagic(t_client_npc_magic* pPacket)
{
	const WORD idCaster = pPacket->idCaster; // 付过阑 荤侩茄 矫傈磊
	const WORD idTarget = pPacket->idTarget; // 付过阑 荤侩茄 措惑磊
	const int nMagic = pPacket->nMagic;
	const bool bTimeDisable = pPacket->bTimeDisable;	// LTS DRAGON MODIFY
	
	CHARLIST* pCaster = ::GetCharListPtr(idCaster);
	CHARLIST* pTarget = ::GetCharListPtr(idTarget);
	if (pCaster == NULL || pTarget == NULL)  return;  
	
	switch (nMagic)
	{
    case FIRE_ARROW:
    case ICE_ARROW: 
		{ // 拳堪拳混捞唱 倔澜拳混牢 版快绰 拱府利 傍拜栏肺 贸府
			return;
		}
    case SUMMONING_SKELETON: // 胶奶饭沛欧 家券
    case SUMMONING_UNDEAD:   // 攫单靛 家券
		{
			if (pCaster->m_xSummon.Count() >= Magic_Ref[nMagic].nCombatCount)
			{ // 家券等 阁胶磐荐啊 弥措扼搁 付过阑 角青窍瘤 臼澜
				return;
			}
			
			break;
		}
	}
	
	if (!bTimeDisable && !pCaster->CheckDelay(nMagic, g_curr_time))		// LTS DRAGON MODIFY
	{
		pCaster->ClearMagic();
		return;
	}
	
	bool bFail = false;
	// 籍拳俊 吧妨乐栏搁 绢栋茄 付过档 利侩阑 罐瘤 给窃. 窜 历林秦力绰 力寇
	if (pTarget->IsStone() && pPacket->nMagic != REMOVE_CURSE)
	{		
		bFail = true;
		goto MAGIC_FAIL;
	}
	// 付过 荤侩 魂免 咯何 啊瓷 八荤
	if (!FilterNpcMagic(nMagic, pCaster, pTarget, pPacket->nX, pPacket->nY))
	{ 
		bFail = true;
		goto MAGIC_FAIL;
	}
	
MAGIC_FAIL:
	memset(&m_packet, 0, sizeof(t_packet));
	m_packet.h.header.type = CMD_NPC_MAGIC;
	m_packet.h.header.size = sizeof(t_server_npc_magic);
	m_packet.u.magic.server_npc_magic.nMagic = pPacket->nMagic;
	m_packet.u.magic.server_npc_magic.idCaster = idCaster;
	m_packet.u.magic.server_npc_magic.idTarget = idTarget;
	m_packet.u.magic.server_npc_magic.nX = pPacket->nX;
	m_packet.u.magic.server_npc_magic.nY = pPacket->nY;
	m_packet.u.magic.server_npc_magic.bFailed = false;
	::CastNPC2Other(idCaster - 10000, &m_packet);
}

void CBattleManager::RecvNpcRecall(t_client_npc_magic* pPacket)
{ //< CSD-021119
	const WORD idCaster = pPacket->idCaster; // 付过阑 荤侩茄 矫傈磊
	const WORD idTarget = pPacket->idTarget; // 付过阑 荤侩茄 措惑磊
	const int nMagic = pPacket->nMagic;
	const int nX = pPacket->nX;
	const int nY = pPacket->nY;
	CHARLIST* pCaster = ::GetCharListPtr(idCaster);
	CHARLIST* pTarget = ::GetCharListPtr(idTarget);
	if (pCaster == NULL || pTarget == NULL)  return;  
	// 付过 荤侩 魂免 咯何 啊瓷 八荤
	if (!FilterNpcMagic(nMagic, pCaster, pTarget, nX, nY))
	{ 
		return;
	}
	
	const int nBattle = Magic_Ref[nMagic].magic_Type/10;
	GetBattle(nBattle)->SetIndex(nMagic);
	GetBattle(nBattle)->SetBothID(idCaster, idTarget);
	GetBattle(nBattle)->SetBothPtr(pCaster, pTarget);
	GetBattle(nBattle)->SetCurrentTime(g_curr_time);
	GetBattle(nBattle)->SetContinueTime(0);
	GetBattle(nBattle)->SetPosition(nX>>5, nY>>5);
	GetBattle(nBattle)->Execute();
} //> CSD-021119

void CBattleManager::RecvNpcTeleport(t_client_npc_magic* pPacket)
{	//< CSD-030306
	const WORD idCaster = pPacket->idCaster; // 付过阑 荤侩茄 矫傈磊
	const WORD idTarget = pPacket->idTarget; // 付过阑 荤侩茄 措惑磊
	const int nMagic = pPacket->nMagic;
	const int nX = pPacket->nX;
	const int nY = pPacket->nY;
	CHARLIST* pCaster = ::GetCharListPtr(idCaster);
	CHARLIST* pTarget = ::GetCharListPtr(idTarget);
	if (pCaster == NULL || pTarget == NULL)  return;  
	// 付过 荤侩 魂免 咯何 啊瓷 八荤
	if (!FilterNpcMagic(nMagic, pCaster, pTarget, nX, nY))
	{ 
		return;
	}
	
	const int nBattle = Magic_Ref[nMagic].magic_Type/10;
	GetBattle(nBattle)->SetIndex(nMagic);
	GetBattle(nBattle)->SetBothID(idCaster, idTarget);
	GetBattle(nBattle)->SetBothPtr(pCaster, pTarget);
	GetBattle(nBattle)->SetCurrentTime(g_curr_time);
	GetBattle(nBattle)->SetContinueTime(0);
	GetBattle(nBattle)->SetPosition(nX>>5, nY>>5);
	GetBattle(nBattle)->Execute();
} //> CSD-030306

void CBattleManager::RecvMagicSelect(WORD idCaster, t_client_magic_select* pPacket)
{	//< CSD-TW-030623
	CHARLIST* pCaster = ::GetCharListPtr(idCaster);
	
	if (pCaster == NULL)
	{
		return;
	}

	if (pCaster->IsRecoveryCombatState())
	{
		pCaster->Message(MK_NORMAL, 1, 42);
		return;
	}

	pCaster->InitActiveCombat();
	pCaster->ClearActiveState();
	pCaster->ClearPassiveState();
	pCaster->ClearRecoveryState();
	
	memset(&m_packet, 0, sizeof(t_packet));
	m_packet.h.header.type = CMD_MAGIC_SELECT;
	m_packet.h.header.size = sizeof(t_server_magic_select);
	m_packet.u.magic.server_magic_select.idCaster = idCaster;
	m_packet.u.magic.server_magic_select.nMagic = pPacket->nMagic;
	::QueuePacket(connections, idCaster, &m_packet, 1);
	::CastMe2Other(idCaster, &m_packet);
}	//> CSD-TW-030623

void CBattleManager::RecvMagicCasting(WORD idCaster, t_client_magic_casting* pPacket)
{	//< CSD-TW-030606
	CHARLIST* pCaster = GetCharListPtr(idCaster);
	if (pCaster == NULL)  return;  
	// 付过 矫傈 八荤 汲沥
	const BYTE nMagic = pPacket->nMagic;
	const DWORD dwNow = g_curr_time + RareEM.GetStaticRareBear(pCaster->StaticRare);
	
	if (!pCaster->CheckStart(nMagic, g_curr_time)) 
	{ 
		pCaster->ClearMagic();
		return;
	}
	// 辑肺 傍拜 啊瓷咯何 八荤
	if (!IsBattle(pCaster))  
	{
		pCaster->ClearMagic();
		return;
	}
	// 付过 矫傈 魂免 咯何 啊瓷 八荤
	if (!FilterStart(pCaster))
	{ 
		pCaster->ClearMagic();
		return;
	}
	
	memset(&m_packet, 0, sizeof(t_packet));
	m_packet.h.header.type = CMD_MAGIC_CASTING;
	m_packet.h.header.size = sizeof(t_server_magic_casting);
	m_packet.u.magic.server_magic_casting.nMagic = nMagic;
	m_packet.u.magic.server_magic_casting.wReady = WORD(pCaster->CalcMagicCastReady(nMagic));
	m_packet.u.magic.server_magic_casting.idCaster = idCaster;
	::QueuePacket(connections, idCaster, &m_packet, 1);
	::CastMe2Other(idCaster, &m_packet);
}	//> CSD-TW-030606

void CBattleManager::RecvMagicExecute(WORD idCaster, t_client_magic_execute* pPacket)
{	//< CSD-TW-030606
	const int nMagic = pPacket->nMagic;
	// 拳堪拳混捞唱 倔澜拳混牢 版快绰 拱府利 傍拜栏肺 贸府
	switch (nMagic)
	{
    case FIRE_ARROW:
    case ICE_ARROW: return;
	}