movemanager.cpp

墨香最新私服

// MoveManager.cpp: implementation of the CMoveManager class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "MoveManager.h"
#include "Object.h"
#include "Hero.h"
#include "ObjectManager.h"
#include "ObjectStateManager.h"
#include "GameResourceManager.h"
#include "KyungGongManager.h"
#include "GameIn.h"

#include ".\Engine\EngineObject.h"
#include "MHMap.h"

#include "MovePoint.h"

#include "CAction.h"
#include "ActionTarget.h"


#include "CharStateDialog.h"
#include "PathManager.h"
#include "TileManager.h"
#include "PartyIconManager.h"

#ifdef _GMTOOL_
#include "GMToolManager.h"
#endif


//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
GLOBALTON(CMoveManager)
CMoveManager::CMoveManager()
{

}

CMoveManager::~CMoveManager()
{

}

void CMoveManager::InitMove(CObject* pObject,BASEMOVE_INFO* pMoveInfo,float AngleDeg)
{
	pObject->m_RotateInfo.Angle.SetAngleDeg(AngleDeg);
	pObject->m_RotateInfo.bRotating = FALSE;

	if(pMoveInfo)
	{
		memcpy(&pObject->m_MoveInfo,pMoveInfo,sizeof(BASEMOVE_INFO));
		if(pMoveInfo->bMoving)
		{
			//StartMove(pObject,gCurTime,&pMoveInfo->TargetPosition);
			StartMoveEx(pObject,NULL, gCurTime);
		}
	}
	else
	{
		memset(&pObject->m_MoveInfo,0,sizeof(BASEMOVE_INFO));
	}
	pObject->m_MoveInfo.m_bLastMoving = FALSE;

	pObject->SetPosition(&pObject->m_MoveInfo.CurPosition);

	if(pObject->GetObjectKind() == eObjectKind_Player)
	{
		((CPlayer*)pObject)->SetBaseMotion();
	}
}

void CMoveManager::SetPosition(CObject* pObject,VECTOR3* pPos)
{
	// Move_bMoving捞 TRUE 捞 酒匆锭俊父 啊瓷.. ASSERT(Move_bMoving == FALSE); 吧绢滴磊
	//YH2DO
	//ASSERT(pObject->m_MoveInfo.bMoving == FALSE);
	pObject->m_MoveInfo.CurPosition = *pPos;
	pObject->SetPosition(pPos);
}

void CMoveManager::EndYMove(CObject* pObject)
{
	pObject->m_bIsYMoving = FALSE;
	pObject->GetEngineObject()->ApplyHeightField(TRUE);
}

void CMoveManager::EndMove(CObject* pObject)
{
	if(pObject->GetState() == eObjectState_Move)
		OBJECTSTATEMGR->EndObjectState(pObject,eObjectState_Move);

	pObject->m_MoveInfo.m_bEffectMoving = FALSE;
	pObject->m_MoveInfo.bMoving = FALSE;
	pObject->m_MoveInfo.InitTargetPosition();

	if(pObject->m_MoveInfo.KyungGongIdx)
	{
		if(pObject == HERO)
			ToggleHeroKyungGongMode();
	}
}

