gnpc.cc

五行MMORPG引擎系统V1.0

//GNpc.cc
/*/////////////////////////////////////////////////////////////////

   李亦
	[e-mail] 4040719
	2006-7-18
/*/////////////////////////////////////////////////////////////////

#include "rpg/RPGDataMan.h"
#include "rpg/gobjects/GNpc.h"
#include "rpg/RPGSetting.h"
#include "rpg/gobjects/GPlayer.h"
#include "game/gameBase.h"
#include "rpg/RPGChat.h"
#include "rpg/RPGPlayerAux.h"
#include "rpg/gobjects/GTaskState.h"



namespace RPG
{

GNpc*	g_pGNpc = NULL;

IMPLEMENT_CO_NETOBJECT_V1(GNpc);

IMPLEMENT_CONSOLETYPE(GNpc);
IMPLEMENT_SETOBJECTTYPE(GNpc);
IMPLEMENT_GETOBJECTTYPE(GNpc);

GNpc::GNpc()
{
	m_dwRPGTypes |= GOT_NPC;
	//m_arEquipments.SetArrayType(GGAR_EQUIPARMING);
	//m_arActions.SetArrayType(GGAR_ACTIONBASE);
	//m_arKeyCells.SetArrayType(GGAR_FUNCKEYBAR);

	//ClearData(PCS_ALL);
}

GNpc::~GNpc()
{
}


void GNpc::ClearData(U32 dwState)
{
	U32 n;
	//装备槽
	if(dwState & PCS_EQUIPMENTS)
	{
		m_arEquipments.setSize(EQUIP_SLOTNUM);
		for(n = 0; n < EQUIP_SLOTNUM; n++)
			m_arEquipments[n] = NULL;
	}

	//背包槽
	if(dwState & PCS_BAGGOODS)
	{
		m_arBagGoods.setSize(NPC_BAG_SLOTNUM);			
		for(n = 0; n < NPC_BAG_SLOTNUM; n++)
			m_arBagGoods[n] = NULL;
	}

	//技能槽
	if(dwState & PCS_SKILLS)
	{
		m_arSkills.setSize(NPC_SKILL_SLOTNUM);	
		for(n = 0; n < NPC_SKILL_SLOTNUM; n++)
			m_arSkills[n] = NULL;
	}


}

void GNpc::ProcessTalk(GPlayer* pGPlayer)
{
	GameBase*	pGameBase;
	GNpc*			pNpc;
	GameBase*	pPlayer;

	if(!pGPlayer)
		return;

	pPlayer = pGPlayer->GetGameBase();
	if(!pPlayer)
		return;

	pGameBase = GetGameBase();
	if(!pGameBase)
		return;


	ToggleNpc(this);

	pGameBase->faceTo(pPlayer->getPosition(),g_pGDialog != NULL);

	if(g_pGDialog)
	{	
		pPlayer->faceTo(pGameBase->getPosition());
		RPGChat::OutputTipF(TIP_NPC_TALKING,GetIDName());
		Con::executef(this,2,"OnProcessTalk");
	}
	else
	{
		RPGChat::OutputTipF(TIP_NPC_NOTALK,GetIDName());
	}
}

BOOL GNpc::GetCurTaskPiece(GTask*& pTask,GTaskPiece*& pPiece,EGTaskStates& state,GPlayer* pGPlayer)
{
	U32	n;

	if(!pGPlayer)
		goto laFailed;

	//EGTaskStates	state;

	////从玩家任务状态，获取任务状态对话
	if(pGPlayer->GetCurTaskPiece(pTask,pPiece,state,this))
	{	
		if(pPiece)
			state = pPiece->UpdateTaskState(pGPlayer, this, state);
		else
			state = pTask->UpdateTaskState(pGPlayer, this, state);
		return TRUE;
	}


	//检测Npc身上任务对话
	//以下情况将不处理任务
	//	1.任务已经完成，且不可重复
	//	2.任务已经过期，且不可重复
	//	3.任务未满足条件
	//	4.任务未处于Hold状态
	for(n=0; n<m_arTasks.size(); n++)
	{
		pTask = m_arTasks[n];
		if(pTask == NULL)
			continue;

		//pGPlayer->GetTask
		state = pGPlayer->GetTaskState(pTask->GetID());
		if(state >= GTS_FINISHED)
			continue;

		state = pTask->UpdateTaskState(pGPlayer, this, GTS_FREE);

		if((state <= GTS_FREE && !pTask->IsHold()))
			continue;

		pPiece = pTask->GetTaskPiece(0);
		if(pPiece)
		{
			if(pPiece->IsFitRequire(pGPlayer))
				return TRUE;
		}//if
		else
		{
			return TRUE;
		}
	}//for

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




GDialog* GNpc::GetFitDialog(GPlayer* pGPlayer)
{
	/*//////////////////////////////////////////////////////////
	1.处理 本Npc是否为Player状态任务中的ToNpc
	2.处理 本NPC身上是否有Player可用状态任务
	3.处理 本NPC身上是否有Player可接受任务
	4.处理 本NPC身上是否有休闲对话
	/*//////////////////////////////////////////////////////////
	GDialog*			pDialog;
	GTaskPiece*		pPiece;
	EGTaskStates	nState;
	GTask*			pTask;
	BOOL				bResult;

	pTask		= NULL;
	pPiece	= NULL;
	nState	= GTS_NULL;
	////////////////////////////////
	//1.处理本NPC是否为状态任务中的ToNpc
	bResult = pGPlayer->GetFitTask(pTask, pPiece,nState, this);

	//2.处理Player可用状态任务
	if(!bResult)
	{	
		bResult = GetCurTaskPiece(pTask, pPiece,nState, pGPlayer);
		ToggleTask(pTask);
	}

	GTaskState::ToggleTaskState(pTask,pPiece, nState,pGPlayer,this);

	//先依据玩家的任务状态，获取任务片段的状态对话
	if(bResult)
	{
		if(pPiece)
			pDialog	= pPiece->GetStateDialog(nState);
		else if(pTask)
			pDialog	= pTask->GetStateDialog(nState);
		else
			pDialog = NULL;

		if(pDialog)
			return pDialog;
	}
	
	//再获取Npc默认的对话
	for(U32 n=0; n<m_arDialogs.size(); n++)
	{
		pDialog = m_arDialogs[n];
		if(pDialog && pDialog->IsFitRequire(pGPlayer))
		{
			return pDialog;
		}
	}
	return NULL;
}


#ifdef TGE_RPGCLIENT

void GNpc::UpdateAllTaskNpc(GPlayer* pGPlayer)
{
	U32				n;
	GTask*			pTask;

	if(!pGPlayer)
		return;

	for(n=0; n<m_arTasks.size(); n++)
	{
		pTask = static_cast<GTask*>(m_arTasks[n]);
		if(pTask == NULL)
			continue;

		if(pGPlayer->IsTaskFinished(pTask))
		{	
			SetTaskNpc(FALSE);
			//SetTaskLock(FALSE);
		}
		else if(!IsTaskLock() && pTask->IsFitRequire(pGPlayer) )
		{
			SetTaskNpc(TRUE);
			SetRunningTask( pGPlayer->IsTaskRunning(pTask) );
		}
	}//for

}


void GNpc::ToggleNpc(GNpc* pNpc)
{
	GDialog* pDialog;
	if(!pNpc)
		return;
	//////////////////////////
	//切换NPC

	if(g_pGNpc != pNpc)
	{	
		pNpc->assignSoleName(SCRIPT_GNpc);
		g_pGNpc = pNpc;
	}

	////////////////////////////
	//切换对话
	if(pNpc)
	{	
		pDialog = pNpc->GetFitDialog(g_pGPlayer);
		if(g_pGDialog != pDialog)
		{	
			if(pDialog)
				pDialog->assignSoleName(SCRIPT_GDialog);
			g_pGDialog = pDialog;
		}
	}
	else
		g_pGDialog = NULL;

}

void GNpc::ToggleTask(GTask* pTask)
{
	if(g_pGTask == pTask)
		return;
	//if(static_cast<GTask*>(g_pGTask))
	//{
	//	g_pGTask->assignName(NULL);
	//}

	g_pGTask = pTask;
	if(pTask)
	{	
		pTask->assignSoleName(SCRIPT_GTask);
	}
}

#endif//TGE_RPGCLIENT

//----------------------------------------------------------------------------

//bool GNpc::onAdd()
//{
//   if (!Parent::onAdd())
//      return false;
//   return true;
//}
//
//
//void GNpc::onRemove()
//{
//   Parent::onRemove();
//}


//bool GNpc::OnNewDataBlock(RPGBaseData* dptr)
//{
//   return true;
//}
//
//bool GNpc::OnNewGameBase(GameBase* dptr)
//{
//   return true;
//}



//void GNpc::inspectPostApply()
//{
//   Parent::inspectPostApply();
//   GSetMaskBits(ExtendedInfoMask);
//}

//void tagGPlayer::ResetData()
//{
//	Parent::ResetData();
//
//	nLeftSP	= 0;
//
//}

//----------------------------------------------------------------------------
void GNpc::ProcessTick(const Move* pMove)
{
	Parent::ProcessTick(pMove);
}

void GNpc::InterpolateTick(F32 delta)
{
	Parent::InterpolateTick(delta);
}

void GNpc::AdvanceTime(F32 fTime)
{
	Parent::AdvanceTime(fTime);
}




U32 GNpc::packUpdate(NetConnection *conn, U32 mask, BitStream *stream)
{
	return Parent::packUpdate(conn, mask, stream);
   // Check the mask for the ScaleMask; if it's true, pass that in.
   //if (stream->writeFlag( mask & ScaleMask ) ) {
   //    mathWrite( *stream, Parent::getScale() );
   //}
   //if (stream->writeFlag((mask & DataBlockMask) && m_pDataBlock != NULL)) {
   //   stream->writeRangedU32(m_pDataBlock->getId(),
   //                          DataBlockObjectIdFirst,
   //                          DataBlockObjectIdLast);
   //}

   // cafTODO: ControlMask
   return 0;
}

void GNpc::unpackUpdate(NetConnection *con, BitStream *stream)
{
	Parent::unpackUpdate(con, stream);
   //if (stream->readFlag()) {
   //   VectorF scale;
   //   mathRead( *stream, &scale );
   //   setScale( scale );
   //}
   //if (stream->readFlag()) {
   //   RPGBaseData* dptr = 0;
   //   SimObjectId id = stream->readRangedU32(DataBlockObjectIdFirst,
   //                                          DataBlockObjectIdLast);

   //   if (!Sim::findObject(id,dptr) || !SetDataBlock(dptr))
   //      con->setLastError("Invalid packet GNpc::unpackUpdate()");
   //}
}






void GNpc::initPersistFields()
{
   Parent::initPersistFields();

   //addGroup("Misc");	
   //addField("nameTag",		TypeCaseString,		Offset(m_pNameTag,   GNpc));
   //addField("dataBlock",	TypeRPGBaseDataPtr,	Offset(m_pDataBlock, GNpc));
   //addField("gameBase",		TypeGameBasePtr,		Offset(m_pGameBase, GNpc));
   //endGroup("Misc");	
}

//void GNpc::consoleInit()
//{
//   Parent::consoleInit();
////   Con::addVariable("GNpc::boundingBox", TypeBool, &gShowBoundingBox);
//}


ConsoleFunction(ToggleNpc,void,2,2,"ToggleNpc(npc)")
{
	GNpc* pNpc;
	Sim::findObject(argv[1],pNpc);
	GNpc::ToggleNpc(pNpc);
}







};//namespace RPG