battlemanager.cpp

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

	const WORD idTarget = pPacket->idTarget; // 付过 措惑磊 
	CHARLIST* pCaster = ::GetCharListPtr(idCaster);
	CHARLIST* pTarget = ::GetCharListPtr(idTarget);
	if (pCaster == NULL || pTarget == NULL)  return;  
	// 瓤苞寒俊 措茄 贸府
	const int nX = pPacket->nX;
	const int nY = pPacket->nY;
	
	if (!IsValid(nMagic, nX>>5, nY>>5))
	{
		pCaster->Message(MK_WARNING, 1, 4);
		return;
	}
	
	bool bFail = false;
	// 籍拳俊 吧妨乐栏搁 绢栋茄 付过档 利侩阑 罐瘤 给窃. 窜 历林秦力绰 力寇
	if (pTarget->IsStone() && pPacket->nMagic != REMOVE_CURSE)
	{		
		pCaster->Message(MK_NORMAL, 1, 18);
		pCaster->ClearMagic();
		bFail = true;
		goto MAGIC_FAIL;
	}
	// 辑肺 傍拜 啊瓷咯何 八荤
	if (!IsBattle(pCaster, pTarget))
	{
		pCaster->ClearMagic();
		bFail = true;
		goto MAGIC_FAIL;
	}
	
	// 付过 荤侩捞 啊瓷茄瘤 八荤
	if (!pCaster->CheckDoing(nMagic, g_curr_time))
	{
		pCaster->ClearMagic();
		bFail = true;
		goto MAGIC_FAIL;
	}
	
	if (!FilterMagic(pCaster, pTarget, nX, nY))
	{
		pCaster->ClearMagic();
		bFail = true;
		goto MAGIC_FAIL;
	}
	
	pCaster->ClearMagic(false); // 付过 荤侩捞 登菌澜阑 汲沥
	// CSD-030806
	g_pLogManager->SaveMagicExecute(nMagic, pCaster, pTarget, nX, nY);
	
MAGIC_FAIL:
	memset(&m_packet, 0, sizeof(t_packet));
	m_packet.h.header.type = CMD_MAGIC_EXECUTE;
	m_packet.h.header.size = sizeof(t_server_magic_execute);
	m_packet.u.magic.server_magic_execute.nMagic = nMagic;
	m_packet.u.magic.server_magic_execute.idCaster = idCaster;
	m_packet.u.magic.server_magic_execute.idTarget = idTarget;
	m_packet.u.magic.server_magic_execute.nX = nX;
	m_packet.u.magic.server_magic_execute.nY = nY;
	m_packet.u.magic.server_magic_execute.bFailed = bFail;
	::QueuePacket(connections, idCaster, &m_packet, 1);
	::CastMe2Other(idCaster, &m_packet);
}	//> CSD-TW-030606

void CBattleManager::RecvMagicResult(WORD idCaster, t_client_magic_result* pPacket)
{
	const WORD idTarget = pPacket->idTarget; // 付过阑 荤侩茄 措惑磊
	CHARLIST* pCaster = ::GetCharListPtr(idCaster);
	CHARLIST* pTarget = ::GetCharListPtr(idTarget);
	if (pCaster == NULL || pTarget == NULL)  return;  
	
	const int nMagic = pPacket->nMagic;
	if (nMagic == 0)  return;
	// 瓤苞寒俊 措茄 贸府
	const int nX = pPacket->nX;
	const int nY = pPacket->nY;
	
	if (!IsValid(nMagic, nX>>5, nY>>5))
	{
		pCaster->Message(MK_WARNING, 1, 4);
		return;
	}
	// 籍拳俊 吧妨乐栏搁 绢栋茄 付过档 利侩阑 罐瘤 给窃. 窜 历林秦力绰 力寇
	if (pTarget->IsStone() && nMagic != REMOVE_CURSE)
	{	
		pCaster->ClearMagic();
		return;
	}
	// 付过 利侩捞 啊瓷茄瘤 八荤
	if (!pCaster->CheckEnd(nMagic, g_curr_time))
	{ 
		pCaster->ClearMagic();
		return;
	}  
	// 辑肺 傍拜 啊瓷咯何 八荤
	if (!IsBattle(pCaster, pTarget))
	{
		pCaster->ClearMagic();
		return;
	}
	
	if (!FilterResult(pCaster, pTarget))
	{
		pCaster->ClearMagic();
		return;
	}
	
	pTarget->SetWanted(pPacket->bWanted);    // 泅惑裹牢瘤 咯何 汲沥
	
	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();
}