// 何盒 鸥百 诀单捞飘 
int CMoveManager::TargetUpdate(CObject* pObject, MOVE_INFO * pMoveInfo, VECTOR3 * TargetPos)
{
	//VECTOR3 * TargetPos = &pMoveInfo->TargetPositions[pMoveInfo->CurTargetPositionIdx];
	// 鸥百 芭府狼 钦
	float dx = TargetPos->x - pMoveInfo->CurPosition.x;
	float dz = TargetPos->z - pMoveInfo->CurPosition.z;
	float Distance = sqrtf(dx*dx+dz*dz);
	if(Distance <= 0.01)
	{
		EndMove(pObject);
		return 1;
	}

	float Speed = pObject->GetMoveSpeed();
	float ttt = Speed / Distance;

	pMoveInfo->Move_StartTime			= gCurTime;
	pMoveInfo->Move_StartPosition		= pMoveInfo->CurPosition;
	pMoveInfo->Move_Direction.x			= dx*ttt;
	pMoveInfo->Move_Direction.y			= 0;
	pMoveInfo->Move_Direction.z			= dz*ttt;
	pMoveInfo->Move_EstimateMoveTime	= Speed==0 ? 999999999 : Distance / Speed;

	return 0;
}
void CMoveManager::StartMoveEx(CObject* pObject, VECTOR3* pStartPos ,DWORD CurTime)
{
	//YH 阁胶磐 脾绰巴锭巩俊 林籍贸府窃
	//CalcPositionEx(pObject, CurTime);
	if(pObject->GetMoveSpeed() == 0 && pStartPos)
	{
		if(IsMoving(pObject))
			EndMove(pObject);
		SetPosition(pObject,pStartPos);
		return;
	}

	ASSERT( pObject->m_MoveInfo.GetCurTargetPosIdx() <= pObject->m_MoveInfo.GetMaxTargetPosIdx() );	//0000
	StartMoveEx(pObject, CurTime, pObject->m_MoveInfo.GetTargetPosition(pObject->m_MoveInfo.GetCurTargetPosIdx()));
}

void CMoveManager::StartMoveEx(CObject* pObject, DWORD CurTime, VECTOR3 * pTargetPos)
{
	MOVE_INFO* pMoveInfo = &pObject->m_MoveInfo;
	
	if(pObject->GetState() == eObjectState_Die)
	{
		pMoveInfo->bMoving = FALSE;
		return;
	}

	if(pObject->m_bIsYMoving)
	{
		EndYMove(pObject);
	}

	pMoveInfo->bMoving = TRUE;
	pObject->m_MoveInfo.m_bEffectMoving = FALSE;
	
	if(TargetUpdate(pObject, pMoveInfo, pTargetPos) != 0)
	{
		return;
	}
	
	float TargetAngle = RADTODEG(VECTORTORAD(pMoveInfo->Move_Direction));
	pObject->m_RotateInfo.Angle.SetTargetDeg(TargetAngle);
	float fChangedAngle = pObject->m_RotateInfo.Angle.GetChangeAmountDeg();
	if(fChangedAngle < 0)
		fChangedAngle*=-1.f;
	pObject->m_RotateInfo.EstimatedRotateTime = 0.1f + fChangedAngle * 0.2f / 180.f;
	pObject->m_RotateInfo.Rotate_StartTime = CurTime;
	pObject->m_RotateInfo.bRotating = TRUE;
	

	if(pObject->GetState() != eObjectState_Move)
	{
		if(OBJECTSTATEMGR->StartObjectState(pObject,eObjectState_Move) == TRUE)
			OBJECTSTATEMGR->EndObjectState(pObject,eObjectState_Move,(DWORD)(pMoveInfo->Move_EstimateMoveTime*1000));		
	}
	else
	{
		pObject->SetMotionInState(eObjectState_Move);
		OBJECTSTATEMGR->EndObjectState(pObject,eObjectState_Move,(DWORD)(pMoveInfo->Move_EstimateMoveTime*1000));
	}
}

