www.pudn.com > notWow.rar > Char.cpp

#include "Char.h" 
 
#include "ModelMgr.h" 
#include "Random.h" 
#include "SceneMgr.h" 
 
extern ScenesManager	g_SceneMgr; 
extern ModelsManager	g_MdlMgr; 
extern Random			g_Random; 
 
int Char::s_TimeFixed  = 1000; 
int Char::s_ShuffleDgreeFixed = 4; 
 
bool ObjectPtr::operator < (const ObjectPtr& Oth) const 
{ 
//	int A1 = (g_MdlMgr.GetModel(Ptr->m_ModelID)->GetType() & MODEL_ATEST ); 
//	int A2 = (g_MdlMgr.GetModel(Oth.Ptr->m_ModelID)->GetType() & MODEL_ATEST ); 
	int T1 = (g_MdlMgr.GetModel(Ptr->m_ModelID)->GetType() & MODEL_TRANS ); 
	int T2 = (g_MdlMgr.GetModel(Oth.Ptr->m_ModelID)->GetType() & MODEL_TRANS ); 
	if( (T1 + T2) & MODEL_TRANS ) 
		return (T1 == 0); 
	else 
		return Ptr->m_fViewZ < Oth.Ptr->m_fViewZ; 
} 
 
void WorldObject::Render(D3DXMATRIX* pViewProj,bool bFar) 
{ 
	if(!m_bRender) 
		return; 
	IModel* pModel = g_MdlMgr.GetModel(m_ModelID); 
	pModel->Move(m_fPosX,m_fPosY,m_fPosZ,m_Dir);	 
	pModel->Update(pViewProj); 
	pModel->Render(m_fViewZ,bFar); 
	m_bRender = false; 
} 
 
void Char::Render(D3DXMATRIX* pViewProj) 
{ 
	//if(!m_bRender) 
	//	return; 
	M2Model *pModel =  (M2Model*)g_MdlMgr.GetModel(m_ModelID); 
	pModel->Move(m_fPosX,m_fPosY,m_fPosZ,m_Dir); 
	pModel->SetTexture(m_TexturesID); 
	pModel->SetDetails(m_Geosets); 
	pModel->SetAnimation(m_Anim,m_Time); 
	pModel->Update(pViewProj); 
	pModel->Render(m_fViewZ); 
	m_bRender = false; 
} 
 
void Item::Render(D3DXMATRIX* pViewProj) 
{ 
 
} 
 
D3DXMATRIX Char::GetMatrix() 
{ 
	D3DXMATRIX m; 
	return m; 
} 
 
bool Char::CalDir(int x,int z,int &dir) 
{ 
	if(abs(x + 0.5 - m_fPosX) < 0.01 ) 
	{ 
		if(abs(m_fPosZ - z - 0.5) < 0.01) 
			return true; 
		else if(m_fPosZ > z + 0.5) 
			dir = 90; 
		else  
			dir = 270; 
	} 
	else 
	{ 
		float fTan = (m_fPosZ - z - 0.5) / (x + 0.5 - m_fPosX); 
		if(x + 0.5 - m_fPosX > 0) 
			dir = Math::Arctan(fTan); 
		else 
			dir = Math::Arctan(fTan) -180; 
	} 
	return (abs(dir - m_Dir) > 10); 
} 
 
int	 Char::CalDistSqr(int x,int z) 
{ 
	int dx = (int)m_fPosX - x; 
	int dz = (int)m_fPosZ - z; 
	return  (dx * dx + dz * dz); 
} 
 
void Char::Idle() 
{ 
	m_StateQueue.clear(); 
	m_State = CS_IDLE; 
	m_bActChange = true; 
	m_bStateOver = true; 
	m_pAimChar = NULL; 
} 
 
void Char::Turn(int x,int z) 
{ 
	State st; 
	if(!CalDir(x,z,st.DestDir)) 
		return; 
	st.pAimChar = NULL; 
	st.DestX = x; 
	st.DestZ = z; 
	st.CharState = CS_TURN; 
	m_StateQueue.push_back(st); 
} 
 
void Char::Turn(ICharBase *pChar) 
{ 
	State st; 
	st.DestX = (int)pChar->m_fPosX; 
	st.DestZ = (int)pChar->m_fPosZ; 
	st.pAimChar = pChar; 
	st.CharState = CS_TURN; 
	m_StateQueue.push_back(st); 
} 
 
