gtaskstate.cc

五行MMORPG引擎系统V1.0

//GTask.cc
/*/////////////////////////////////////////////////////////////////

   李亦
	[e-mail] 4040719
	2006-8-12
/*/////////////////////////////////////////////////////////////////

#include "rpg/RPGDataman.h"
#include "rpg/gobjects/GTask.h"
#include "rpg/gobjects/GTaskState.h"
#include "rpg/gobjects/GNpc.h"
//#include "rpg/RPGPlayerAux.h"


namespace RPG
{

GTaskState*	g_pGTaskState = NULL;


GTaskState::GTaskState()
{
	m_pNpc	= NULL;
	m_pTask	= NULL;
	m_nState	= GTS_NULL;
	//m_nCurPieceState	= GTS_NULL;
	m_pCurPiece	= NULL;
}

void GTaskState::InitPieceStates(U32 nSize)
{
	GTaskPiece*		pPiece;
	EGTaskStates	state;
	AssertWarn(m_pTask,"须先调用SetTaskState");
	if(m_pTask == NULL)
		return;
	//初始化片段状态
	//	凡在Hold之后（不包括Hold本身），都为GTS_NULL
	// 否则置为 GTS_FREE

	Vector<GTaskPiece*>&	arPieces = m_pTask->GetTaskPieces();
	m_arPieceStates.setSize(nSize);
	state	= GTS_FREE;

	for(U32 n=0; n<nSize; n++)
	{
		pPiece = arPieces[n];
		if(!pPiece)
		{	
			m_arPieceStates[n] = GTS_NULL;
			continue;
		}
		m_arPieceStates[n] = state;

		if(pPiece->IsHold())
		{
			state = GTS_IDLE;
		}
	}//for

}


BOOL GTaskState::SetPieceState(U32 nIndex,EGTaskStates state)
{
	AssertWarn(nIndex < m_arPieceStates.size(),"超出PieceStates范围");
	if(nIndex >= m_arPieceStates.size())
		return FALSE;

	//if(m_arPieceStates[nIndex] <= GTS_IDLE)
	//	return FALSE;

	m_arPieceStates[nIndex] = state;
	return TRUE;
}


BOOL GTaskState::SetTaskState(GTask* pTask,EGTaskStates state,GNpc* pNpc)
{
	//GNpc*	pToNpc;

	if(!pTask || !pTask->IsOwnerNpc(pNpc))
		return FALSE;
	//if(!pNpc->ExistTask(pTask))
		//return FALSE;

	m_pNpc	= pNpc;
	m_pTask	= pTask;
	m_nState	= state;

	if(m_pTask)
		m_pTask->UpdateToNpcState(state);


	return TRUE;
}


//适用于宿主Npc
BOOL GTaskState::GetFitPiece(GTaskPiece*& pPiece,EGTaskStates& state,U32 nIndex)
{
	//GTaskPiece* pPiece;
	U32			n;

	//在定位nIndex位置的任务片段时
	//	1. 如果过程中发现Hold状态片段，则返回NULL
	//	2. 否则返回nIndex位置Piece
	//	3 如果任务(片段)为 存在ToNpc，
	//		3.1 状态为GTS_RUNNING*，则直接返回 GTS_RUNNING
	//		3.2 状态为Premium，且!HasGoal，则返回 Idle

	//nIndex==-1时，则抽取第1个可用片段

	//AssertWarn(,"未初始化任务状态");
	if(!m_pTask || m_arPieceStates.size() != m_pTask->GetTaskPieceSize())
		goto laFailed;

	Vector<GTaskPiece*>&	arPieces = m_pTask->GetTaskPieces();

	//if(nIndex >= m_arPieceStates.size())
	//	return FALSE;

	//指定位置nIndex
	if(nIndex < m_arPieceStates.size())
	{
		if(m_arPieceStates[nIndex] <= GTS_IDLE)
			goto laFailed;
		pPiece	= arPieces[nIndex];
		state		= m_arPieceStates[nIndex];
		return TRUE;
	}

	//未指定位置
	for(n=0; n<arPieces.size(); n++)
	{
		pPiece	= arPieces[n];
		if(!pPiece)
			continue;
		state		= m_arPieceStates[n];

		if(state == GTS_NULL || state >= GTS_FINISHED)
			continue;

		//Hold状态下的片段
		if(state == GTS_IDLE)
			goto laFailed;

		//if(pPiece->GetToNpc())
		//{
		//	state = GetFitGoalObjState(pPiece, state, NULL);
		//}
		return TRUE;
	}//for



	if(m_nState >= GTS_FINISHED)
		goto laFailed;

	state = m_nState;
	pPiece	= NULL;
	//state = GetFitGoalObjState(m_pTask, m_nState, NULL);

	return TRUE;

laFailed:
	{
		pPiece	= NULL;
		state		= GTS_NULL;
	}
	return FALSE;

}


//适用于ToNpc
BOOL GTaskState::GetFitPiece(GTaskPiece*& pPiece,EGTaskStates& state,GNpc* pToNpc)
{
	//GTaskPiece* pPiece;
	U32			n;

	//依据ToNpc获取 相应任务状态
	//	1. 如果过程中发现Hold状态片段，则返回NULL
	//	2. 否则返回nIndex位置Piece
	//	3. 须为接受状态任务 即 GTS_RUNNING*
	//	4  如果任务(片段)为 存在ToNpc，
	//		（ToNpc只使用任务的GTS_RUNNING2、GTS_PREMIUM2状态）
	//		3.1 状态为GTS_RUNNING*，则直接返回 GTS_RUNNING2
	//		3.2 状态为Premium，且!HasGoal，则返回 Idle

	if(!m_pTask || m_arPieceStates.size() != m_pTask->GetTaskPieceSize() || !pToNpc)
		goto laFailed;

	Vector<GTaskPiece*>&	arPieces = m_pTask->GetTaskPieces();


	//未指定位置
	for(n=0; n<arPieces.size(); n++)
	{
		pPiece	= arPieces[n];
		if(!pPiece)
			continue;
		state		= m_arPieceStates[n];

		if(state >= GTS_FINISHED)
			continue;

		//须为接受状态任务
		if(state <= GTS_FREE2)
			continue;
		////Hold状态下的片段
		//if(state == GTS_IDLE)
		//	goto laFailed;

		if(pPiece->IsToNpc(pToNpc))
		{	
			//state = GetFitGoalObjState(pPiece, state, pToNpc);
			return TRUE;
		}
	}//for

	if(arPieces.size()==0)
	{
		if(m_nState >= GTS_FINISHED || m_nState <= GTS_FREE2 || !m_pTask->IsToNpc(pToNpc))
			goto laFailed;

		//成功返回
		state = m_nState;
		//state = GetFitGoalObjState(m_pTask, m_nState, pToNpc);

		pPiece	= NULL;
		return TRUE;
	}

	//失败返回
laFailed:
	{
		pPiece	= NULL;
		state		= GTS_NULL;
	}
	return FALSE;

}

BOOL GTaskState::SetCurPiece(U32 n)
{
	if(!m_pTask)
		return FALSE;
	if(n >= m_arPieceStates.size())
	{
		m_pCurPiece			= NULL;
		//m_nCurPieceState	= GTS_NULL;
	}
	else
	{
		m_pCurPiece			= m_pTask->GetTaskPiece(n);
		//m_nCurPieceState	= m_arPieceStates[n];
	}
	return TRUE;
}

BOOL GTaskState::SetCurPiece(GTaskPiece* pPiece,EGTaskStates nState)
{
	GNpc*	pToNpc;

	if(!m_pTask)
		return FALSE;

	//处理当前任务片段状态
	if(pPiece)
	{	
		//m_nCurPieceState	= nState;
		pPiece->UpdateToNpcState(nState);
	}
	else
	{
		//m_nCurPieceState	= GTS_NULL;
	}

	//取消之前任务的Lock状态
	//if(m_pCurPiece)
	//	m_pCurPiece->UpdateToNpcState();

	m_pCurPiece			= pPiece;
	return TRUE;
}


BOOL GTaskState::ExecuteAllPiecePossible(GNpc* pNpc,GPlayer* pPlayer,U32 nBase,BOOL bRunNow)
{
	GTaskPiece*		pPiece;
	EGTaskStates	nTaskState;
	EGTaskStates	nPieceState;
	U32				n;
	BOOL				bBreak;

	//执行所有尽可能的任务片段
	//	0. nBase之前的任务片段须为Finished状态
	//	1. 从nBase位置开始，直到Hold型片段（不包括本身）/或不符合条件的片段
	//		所有这些片段都需要执行状态
	//

	if(!m_pTask || m_pTask->GetTaskPieceSize() == 0)
		return FALSE;

	///////////////////////////////////////////
	//执行整体任务状态
	if(nBase == -1 || nBase >= m_pTask->GetTaskPieceSize())
	{
		nTaskState = m_pTask->UpdateTaskState(pPlayer,pNpc,m_nState);
		if(bRunNow)
			m_pTask->ExecuteTask(pNpc, pPlayer, nTaskState);
		else
			SetState(nTaskState);
		return TRUE;
	}

	//nTaskState	= pState->GetState();

	//////////////////////////////////////////////////////////
	//任务处在已接受状态时
	if(m_nState >= GTS_RUNNING && m_nState <= GTS_RUNNING2)
	{
		for(n=0; n< nBase; n++)
		{
			nPieceState = GetPieceState(n);
			if(nPieceState < GTS_FINISHED)
				return FALSE;
		}

		bBreak = FALSE;
		for(n=nBase; !bBreak && n< m_pTask->GetTaskPieceSize(); n++)
		{
			pPiece	= m_pTask->GetTaskPiece(n);
			if(pPiece == NULL)
				continue;
			nPieceState = GetPieceState(n);

			//发现Hold状态
			if(pPiece->IsHold())
				bBreak = TRUE;
			
			if(nPieceState <= GTS_FREE)
			{	
				nPieceState = pPiece->UpdateTaskState(pPlayer,pNpc,GTS_FREE);
				if(nPieceState == GTS_FREE)
					break;
			}
			else
				nPieceState = pPiece->UpdateTaskState(pPlayer,pNpc,nPieceState);

			if(bRunNow)
				pPiece->ExecuteTask(pNpc, pPlayer, nPieceState);
			else
				SetPieceState(n,nPieceState);
		}//for
		return TRUE;
	}//if

	//pPiece		= (GTaskPiece*)pState->GetCurPiece();

	return TRUE;
}



BOOL GTaskState::UpdateToNpcState()