gtaskstate.cc

五行MMORPG引擎系统V1.0

{
	U32	n;
	GTaskPiece* pPiece;
	BOOL			bSet;
	GNpc*			pNpc;
	BOOL			bExist;

	if(!m_pTask)
		return FALSE;
	Vector<GTaskPiece*> arPieces = m_pTask->GetTaskPieces();

	bSet		= TRUE;
	bExist	= FALSE;
	for(n=0; n<m_arPieceStates.size() && n < arPieces.size(); n++)
	{
		if(m_arPieceStates[n] >= GTS_FINISHED )
			continue;

		pPiece = arPieces[n];
		if(pPiece== NULL)
			continue;

		pNpc = pPiece->GetToNpc();
		if(!pNpc)
			continue;

		pNpc->SetTaskLock(bSet);
		bExist = TRUE;

		if(m_arPieceStates[n] < GTS_IDLE)
			bSet = FALSE;
	}

	if(!bExist && 	m_pTask->GetToNpc())
		m_pTask->GetToNpc()->SetTaskLock(TRUE);

	return TRUE;

}


BOOL GTaskState::IsFitToNpc(GNpc* pNpc)
{
	U32	n;
	GTaskPiece* pPiece;

	if(!m_pTask)
		return FALSE;
	Vector<GTaskPiece*> arPieces = m_pTask->GetTaskPieces();

	for(n=0; n<m_arPieceStates.size() && n < arPieces.size(); n++)
	{
		if(m_arPieceStates[n] < GTS_IDLE)
			break;
		if(m_arPieceStates[n] >= GTS_FINISHED )
			continue;

		pPiece = arPieces[n];
		if(pPiece== NULL)
			continue;
		if(pPiece->IsToNpc(pNpc))
			return TRUE;
	}

	return m_pTask->IsToNpc(pNpc);

}


BOOL GTaskState::IsTaskFinished(U32 nPieceIndex)
{
	//任务片段检测
	if(nPieceIndex != -1)
	{
		return GetPieceState(nPieceIndex) == GTS_FINISHED;
	}

	//整体任务检测
	if(!IsAllPieceFinished())
		return FALSE;

	return m_nState == GTS_FINISHED;
}


BOOL GTaskState::IsAllPieceFinished()
{
	U32 n;
	for(n=0; n<m_arPieceStates.size(); n++)
	{
		if(m_arPieceStates[n] != GTS_FINISHED)
			return FALSE;
	}
	return TRUE;
}

//
//
//EGTaskStates GTaskState::GetFitGoalObjState(GTaskPiece* pPiece,GNpc* pNpc)
//{
//	EGTaskStates state;
//
//	if(!m_pTask)
//		return GTS_NULL;
//
//	if(pPiece == NULL)
//	{
//		if(!m_pTask->IsOwnerNpc(pNpc))
//			return GTS_NULL;
//		return GetFitGoalObjState( m_pTask, m_nState, pNpc);
//	}
//
//	if(!pPiece->IsOwnerTask(m_pTask))
//		return GTS_NULL;
//
//	state = GetPieceState(pPiece->GetIndex());
//	return GetFitGoalObjState( pPiece, state, pNpc);
//}
//
//
//EGTaskStates GTaskState::GetFitGoalObjState(GTaskBase* pBase,EGTaskStates state,GNpc* pToNpc)
//{
//	//////////////////////////////////////
//	//宿主Npc处理
//	if(pToNpc == NULL || pBase->IsOwnerNpc(pToNpc))
//	{
//		if(pBase->GetToNpc())
//		{
//			if(!pBase->HasGoal())
//			{
//				if(state == GTS_PREMIUM)
//					state = GTS_IDLE;
//			}
//			if(state == GTS_RUNNING2)
//				state = GTS_RUNNING;
//		}
//		return state;
//	}
//
//	//////////////////////////////////////
//	//ToNpc处理
//	if(pBase->IsToNpc(pToNpc))
//	{	
//		if(state == GTS_RUNNING)
//			state = GTS_RUNNING2;
//	}
//	return state;
//}