void Char::Walk(int x,int z) 
{ 
	State st; 
	CalDir(x,z,st.DestDir); 
	st.pAimChar = NULL; 
	st.DestX = x; 
	st.DestZ = z; 
	st.CharState = CS_WALK; 
	m_StateQueue.push_back(st); 
} 
 
void Char::Walk(ICharBase *pChar) 
{ 
	State st; 
	st.pAimChar = pChar; 
	st.CharState = CS_WALK; 
	m_StateQueue.push_back(st); 
} 
 
void Char::Run(int x,int z) 
{ 
	State st; 
	st.pAimChar = NULL; 
	st.DestX = x; 
	st.DestZ = z; 
	st.CharState = CS_RUN; 
	m_StateQueue.push_back(st); 
} 
 
 
 
void Char::Run(ICharBase *pChar) 
{ 
	State st; 
	st.pAimChar = pChar; 
	st.CharState = CS_RUN; 
	m_StateQueue.push_back(st); 
} 
 
 
 
void Char::Attack(ICharBase *pChar) 
{ 
	State st; 
	st.pAimChar = pChar; 
	st.CharState = CS_ATTACK; 
	m_StateQueue.push_back(st); 
} 
 
void Char::Talk(ICharBase *pChar) 
{ 
 
} 
 
void Char::SetBattle(bool Battle) 
{ 
} 
 
void Char::OnIdle(float fTime) 
{ 
	vector Anim; 
	M2Model *p = (M2Model*)g_MdlMgr.GetModel(m_ModelID); 
 
	if(m_bActChange) 
	{ 
		m_Act = ACT_STAND; 
		Anim = p->GetAnimation(ACT_STAND); 
		//m_Anim = Anim[g_Random.RandInt(0,Anim.size()-1)]; 
		m_Anim = Anim[0]; 
		m_bActChange = false; 
		m_Time = 0; 
	} 
	else 
	{ 
		m_Time += s_TimeFixed * fTime;		 
		if(p->NewLoop(m_Anim,m_Time)) 
		{ 
			m_Time = 0; 
			m_Act = ACT_STAND; 
			Anim = p->GetAnimation(m_Act); 
			//m_Anim = Anim[g_Random.RandInt(0,Anim.size()-1)]; 
			m_Anim = Anim[0]; 
		} 
	} 
	m_bStateOver = true; 
} 
 
void Char::OnTurn(float fTime) 
{ 
	vector Anim; 
	M2Model *p = (M2Model*)g_MdlMgr.GetModel(m_ModelID); 
 
	int Turn; 
	int Delta; 
 
	// Turn to somebody 
	if(m_pAimChar != NULL) 
	{ 
		// same direction -- stand 
		if(!CalDir((int)m_pAimChar->m_fPosX,(int)m_pAimChar->m_fPosZ,m_DestDir)) 
		{ 
			if(m_bActChange) 
			{ 
				m_Act = ACT_STAND; 
				Anim = p->GetAnimation(ACT_STAND); 
				m_Anim = Anim[0]; 
				m_bActChange = false; 
				m_Time = 0; 
			} 
			else 
			{ 
				m_Time += s_TimeFixed * fTime;		 
				if(p->NewLoop(m_Anim,m_Time)) 
				{ 
					m_Act = ACT_STAND; 
					m_Time = 0; 
					Anim = p->GetAnimation(ACT_STAND); 
					m_Anim = Anim[0]; 
				} 
			} 
			return; 
		} 
	} 
 
	m_Dir = m_DestDir; 
 
	// end state 
	if(m_pAimChar == NULL) 
		m_bStateOver = true; 
 
} 
 