#define MOVESKIPCOUNT2	1
BOOL CMoveManager::CalcPositionEx(CObject* pObject,DWORD CurTime)
{
	MOVE_INFO* pMoveInfo = &pObject->m_MoveInfo;
	
	if(pMoveInfo->bMoving)
	{
		if(IsGameSlow() == TRUE && pObject != HERO)
		{
			if(pObject->m_bMoveSkipCount < MOVESKIPCOUNT2)
			{
				++pObject->m_bMoveSkipCount;
				return FALSE;
			}
			else
				pObject->m_bMoveSkipCount = 0;
		}

		BOOL bVal = FALSE;
		float fMoveTime = ((CurTime - pMoveInfo->Move_StartTime)*0.001f);
		if(pMoveInfo->Move_EstimateMoveTime < fMoveTime)
		{
			// 促澜 鸥百栏肺 函版
			if(pMoveInfo->GetCurTargetPosIdx()< pMoveInfo->GetMaxTargetPosIdx()- 1)
			{
				ASSERT( pMoveInfo->GetCurTargetPosIdx() <= MAX_CHARTARGETPOSBUF_SIZE );	//0000
				pMoveInfo->CurPosition.x = pMoveInfo->GetTargetPosition(pMoveInfo->GetCurTargetPosIdx())->x;
				pMoveInfo->CurPosition.z = pMoveInfo->GetTargetPosition(pMoveInfo->GetCurTargetPosIdx())->z;
				pMoveInfo->SetCurTargetPosIdx(pMoveInfo->GetCurTargetPosIdx()+1);
				ASSERT( pMoveInfo->GetCurTargetPosIdx() <= MAX_CHARTARGETPOSBUF_SIZE );	//0000
				StartMoveEx(pObject, CurTime, pMoveInfo->GetTargetPosition(pMoveInfo->GetCurTargetPosIdx()));
			}
			else
			{
				ASSERT( pMoveInfo->GetCurTargetPosIdx() <= MAX_CHARTARGETPOSBUF_SIZE );	//0000
				pMoveInfo->CurPosition.x = pMoveInfo->GetTargetPosition(pMoveInfo->GetCurTargetPosIdx())->x;
				pMoveInfo->CurPosition.z = pMoveInfo->GetTargetPosition(pMoveInfo->GetCurTargetPosIdx())->z;
				bVal = TRUE;
			}
		}
		else
		{
			pMoveInfo->CurPosition.x = pMoveInfo->Move_StartPosition.x + pMoveInfo->Move_Direction.x * fMoveTime;
			pMoveInfo->CurPosition.z = pMoveInfo->Move_StartPosition.z + pMoveInfo->Move_Direction.z * fMoveTime;
		}

		pObject->SetPosition(&pObject->m_MoveInfo.CurPosition);

		return bVal;
	}


	return FALSE;
}
/*

// 捞悼吝牢 惑怕肺 钎矫窍绊 矫累瘤痢苞 场瘤痢阑 扁撅秦初绰促.
// 捞悼矫累矫埃档 扁撅秦初绰促.
// 泅犁困摹甫 拌魂秦毫辑 StartPos 尔 瞒捞啊 腹捞 唱搁 炼摹-_-;甫 秒茄促.
void CMoveManager::StartMove(CObject* pObject,DWORD CurTime,VECTOR3* TargetPos)
{
	MOVE_INFO* pMoveInfo = &pObject->m_MoveInfo;	
	if(pObject->m_bIsYMoving)
	{
		EndYMove(pObject);
	}


	pMoveInfo->bMoving = TRUE;

	float Speed = pObject->GetMoveSpeed();
	
	pMoveInfo->Move_StartTime = CurTime;

	// 咯矾俺狼 鸥百 贸府
	pMoveInfo->Move_StartPosition.x = pMoveInfo->CurPosition.x;
	pMoveInfo->Move_StartPosition.z = pMoveInfo->CurPosition.z;
	pMoveInfo->TargetPosition.x = TargetPos->x;
	pMoveInfo->TargetPosition.z = TargetPos->z;
	pMoveInfo->Move_StartPosition.y = 0;
	pMoveInfo->TargetPosition.y = 0;

	// 鸥百 芭府狼 钦
	float dx = pMoveInfo->TargetPosition.x - pMoveInfo->Move_StartPosition.x;
	float dz = pMoveInfo->TargetPosition.z - pMoveInfo->Move_StartPosition.z;
	float Distance = sqrtf(dx*dx+dz*dz);
	if(Distance <= 0.01)
	{
		pMoveInfo->bMoving = FALSE;
		return;
	}
	float ttt = Speed / Distance;

	// 咯矾 鸥百狼 规氢 汲沥 ( 硅凯趣篮 且锭付促 悸泼? )
	pMoveInfo->Move_Direction.x = dx*ttt;
	pMoveInfo->Move_Direction.y = 0;
	pMoveInfo->Move_Direction.z = dz*ttt;
	// 抗惑 矫埃 汲沥
	pMoveInfo->Move_EstimateMoveTime = Distance / Speed;
	
	pObject->m_MoveInfo.CurPosition.y = 0;
	float TargetAngle = RADTODEG(VECTORTORAD(pMoveInfo->Move_Direction));
	pObject->m_RotateInfo.Angle.SetTargetDeg(TargetAngle);
	float fChangedAngle = pObject->m_RotateInfo.Angle.GetChangeAmountDeg();
	if(fChangedAngle < 0)
		fChangedAngle*=-1.f;
	pObject->m_RotateInfo.EstimatedRotateTime = 0.1f + fChangedAngle * 0.2f / 180.f;
	pObject->m_RotateInfo.Rotate_StartTime = CurTime;
	pObject->m_RotateInfo.bRotating = TRUE;

	if(pObject->GetState() != eObjectState_Move)
		OBJECTSTATEMGR->StartObjectState(pObject,eObjectState_Move);
	OBJECTSTATEMGR->EndObjectState(pObject,eObjectState_Move,(DWORD)(pMoveInfo->Move_EstimateMoveTime*1000));
}

// 泅犁 困摹甫 拌魂秦辑 Move_Position俊 悸泼窍绊 逞败霖促.
// 拌加秦辑 拌魂窍瘤 臼绊 鞘夸且锭父 拌魂茄促.
// Move_bMoving捞 FALSE捞搁 官风 府畔茄促.
// 矫埃 函荐俊 措茄 OverFlow甫 绊妨秦具 茄促.
#define MOVESKIPCOUNT	1
BOOL CMoveManager::CalcPosition(CObject* pObject,DWORD CurTime)
{
	if(pObject->m_MoveInfo.bMoving)
	{
		if(IsGameSlow() == TRUE)
		{
			if(pObject->m_bMoveSkipCount < MOVESKIPCOUNT)
			{
				++pObject->m_bMoveSkipCount;
				return FALSE;
			}
			else
				pObject->m_bMoveSkipCount = 0;
		}

		BOOL bVal = FALSE;
		float fMoveTime = ((CurTime - pObject->m_MoveInfo.Move_StartTime)*0.001f);
		if(pObject->m_MoveInfo.Move_EstimateMoveTime < fMoveTime)
		{
			pObject->m_MoveInfo.CurPosition.x = pObject->m_MoveInfo.TargetPosition.x;
			pObject->m_MoveInfo.CurPosition.z = pObject->m_MoveInfo.TargetPosition.z;
			bVal = TRUE;
		}
		else
		{
			pObject->m_MoveInfo.CurPosition.x = pObject->m_MoveInfo.Move_StartPosition.x + 
				pObject->m_MoveInfo.Move_Direction.x * fMoveTime;
			pObject->m_MoveInfo.CurPosition.z = pObject->m_MoveInfo.Move_StartPosition.z + 
				pObject->m_MoveInfo.Move_Direction.z * fMoveTime;
		}
		
		pObject->SetPosition(&pObject->m_MoveInfo.CurPosition);
		return bVal;
	}

	return FALSE;
}
*/
BOOL CMoveManager::CalcYPosition(CObject* pObject,DWORD CurTime)
{
	if(pObject->m_bIsYMoving)
	{
		MOVE_INFO* pMoveInfo = &pObject->m_MoveInfo;

		BOOL bVal = FALSE;
		float fMoveTime = ((CurTime - pMoveInfo->Move_StartTime)*0.001f);
		if(pMoveInfo->Move_EstimateMoveTime < fMoveTime)
		{
			pMoveInfo->CurPosition.y = pMoveInfo->GetTargetPosition(pMoveInfo->GetCurTargetPosIdx())->y;
			bVal = TRUE;
		}
		else
		{
			pMoveInfo->CurPosition.y = pMoveInfo->Move_StartPosition.y + pMoveInfo->Move_Direction.y * fMoveTime;
		}
		
		pObject->SetPosition(&pMoveInfo->CurPosition);

		return bVal;
	}

	return FALSE;
}