void CBattleManager::RecvMagicResult(t_magic_result_d* 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 (!FilterResult(pPacket->nMagic, pCaster, pTarget))
	{ 
		return;
	}
	
	const BYTE nMagic = pPacket->nMagic; // 付过狼 锅龋
	const int nX = pPacket->nX;          // 付过捞 惯积等 困摹狼 X谅钎
	const int nY = pPacket->nY;          // 付过捞 惯积等 困摹狼 Y谅钎  
	const int nBattle = Magic_Ref[nMagic].magic_Type/10;
	
	if (nBattle >= 1 && nBattle <= 6)
	{
		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();
	}
}

void CBattleManager::RecvCombatReset(WORD idMaster)
{ // 傈捧胶懦 器牢磐 犁盒硅
	CHARLIST* pMaster = ::GetCharListPtr(idMaster);
	if (pMaster == NULL)  return;
	
	int nCount = pMaster->GetCombatPoint();
	
	for (int i = LIGHTNING_BOOM; i <= WIND_EXTREME; ++i)
	{
		nCount += pMaster->GetCombatLevel(i);
		pMaster->SetCombatLevel(i, 0);
	}
	
	pMaster->SetCombatPoint(nCount);
}

void CBattleManager::RecvCombatObtain(WORD idMaster, t_client_combat_obtain* pPacket)
{
	CHARLIST* pMaster = ::GetCharListPtr(idMaster);
	if (pMaster == NULL)  return;
	
	const int nPoint = pPacket->nPoint;
	const int nOld = pMaster->GetCombatPoint();
	// 力茄摹 八荤
	if (pMaster->IsLimit(nPoint))  
	{
		pMaster->Message(MK_INFORMATION, 1, 58);
		return;
	}
	
	const int nNew = pMaster->GetCombatPoint();
	::SaveObtainCombat(pMaster, nOld, nNew);
	// Packet 傈价
	memset(&m_packet, 0, sizeof(t_packet));
	m_packet.h.header.type = CMD_COMBAT_OBTAIN;
	m_packet.h.header.size = sizeof(t_server_combat_obtain);
	m_packet.u.combat.server_combat_obtain.idMaster = idMaster;
	m_packet.u.combat.server_combat_obtain.nPara = pPacket->nPara;
	m_packet.u.combat.server_combat_obtain.nPosX = pPacket->nPosX;
	m_packet.u.combat.server_combat_obtain.nPosY = pPacket->nPosY;
	m_packet.u.combat.server_combat_obtain.nTotal = pMaster->GetCombatPoint();
	::QueuePacket(connections, idMaster, &m_packet, 1);
}

void CBattleManager::RecvCombatRequest(WORD idMaster, t_client_combat_request* pPacket)
{  
	CHARLIST* pMaster = ::GetCharListPtr(idMaster);
	if (pMaster == NULL)  return;
	// 力茄摹甫 逞菌促搁 檬扁拳
	if (pMaster->IsLimit())  pMaster->InitCombat();
	// Packet 傈价
	memset(&m_packet, 0, sizeof(t_packet));
	m_packet.h.header.type = CMD_COMBAT_REQUEST;
	m_packet.h.header.size = sizeof(t_server_combat_request);
	m_packet.u.combat.server_combat_request.idMaster = idMaster;
	m_packet.u.combat.server_combat_request.nRemain = pMaster->GetCombatPoint();
	
	for (int i = 0; i < 36; ++i)
	{
		m_packet.u.combat.server_combat_request.aLevel[i] = pMaster->GetCombatLevel(i + LIGHTNING_BOOM);
	}
	
	::QueuePacket(connections, idMaster, &m_packet, 1);
}