void Char::OnWalk(float fTime) 
{ 
	vector Anim; 
	M2Model *p = (M2Model*)g_MdlMgr.GetModel(m_ModelID); 
	 
	if(m_pAimChar != NULL) 
	{ 
		m_DestX = (int)m_pAimChar->m_fPosX; 
		m_DestZ = (int)m_pAimChar->m_fPosZ; 
 
		m_DestX += ( m_pAimChar->m_fPosX > m_fPosX ? -1 : 1 );  
		m_DestZ += ( m_pAimChar->m_fPosZ > m_fPosZ ? -1 : 1 );  
			 
		// near by the target -- stand 
		if(abs(m_DestX + 0.5 - m_fPosX) < 0.1 && abs(m_fPosZ - m_DestZ - 0.5) < 0.1) 
		{	 
			CalDir((int)m_pAimChar->m_fPosX,(int)m_pAimChar->m_fPosZ,m_DestDir); 
			m_Dir = m_DestDir; 
 
			m_fPosX = (int)m_fPosX + 0.5; 
			m_fPosZ = (int)m_fPosZ + 0.5; 
			if(m_bActChange || m_Act != ACT_STAND) 
			{ 
				m_Act = ACT_STAND; 
				Anim = p->GetAnimation(ACT_STAND); 
				m_Anim = Anim[0]; 
				m_bActChange = false; 
				m_Time = 0; 
			} 
			else 
			{ 
				m_Time += s_TimeFixed * fTime;		 
				if(p->NewLoop(m_Anim,m_Time)) 
				{ 
					m_Act = ACT_STAND; 
					m_Time = 0; 
					Anim = p->GetAnimation(ACT_STAND); 
					m_Anim = Anim[0]; 
				} 
			} 
			return; 
		} 
		else 
		{ 
			m_bActChange = (m_Act == ACT_STAND); 
		} 
 
		CalDir(m_DestX,m_DestZ,m_DestDir); 
		m_Dir = m_DestDir; 
	} 
	else 
	{ 
		m_Dir = m_DestDir; 
	} 
		 
	m_fPosX += Math::Cos(m_Dir) * m_fWalkSpeed * fTime; 
	m_fPosZ -= Math::Sin(m_Dir) * m_fWalkSpeed * fTime; 
 
	if(m_bActChange) 
	{ 
		m_Time = 0; 
		m_Act = ACT_WALK; 
		Anim = p->GetAnimation(ACT_WALK); 
		m_Anim = Anim[0]; 
		m_bActChange = false; 
	} 
	else 
	{ 
		m_Time += s_TimeFixed * fTime; 
	} 
 
	if(m_pAimChar == NULL && abs(m_DestX + 0.5 - m_fPosX) < 0.1 && abs(m_fPosZ - m_DestZ - 0.5) < 0.1) 
	{ 
		m_fPosZ = m_DestZ + 0.5; 
		m_fPosX = m_DestX + 0.5; 
		m_bStateOver = true; 
	} 
} 
 