CSTR GTaskState::GetDataBy(STE sField)
{
	GNpc*		pToNpc;
	GNpc*		pFromNpc;

	static STE sToNpc			= StringTable->insert(GTFIELD_TONPC);
	static STE sToNpcPos		= StringTable->insert(GTFIELD_TONPCPOS);
	static STE sFromNpc		= StringTable->insert(GTFIELD_FROMNPC);
	static STE sFromNpcPos	= StringTable->insert(GTFIELD_FROMNPCPOS);
	static STE sGoalObj		= StringTable->insert(GTFIELD_GOALOBJ);
	static STE sGoalObjReq	= StringTable->insert(GTFIELD_GOALOBJREQ);

	static STE sTaskGoal		= StringTable->insert(GTFIELD_TASKGOAL);
	static STE sTaskReq		= StringTable->insert(GTFIELD_TASKREQ);
	static STE sTaskGoalReq		= StringTable->insert(GTFIELD_TASKGOALREQ);
	static STE sTaskPremium		= StringTable->insert(GTFIELD_TASKPREMIUM);
	static STE sTaskPremiumReq	= StringTable->insert(GTFIELD_TASKPREMIUMREQ);

	static STE sTPiecePremium		= StringTable->insert(GTFIELD_TPIECEPREMIUM);
	static STE sTPiecePremiumReq	= StringTable->insert(GTFIELD_TPIECEPREMIUMREQ);
	static STE sTPieceReq			= StringTable->insert(GTFIELD_TPIECEREQ);
	static STE sTPieceGoal			= StringTable->insert(GTFIELD_TPIECEGOAL);
	static STE sTPieceGoalReq		= StringTable->insert(GTFIELD_TPIECEGOALREQ);
	



	if(m_pCurPiece)
	{
		GGOODSREF ref(g_pGPlayer, g_pGNpc, m_pCurPiece);

		pToNpc	= (GNpc*)m_pCurPiece->GetToNpc();
		pFromNpc = (GNpc*)m_pCurPiece->GetFromNpc();

		if(sField == sToNpc)
			return pToNpc?pToNpc->GetCharName() : "";
		else if(sField == sToNpcPos)
		{	
			if(pToNpc)
			{
				char* szBuf = Con::getReturnBuffer(64);
				dSprintf(szBuf,64,"%d,%d",pToNpc->GetXInt(),pToNpc->GetYInt());
				return szBuf;
			}
			return "";
		}
		else if(sField == sFromNpc)
			return pFromNpc?pFromNpc->GetCharName() : "";
		else if(sField == sFromNpcPos)
		{	
			if(pFromNpc)
			{
				char* szBuf = Con::getReturnBuffer(64);
				dSprintf(szBuf,64,"%d,%d",pFromNpc->GetXInt(),pFromNpc->GetYInt());
				return szBuf;
			}
			return "";
		}

		else if(sField == sGoalObj)
			return m_pCurPiece->GetGoalObjectEffText(ref);
		else if(sField == sGoalObjReq)
			return m_pCurPiece->GetGoalObjectReqText(ref);
		else if(sField == sTPieceGoal)
			return m_pCurPiece->GetGoalEffText(ref);
		else if(sField == sTPieceGoalReq)
			return m_pCurPiece->GetGoalReqText(ref);
		else if(sField == sTPiecePremium)
			return m_pCurPiece->GetPremiumEffText(ref);
		else if(sField == sTPiecePremiumReq)
		{	
			ref.bGoodsDeal = false;
			return m_pCurPiece->GetPremiumEffText(ref);
		}
		else if(sField == sTPieceReq)
			return m_pCurPiece->GetRequireReqText(ref);
	}//if

	if(m_pTask)
	{
		GGOODSREF ref(g_pGPlayer, g_pGNpc, m_pCurPiece);

		if(sField == sTaskGoal)
			return m_pTask->GetGoalEffText(ref);
		else if(sField == sTaskGoalReq)
			return m_pTask->GetGoalReqText(ref);
		else if(sField == sTaskPremium)
			return m_pTask->GetPremiumEffText(ref);
		else if(sField == sTaskPremiumReq)
		{	
			ref.bGoodsDeal = false;
			return m_pTask->GetPremiumEffText(ref);
		}
		else if(sField == sTaskReq)
			return m_pTask->GetRequireReqText(ref);
	}
	
	return "";
}



BOOL GTaskState::ToggleTaskState(GTask* pTask,GTaskPiece* pPiece,EGTaskStates nState,GPlayer* pChar,GNpc* pNpc)
{

	GTaskState*	pState;
	if(!pTask)
	{
		g_pGTaskState = NULL;
		return TRUE;
	}

	g_pGTaskState = pChar->InsertTaskState(pTask,nState, pNpc);
	if(g_pGTaskState)
	{	
		g_pGTaskState->SetCurPiece(pPiece, nState);
	}

	return TRUE;
}