void CMoveManager::CalcAngle(CObject* pObject,DWORD CurTime)
{	
	if(pObject->m_RotateInfo.bRotating)
	{
		float fRotateTime = ((CurTime - pObject->m_RotateInfo.Rotate_StartTime)*0.001f);
		if(fRotateTime >= pObject->m_RotateInfo.EstimatedRotateTime)
		{
			pObject->m_RotateInfo.Angle.Process(1);
			pObject->m_RotateInfo.bRotating = FALSE;
		}
		else
		{
			pObject->m_RotateInfo.Angle.Process(fRotateTime / pObject->m_RotateInfo.EstimatedRotateTime);
		}
		pObject->SetAngle(pObject->m_RotateInfo.Angle.ToRad());
	}
}

void CMoveManager::MoveProcess(CObject* pObject)
{
	MOVE_INFO* pMoveInfo = &pObject->m_MoveInfo;
	if(pObject->m_bIsYMoving)
	{
		if(CalcYPosition(pObject,gCurTime) == TRUE)
			EndYMove(pObject);
	}
	else
	{
		if(CalcPositionEx(pObject,gCurTime) == TRUE)
			EndMove(pObject);
	}
	CalcAngle(pObject,gCurTime);
	pMoveInfo->m_bLastMoving = pMoveInfo->bMoving;
}