void CBattleManager::RecvCombatLearn(WORD idMaster, t_client_combat_learn* pPacket)
{  
	CHARLIST* pMaster = ::GetCharListPtr(idMaster);
	if (pMaster == NULL)  return;
	
	const int nCombat = pPacket->nSkill;
	
	if (!IsEnableClass(nCombat, pMaster))  return;
	// 力茄摹甫 逞菌促搁 檬扁拳
	if (pMaster->IsLimit())  
	{
		pMaster->InitCombat();
		return;
	}
	
	switch (nCombat)
	{
    case LIGHTNING_EXTREME:
    case EARTH_EXTREME:
    case FIRE_EXTREME:
    case DARK_EXTREME:
    case ICE_EXTREME:
    case WIND_EXTREME:
		{
			if (!pMaster->IsDual())
			{
				pMaster->Message(MK_SHORTAGE, 1, 54);
				return;
			}
			
			break;
		}
	}
	// 傈捧胶懦 嚼垫
	const int nLevel = pMaster->GetCombatLevel(nCombat) + 1;
	
	if (!IsValid(nCombat, nLevel, pMaster))
	{
		pMaster->Message(MK_SHORTAGE, 1, 54);
		return;
	}
	//< CSD-020909
	const int nPoint = pPacket->nPoint;
	const int nOld = pMaster->GetCombatLevel(nCombat);
	
	if (!pMaster->LevelUpCombat(nCombat, nPoint))
	{
		pMaster->Message(MK_SHORTAGE, 1, 54);
		return;
	}
	
	const int nNew = pMaster->GetCombatLevel(nCombat);
	::SaveChangeCombat(pMaster, nCombat, nOld, nNew);
	//> CSD-020909
	
	// Packet 傈价
	memset(&m_packet, 0, sizeof(t_packet));
	m_packet.h.header.type = CMD_COMBAT_LEARN;
	m_packet.h.header.size = sizeof(t_server_combat_learn);
	m_packet.u.combat.server_combat_learn.idMaster = idMaster;
	m_packet.u.combat.server_combat_learn.nSkill = nCombat;
	m_packet.u.combat.server_combat_learn.nLevel = pMaster->GetCombatLevel(nCombat);
	m_packet.u.combat.server_combat_learn.nRemain = pMaster->GetCombatPoint();
	::QueuePacket(connections, idMaster, &m_packet, 1);
}

void CBattleManager::RecvCombatClear(WORD idMaster, t_client_combat_clear* pPacket)
{	//< CSD-TW-030606
	CHARLIST* pMaster = ::GetCharListPtr(idMaster);
	
	if (pMaster == NULL)
	{
		return;
	}

	pMaster->InitActiveCombat();
	pMaster->ClearActiveState();
	pMaster->ClearPassiveState();
	pMaster->ClearRecoveryState();
	
	memset(&m_packet, 0, sizeof(t_packet));
	m_packet.h.header.type = CMD_COMBAT_CLEAR;
	m_packet.h.header.size = sizeof(t_server_combat_clear);
	m_packet.u.combat.server_combat_clear.idMaster = idMaster;
	m_packet.u.combat.server_combat_clear.nType = 0;
	::QueuePacket(connections, idMaster, &m_packet, 1);
	::CastMe2Other(idMaster, &m_packet);
}	//> CSD-TW-030606

void CBattleManager::RecvCombatSelect(WORD idCaster, t_client_combat_select* pPacket)
{   //< CSD-TW-030623
	CHARLIST* pCaster = ::GetCharListPtr(idCaster);
	if (pCaster == NULL)  return;
	// 辑肺 傍拜 啊瓷咯何 八荤
	if (!IsBattle())                 return;
	if (!IsBattle(pCaster))          return;
	// 荤侩啊瓷茄 傈捧胶懦牢瘤 八荤
	const int nCombat = pPacket->nCombat;
	if (!IsValid(nCombat, pCaster))  return;
	// cp雀汗拌凯 付过捞 惯悼吝老锭绰 酒公巴档 且 荐 绝澜 // 030430 kyo
	if (pCaster->IsRecoveryCombatState())
	{	
		pCaster->Message(MK_INFORMATION, 1, 43);
		return;
	}

	switch (Magic_Ref[nCombat].Spell_Type)
	{
	case ACTIVE_COMBAT:
		{	// Passive 傈捧胶懦 惑怕俊辑 促弗 拌凯狼 傈捧胶懦阑 急琶茄 版快
			const int nPassive = pCaster->GetPassiveCombat();
			
			if (nPassive > 0)
			{				
				if (Magic_Ref[nCombat].order_Type%10 != Magic_Ref[nPassive].order_Type%10)
				{ 
					pCaster->ClearPassiveState();
					pCaster->Message(MK_INFORMATION, 1, 90);
				}
			}
			
			break;
		}
	case PASSIVE_COMBAT:
		{	// Active 加己 傈捧胶懦 惑怕俊辑 促弗 拌凯狼 傈捧胶懦阑 急琶茄 版快
			const int nActive = pCaster->GetActiveCombat();
			
			if (nActive > 0)
			{
				if (Magic_Ref[nCombat].order_Type%10 != Magic_Ref[nActive].order_Type%10)
				{
					pCaster->Message(MK_INFORMATION, 1, 90);
					return;
				}
			}

			break;
		}
	case RECOVERY_COMBAT: // 030415 kyo
		{	// RECOVERY_COMBAT鸥涝 
			const int nRecovery = pCaster->GetRecoveryCombat();

			if (nRecovery > 0)
			{	// cp雀汗 鸥涝篮 active加己阑 檬扁拳 矫挪促.
				pCaster->InitActiveCombat();
				pCaster->ClearActiveState();

				if (Magic_Ref[nCombat].order_Type%10 != Magic_Ref[nRecovery].order_Type%10)
				{
					pCaster->Message(MK_INFORMATION, 1, 90);
					return;
				}
			}

			break;
		}
	}
	
	pCaster->ClearCombat(nCombat);
	// Packet 傈价
	memset(&m_packet, 0, sizeof(t_packet));
	m_packet.h.header.type = CMD_COMBAT_SELECT;
	m_packet.h.header.size = sizeof(t_server_combat_select);
	m_packet.u.combat.server_combat_select.nCombat = nCombat;
	m_packet.u.combat.server_combat_select.idMaster = idCaster;
	::QueuePacket(connections, idCaster, &m_packet, 1);
	::CastMe2Other(idCaster, &m_packet);
}   //> CSD-TW-030623