BOOL GTaskState::RunTaskState(GNpc* pNpc,GPlayer* pPlayer)
{
	GTaskPiece*	pPiece;
	GTask*		pTask;
	BOOL			bResult;
	EGTaskStates	nTaskState;
	EGTaskStates	nPieceState;

	//实现以下处理
	//1. pNpc为 toNpc，则作toNpc处理
	//2. 执行当前片段的 Task状态
	//3. 执行当前任务的 Task状态
	if(!dynamic_cast<GTaskState*>(g_pGTaskState))
		return TRUE;

	pTask = (GTask*)g_pGTaskState->GetTask();
	if(!pTask)
		return FALSE;

	pPiece		= (GTaskPiece*)g_pGTaskState->GetCurPiece();
	nTaskState	= g_pGTaskState->GetState();

	////////////////////////////////////
	//A.片段ToNpc状态  
	//任务片段的ToNpc处理
	//如果没有目标结果 !HasGoal，则由ToNpc直接执行Task状态
	if(pPiece)
	{
		nPieceState	= g_pGTaskState->GetPieceState(pPiece->GetIndex());
		nPieceState = pPiece->UpdateTaskState(pPlayer,pNpc, nPieceState);
		//nPieceState = g_pGTaskState->GetFitGoalObjState(pPiece,pNpc);
		if(pPiece->IsToNpc(pNpc))
		{	
			bResult = pPiece->ExecuteGoalNpc(pNpc, pPlayer, nPieceState);
			if(bResult &&  !pPiece->HasGoal() )
				pPiece->ExecuteTask(pNpc, pPlayer, nPieceState);
			return bResult;
		}//if
	}//if
	//B.任务ToNpc状态
	//任务的ToNpc处理
	//如果没有目标结果 !HasGoal，则由ToNpc直接执行Task状态
	else if(pTask->IsToNpc(pNpc))
	{	
		nTaskState = pTask->UpdateTaskState(pPlayer,pNpc,nTaskState);
		bResult = pTask->ExecuteGoalNpc(pNpc, pPlayer, nTaskState);
		if(bResult  &&  !pTask->HasGoal())//&& pTask->IsToNpc(g_pGTaskState->GetNpc()) )
			pTask->ExecuteTask(pNpc, pPlayer, nTaskState);
		return bResult;
	}//else if


	//////////////////////////////////////////////////
	//C.任务宿主Npc处理
	if(!pTask->IsOwnerNpc(pNpc))
		return FALSE;


	//C1.接受状态  先任务再片段
	///	对0片段，直接接受任务
	if(nTaskState <= GTS_FREE2)
	{
		nTaskState = pTask->UpdateTaskState(pPlayer,pNpc,nTaskState);
		if(pTask->ExecuteTask(pNpc, pPlayer, nTaskState))
			g_pGTaskState->ExecuteAllPiecePossible(pNpc,pPlayer,0,TRUE);
		//if(pPiece && pPiece->IsOwnerTask(pTask))
		//{	
		//	if(pPiece->GetIndex() == 0 && nPieceState <= GTS_FREE)
		//		nPieceState = pPiece->UpdateTaskState(GTS_FREE,pPlayer);
		//	pPiece->ExecuteTask(pNpc, pPlayer, nPieceState);
		//}
	}
	//C2.其它状态  先片段再任务
	else//if(!pPiece->IsToNpcRunning2())
	{
		if(pPiece && pPiece->IsOwnerTask(pTask))
		{	
			nPieceState = pPiece->UpdateTaskState(pPlayer,pNpc,nPieceState);
			if(pPiece->ExecuteTask(pNpc, pPlayer, nPieceState))
			{	
				//if(pPiece->IsToNpcRunning2())
				//	g_pGTaskState->ExecuteAllPiecePossible(pNpc,pPlayer,pPiece->GetIndex()+1, TRUE);
			}
		}
		nTaskState = pTask->UpdateTaskState(pPlayer,pNpc,nTaskState);
		pTask->ExecuteTask(pNpc, pPlayer, nTaskState);
	}



	return TRUE;
}



};//namespace RPG