void CMoveManager::SetHeroTarget(VECTOR3* pPos,BOOL bMousePointDisplay)
{
	CHero* pHero = OBJECTMGR->GetHero();

	if(pHero->IsInSpecialState(eSpecialState_Stun))
		return;

	if( pHero->GetState() != eObjectState_None &&
		pHero->GetState() != eObjectState_Move &&
		pHero->GetState() != eObjectState_TiedUp_CanMove &&
		pHero->GetState() != eObjectState_Immortal  )
	{
		if( pHero->GetState() == eObjectState_Society )
		{
			if( pHero->EndSocietyAct() == FALSE )
			{
				CAction act;
				act.InitMoveAction(pPos);
				pHero->SetNextAction(&act);
				pHero->DisableAutoAttack();
				return;
			}
		}
		else
		{
			CAction act;
			act.InitMoveAction(pPos);
			pHero->SetNextAction(&act);
			pHero->DisableAutoAttack();
			return;
		}
	}
	if( pHero->GetState() == eObjectState_Move &&
		pHero->GetEngineObject()->GetCurMotion() == pHero->m_ObjectState.State_End_Motion)
		return;

	
	if(IsMoving(pHero))
		CalcPositionEx(pHero,gCurTime);
	
	//////////////////////////////////////////////////////////////////////////
	// 50cm 鸥老狼 吝居俊 辑霸 茄促.
	/*
	pPos->x = int(pPos->x / TileWidth) * TileWidth + TileWidth * 0.5f;
	pPos->z = int(pPos->z / TileWidth) * TileWidth + TileWidth * 0.5f;
	*/
	pPos->x = (int(pPos->x / TILECOLLISON_DETAIL) + 0.5f) * TILECOLLISON_DETAIL;
	pPos->y = 0;
	pPos->z = (int(pPos->z / TILECOLLISON_DETAIL) + 0.5f) * TILECOLLISON_DETAIL;
	//////////////////////////////////////////////////////////////////////////
	
	



	pHero->m_MoveInfo.InitTargetPosition();
	switch(PATHMGR->GetPath(&pHero->m_MoveInfo.CurPosition,pPos,pHero->m_MoveInfo.GetTargetPositionArray(), MAX_CHARTARGETPOSBUF_SIZE, pHero->m_MoveInfo.GetMaxTargetPosIdxRef(), pHero, FALSE, 100))
	{
	case PATH_BLOCKFAILED:
	case PATH_FAILED:
		//__asm int 3;
		return;
	}
	WORD count = pHero->m_MoveInfo.GetMaxTargetPosIdx();

	// 辨茫扁 抛胶飘 侩
	/*
	EFFECTMGR->RemoveAllEffect();
	for(int k = 0 ; k < count ; ++k)
	{
		EFFECTMGR->StartEffectProcess(1, HERO, 0,0,0,EFFECT_FLAG_ABSOLUTEPOS, &pHero->m_MoveInfo.TargetPositions[k]);
	}*/


	if(bMousePointDisplay)
		MOVEPOINT->SetPoint(pPos);

	// jsd 
	if( count == 0 )
		return;
	else if( count == 1 )
	{
		MOVE_ONETARGETPOS msg;
		msg.Category = MP_MOVE;
		msg.Protocol = MP_MOVE_ONETARGET;
		msg.dwObjectID = HEROID;
		msg.dwMoverID = HEROID;
		msg.SetStartPos( &pHero->m_MoveInfo.CurPosition );
		msg.SetTargetPos( pHero->m_MoveInfo.GetTargetPosition(0) );

		NETWORK->Send(&msg,msg.GetSize());
	}
	else
	{
		MOVE_TARGETPOS msg;
		msg.Init();
		msg.Category = MP_MOVE;
		msg.Protocol = MP_MOVE_TARGET;
		msg.dwObjectID = HEROID;
		msg.dwMoverID = HEROID;
		msg.SetStartPos(&pHero->m_MoveInfo.CurPosition);
		//msg.tpos.Compress(&TargetPos);
		ASSERT( count <= MAX_CHARTARGETPOSBUF_SIZE );	//0000
		for(int i=0;i<count;++i)
		{
			msg.AddTargetPos(pHero->m_MoveInfo.GetTargetPosition(i));
		}

		NETWORK->Send(&msg,msg.GetSize());
	}

	//StartMove(pHero,gCurTime,&TargetPos);
	StartMoveEx(pHero,NULL,gCurTime);
}

