tacticmanager.cpp

墨香最新私服

// TacticManager.cpp: implementation of the CTacticManager class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "TacticManager.h"
#include "PartyManager.h"
#include "Party.h"
#include "UserTable.h"
#include "TacticStartInfo.h"
#include "Player.h"
#include "TacticObject.h"
#include "ObjectStateManager.h"

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

DWORD TacticErrorCode = 0;
#define GotoTacticError(tag,ErrorCode)	{							\
									TacticErrorCode = ErrorCode;	\
									goto tag;						\
										}
		

CTacticManager::CTacticManager()
{
	m_TacticInfoTable.Initialize(64);
	m_GarbageTacticTable.Initialize(64);
}

CTacticManager::~CTacticManager()
{
	m_TacticInfoTable.SetPositionHead();
	while(CTacticStartInfo* pTacticInfo = m_TacticInfoTable.GetData())
	{
		delete pTacticInfo;
	}
	m_TacticInfoTable.RemoveAll();
}

void CTacticManager::AddTacticStartInfo(TACTICSTART_INFO* pList)
{
	ASSERT(m_TacticInfoTable.GetData(pList->TacticID) == NULL);

	CTacticStartInfo* pInfo = new CTacticStartInfo(pList);
	m_TacticInfoTable.Add(pInfo,pList->TacticID);
}

CTacticStartInfo* CTacticManager::GetTacticStartInfo(WORD TacticID)
{
	CTacticStartInfo* pInfo = m_TacticInfoTable.GetData(TacticID);
	return pInfo;
}
void CTacticManager::OnTacticStartReceived(CPlayer* pPlayer, SEND_TACTIC_START* pmsg)
{
	ASSERT(pPlayer);
	CTacticStartInfo* pTacticInfo = GetTacticStartInfo(pmsg->TacticID);
	
	CParty* pParty = PARTYMGR->GetParty(pPlayer->GetPartyIdx());
	if(pParty == NULL)
		GotoTacticError(tacticstart_failed,eTSEC_NoParty);

	if(pParty->GetTacticObjectID() != 0)
		GotoTacticError(tacticstart_failed,eTSEC_AlreadyPartyDoingTactic);
		
	if(pTacticInfo->IsTacticableState(pPlayer) == FALSE)
		GotoTacticError(tacticstart_failed,eTSEC_NotTacticableState);

	if(pTacticInfo->IsTacticablePosition(pPlayer,DIRTODEG(pmsg->Direction)) == FALSE)
		GotoTacticError(tacticstart_failed,eTSEC_NotTacticablePosition);
	
	RegistTacticObject(pTacticInfo,pPlayer,pmsg->Direction);
	
	OBJECTSTATEMGR_OBJ->StartObjectState(pPlayer, eObjectState_Tactic, 0);
	
	return;

tacticstart_failed:
	MSG_DWORD msg;
	msg.Category = MP_TACTIC;
	msg.Protocol = MP_TACTIC_START_NACK;
	msg.dwObjectID = pPlayer->GetID();
	msg.dwData = TacticErrorCode;
	pPlayer->SendMsg(&msg,sizeof(msg));
}

void CTacticManager::OnTacticJoinReceived(CPlayer* pPlayer, SEND_TACTIC_JOIN* pmsg)
{
	CParty* pParty;
	CTacticObject* pTacticObj;

	if(pPlayer->GetPartyIdx() == 0)
		GotoTacticError(tacticjoin_failed,eTJEC_NoPartyIdx);

	pParty = PARTYMGR->GetParty(pPlayer->GetPartyIdx());
	if(pParty == NULL)
		GotoTacticError(tacticjoin_failed,eTJEC_NoPartyInstance);

	if(pParty->GetTacticObjectID() == 0)
		GotoTacticError(tacticjoin_failed,eTJEC_NotPartyTacticState);

	if(pParty->GetTacticObjectID() != pmsg->TacticObjectID)
		GotoTacticError(tacticjoin_failed,eTJEC_NotEqualBetweenMSGnPartyTactic);

	pTacticObj = GetTacticObject(pmsg->TacticObjectID);
	if(pTacticObj == NULL)
		GotoTacticError(tacticjoin_failed,eTJEC_NoTacticObject);

	pTacticObj->TacticJoin(pPlayer,pmsg->Position);
		
	OBJECTSTATEMGR_OBJ->StartObjectState(pPlayer, eObjectState_Tactic, 0);

	return;

tacticjoin_failed:
	MSG_DWORD msg;
	msg.Category = MP_TACTIC;
	msg.Protocol = MP_TACTIC_JOIN_NACK;
	msg.dwObjectID = pPlayer->GetID();
	msg.dwData = TacticErrorCode;
	pPlayer->SendMsg(&msg,sizeof(msg));	
}


void CTacticManager::RegistTacticObject(CTacticStartInfo* pInfo,CPlayer* pOperator,DIRINDEX Direction)
{
	BASEOBJECT_INFO binfo;
	binfo.dwObjectID = GetNewTacticObjectIdx();
	//strcpy(binfo.ObjectName,pInfo->GetTacticName());
	SafeStrCpy(binfo.ObjectName,pInfo->GetTacticName(),MAX_NAME_LENGTH+1);
	
	binfo.ObjectState = eObjectState_None;

	g_pServerSystem->AddTacticObject(&binfo,pInfo,pOperator,Direction);
}

CTacticObject* CTacticManager::GetTacticObject(DWORD TacticObjectID)
{
	CObject* pObj = g_pUserTable->FindUser(TacticObjectID);
	if(pObj == NULL)
		return NULL;
	if(pObj->GetObjectKind() != eObjectKind_Tactic)
		return NULL;

	return (CTacticObject*)pObj;
}

BOOL CTacticManager::TacticProcess(CTacticObject* pTacObj)
{
	if(pTacObj->CheckFail() == TRUE)
	{
		AddGarbageTactic(pTacObj);
		return TRUE;
	}
	else if(pTacObj->CheckExecute() == TRUE)
	{
		AddGarbageTactic(pTacObj);
		return TRUE;
	}
	else
	{
		return FALSE;
	}
}

void CTacticManager::AddGarbageTactic(CTacticObject* pTacObj)
{
	m_GarbageTacticTable.Add(pTacObj,pTacObj->GetID());
}

void CTacticManager::ProcessGarbageTactic()
{
	m_GarbageTacticTable.SetPositionHead();
	CTacticObject* pObj;
	while(pObj = m_GarbageTacticTable.GetData())
	{
		g_pServerSystem->RemoveTacticObject(pObj->GetID());
	}
	m_GarbageTacticTable.RemoveAll();
}


DWORD toidTemp = 0;
DWORD CTacticManager::GetNewTacticObjectIdx()
{
	return TACTICOBJECT_ID_START+ toidTemp++;
}