void CBattleManager::RecvCombatAttack(WORD idCaster, t_client_combat_attack* pPacket)
{	//< CSD-TW-030606
	const int nCombat = pPacket->nSkill;
	const int nX = pPacket->nX;
	const int nY = pPacket->nY;
	const WORD idTarget = pPacket->idTarget; // 付过 措惑磊
	CHARLIST* pCaster = ::GetCharListPtr(idCaster);
	CHARLIST* pTarget = ::GetCharListPtr(idTarget);
	if (pCaster == NULL || pTarget == NULL)  return;
	
	bool bFail = false;
	// 籍拳俊 吧妨乐栏搁 绢栋茄 傈捧胶懦档 利侩阑 罐瘤 给窃
	if (pTarget->IsStone())
	{		
		pCaster->Message(MK_NORMAL, 1, 18);
		bFail = true;
		goto COMBAT_FAIL;
	}
	// 辑肺 傍拜 啊瓷咯何 八荤
	if (!IsBattle())                        return;
	if (!IsBattle(pCaster))                 return;
	if (!IsBattle(pCaster, pTarget))        return;
	// 荤侩啊瓷茄 傈捧胶懦牢瘤 八荤
	if (!IsValid(nCombat, pCaster))         return;
	if (!IsEnableClass(nCombat, pCaster))   return;
	if (!IsEnableWeapon(nCombat, pCaster))  return;
	// 傈捧胶懦 荤侩 咯何 啊瓷 八荤
	if (!FilterCombat(nCombat, pCaster, pTarget, nX, nY))
	{ 
		bFail = true;
		goto COMBAT_FAIL;
	}

	if (!pCaster->IsEnableCombat(nCombat))
	{
		pCaster->Message(MK_SHORTAGE, 1, 57);
		return;
	}
	// 胶懦 荤侩啊瓷荐 犁汲沥
	switch (nCombat)
	{
    case BLOOD_EARTH:
    case TWISTER:
    case POISONING_NOVA:
    case WHILWIND:
		{
			if (pCaster->IsCount())
			{
				ChangeCombat(nCombat, idCaster);
			}
			else
			{
				ResetCombat(nCombat, idCaster);
			}
			
			break;
		}
    default:
		{
			ResetCombat(nCombat, idCaster);
			break;
		}
	}
	// CSD-030806
	g_pLogManager->SaveCombatExecute(nCombat, pCaster, pTarget, nX, nY);
	
COMBAT_FAIL:
	memset(&m_packet, 0, sizeof(t_packet));
	m_packet.h.header.type = CMD_COMBAT_ATTACK;
	m_packet.h.header.size = sizeof(t_server_combat_attack);
	m_packet.u.combat.server_combat_attack.nSkill = nCombat;
	m_packet.u.combat.server_combat_attack.nLevel = pCaster->GetCombatLevel(nCombat);
	m_packet.u.combat.server_combat_attack.idCaster = idCaster;
	m_packet.u.combat.server_combat_attack.idTarget = idTarget;
	m_packet.u.combat.server_combat_attack.wAmount = pCaster->Cp;
	m_packet.u.combat.server_combat_attack.nX = nX;
	m_packet.u.combat.server_combat_attack.nY = nY;
	m_packet.u.combat.server_combat_attack.bFailed = bFail;
	::QueuePacket(connections, idCaster, &m_packet, 1);