void CMoveManager::SetLookatPos(CObject* pObject, VECTOR3* pPos,float TurnDuration, DWORD CurTime)
{
	pObject->m_MoveInfo.CurPosition.y = 0;
	VECTOR3 PositionGap = *pPos - pObject->m_MoveInfo.CurPosition;
	float Distance = VECTOR3Length(&PositionGap);
	if(Distance == 0)
		return;
	VECTOR3 TDirection = PositionGap / Distance;
	float angle = RADTODEG(VECTORTORAD(TDirection));
	SetAngle(pObject,angle,TurnDuration);
}

void CMoveManager::SetAngle(CObject* pObject,float AngleDeg,float TurnDuration)
{
	if(TurnDuration == 0)
	{
		pObject->m_RotateInfo.Angle.SetAngleDeg(AngleDeg);
		pObject->m_RotateInfo.bRotating = FALSE;
		pObject->SetAngle(pObject->m_RotateInfo.Angle.ToRad());
	}
	else
	{
		pObject->m_RotateInfo.Angle.SetAngleDeg(AngleDeg);
		pObject->m_RotateInfo.EstimatedRotateTime = TurnDuration;
		pObject->m_RotateInfo.Rotate_StartTime = gCurTime;
		pObject->m_RotateInfo.bRotating = TRUE;
	}
}

void CMoveManager::SetHeroActionMove(CActionTarget* pTarget,CAction* pAction)
{
	VECTOR3* pTargetPos = pTarget->GetTargetPosition();
	if(pTargetPos == NULL)
		return;
	SetHeroTarget(pTargetPos,FALSE);

	CHero* pHero = OBJECTMGR->GetHero();
	pHero->SetMovingAction(pAction);