void Char::OnRun(float fTime) 
{ 
	vector Anim; 
	M2Model *p = (M2Model*)g_MdlMgr.GetModel(m_ModelID); 
	 
	if(m_pAimChar != NULL) 
	{ 
		m_DestX = (int)m_pAimChar->m_fPosX; 
		m_DestZ = (int)m_pAimChar->m_fPosZ; 
 
		m_DestX += ( m_pAimChar->m_fPosX > m_fPosX ? -1 : 1 );  
		m_DestZ += ( m_pAimChar->m_fPosZ > m_fPosZ ? -1 : 1 );  
			 
		// near by the target -- stand 
		if(abs(m_DestX + 0.5 - m_fPosX) < 0.1 && abs(m_fPosZ - m_DestZ - 0.5) < 0.1) 
		{	 
			CalDir((int)m_pAimChar->m_fPosX,(int)m_pAimChar->m_fPosZ,m_DestDir); 
			m_Dir = m_DestDir; 
 
			m_fPosX = (int)m_fPosX + 0.5; 
			m_fPosZ = (int)m_fPosZ + 0.5; 
			if(m_bActChange || m_Act != ACT_STAND) 
			{ 
				m_Act = ACT_STAND; 
				Anim = p->GetAnimation(ACT_STAND); 
				m_Anim = Anim[0]; 
				m_bActChange = false; 
				m_Time = 0; 
			} 
			else 
			{ 
				m_Time += s_TimeFixed * fTime;		 
				if(p->NewLoop(m_Anim,m_Time)) 
				{ 
					m_Act = ACT_STAND; 
					m_Time = 0; 
					Anim = p->GetAnimation(ACT_STAND); 
					m_Anim = Anim[0]; 
				} 
			} 
			return; 
		} 
		else 
		{ 
			m_bActChange = (m_Act == ACT_STAND); 
		} 
 
		CalDir(m_DestX,m_DestZ,m_DestDir); 
		m_Dir = m_DestDir; 
	} 
	else 
	{ 
		m_Dir = m_DestDir; 
	} 
		 
	m_fPosX += Math::Cos(m_Dir) * m_fRunSpeed * fTime; 
	m_fPosZ -= Math::Sin(m_Dir) * m_fRunSpeed * fTime; 
 
	if(m_bActChange) 
	{ 
		m_Time = 0; 
		m_Act = ACT_RUN; 
		Anim = p->GetAnimation(m_Act); 
		m_Anim = Anim[0]; 
		m_bActChange = false; 
	} 
	else 
	{ 
		m_Time += s_TimeFixed * fTime; 
	} 
 
	if(m_pAimChar == NULL && abs(m_DestX + 0.5 - m_fPosX) < 0.1 && abs(m_fPosZ - m_DestZ - 0.5) < 0.1) 
	{ 
		m_fPosZ = m_DestZ + 0.5; 
		m_fPosX = m_DestX + 0.5; 
		m_bStateOver = true; 
	} 
} 
 
 
void Char::OnAttack(float fTime) 
{ 
	vector Anim; 
	M2Model *p = (M2Model*)g_MdlMgr.GetModel(m_ModelID); 
 
 
	m_DestX = (int)m_pAimChar->m_fPosX; 
	m_DestZ = (int)m_pAimChar->m_fPosZ; 
		 
	// near by the target -- attack 
	if(CalDistSqr((int)m_pAimChar->m_fPosX,(int)m_pAimChar->m_fPosZ) < 1.5 ) 
	{	 
		CalDir((int)m_pAimChar->m_fPosX,(int)m_pAimChar->m_fPosZ,m_DestDir); 
		m_Dir = m_DestDir; 
 
		if(m_bActChange || m_Act != ACT_STAND) 
		{ 
			m_Act = ACT_STAND; 
			Anim = p->GetAnimation(ACT_STAND); 
			m_Anim = Anim[0]; 
			m_bActChange = false; 
			m_Time = 0; 
		} 
		else 
		{ 
			m_Time += s_TimeFixed * fTime;		 
			if(p->NewLoop(m_Anim,m_Time)) 
			{ 
				m_Act = ACT_STAND; 
				m_Time = 0; 
				Anim = p->GetAnimation(ACT_STAND); 
				m_Anim = Anim[0]; 
			} 
		} 
		return; 
	} 
	else 
	{ 
		m_bActChange = (m_Act == ACT_STAND); 
	} 
 
	CalDir(m_DestX,m_DestZ,m_DestDir); 
	m_Dir = m_DestDir; 
 
		 
	m_fPosX += Math::Cos(m_Dir) * m_fRunSpeed * fTime; 
	m_fPosZ -= Math::Sin(m_Dir) * m_fRunSpeed * fTime; 
 
	if(m_bActChange) 
	{ 
		m_Time = 0; 
		m_Act = ACT_RUN; 
		Anim = p->GetAnimation(m_Act); 
		m_Anim = Anim[0]; 
		m_bActChange = false; 
	} 
	else 
	{ 
		m_Time += s_TimeFixed * fTime; 
	} 
 
	if(m_pAimChar == NULL && abs(m_DestX + 0.5 - m_fPosX) < 0.1 && abs(m_fPosZ - m_DestZ - 0.5) < 0.1) 
	{ 
		m_fPosZ = m_DestZ + 0.5; 
		m_fPosX = m_DestX + 0.5; 
		m_bStateOver = true; 
	} 
} 
 
void Char::OnTalk(float fTime) 
{ 
 
} 
 
void Char::Update(float fTime) 
{ 
	if(m_bStateOver ) 
	{ 
		if(m_StateQueue.empty()) 
		{ 
			m_State = CS_IDLE; 
			m_bActChange = true; 
		} 
		else 
		{ 
			State st; 
			st = m_StateQueue.front(); 
			m_StateQueue.pop_front(); 
			m_State = st.CharState; 
			m_DestDir = st.DestDir; 
			m_DestX = st.DestX; 
			m_DestZ = st.DestZ; 
			m_pAimChar = st.pAimChar; 
			m_bActChange = true; 
			m_bStateOver = false; 
		} 
	} 
 
	if(m_State == CS_IDLE) 
	{ 
		OnIdle(fTime); 
	} 
	else if(m_State == CS_TURN) 
	{ 
		OnTurn(fTime); 
	} 
	else if(m_State == CS_WALK) 
	{ 
		OnWalk(fTime); 
	}	 
	else if(m_State == CS_RUN) 
	{ 
		OnRun(fTime); 
	} 
	else if(m_State == CS_ATTACK) 
	{ 
		OnAttack(fTime); 
	} 
}